@manifest-network/manifestjs 2.1.0

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

@@ -0,0 +1,1123 @@
+import * as _122 from "./tokenfactory/v1beta1/authorityMetadata";
+import * as _123 from "./tokenfactory/v1beta1/genesis";
+import * as _124 from "./tokenfactory/v1beta1/params";
+import * as _125 from "./tokenfactory/v1beta1/query";
+import * as _126 from "./tokenfactory/v1beta1/tx";
+import * as _249 from "./tokenfactory/v1beta1/query.lcd";
+import * as _250 from "./tokenfactory/v1beta1/query.rpc.Query";
+import * as _251 from "./tokenfactory/v1beta1/tx.rpc.msg";
+export declare namespace osmosis {
+    namespace tokenfactory {
+        const v1beta1: {
+            MsgClientImpl: typeof _251.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _251.MsgClientImpl;
+            QueryClientImpl: typeof _250.QueryClientImpl;
+            createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                params(request?: _125.QueryParamsRequest): Promise<_125.QueryParamsResponse>;
+                denomAuthorityMetadata(request: _125.QueryDenomAuthorityMetadataRequest): Promise<_125.QueryDenomAuthorityMetadataResponse>;
+                denomsFromCreator(request: _125.QueryDenomsFromCreatorRequest): Promise<_125.QueryDenomsFromCreatorResponse>;
+                denomsFromAdmin(request: _125.QueryDenomsFromAdminRequest): Promise<_125.QueryDenomsFromAdminResponse>;
+            };
+            LCDQueryClient: typeof _249.LCDQueryClient;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    createDenom(value: _126.MsgCreateDenom): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    mint(value: _126.MsgMint): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    burn(value: _126.MsgBurn): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    changeAdmin(value: _126.MsgChangeAdmin): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    setDenomMetadata(value: _126.MsgSetDenomMetadata): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    forceTransfer(value: _126.MsgForceTransfer): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    updateParams(value: _126.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                };
+                withTypeUrl: {
+                    createDenom(value: _126.MsgCreateDenom): {
+                        typeUrl: string;
+                        value: _126.MsgCreateDenom;
+                    };
+                    mint(value: _126.MsgMint): {
+                        typeUrl: string;
+                        value: _126.MsgMint;
+                    };
+                    burn(value: _126.MsgBurn): {
+                        typeUrl: string;
+                        value: _126.MsgBurn;
+                    };
+                    changeAdmin(value: _126.MsgChangeAdmin): {
+                        typeUrl: string;
+                        value: _126.MsgChangeAdmin;
+                    };
+                    setDenomMetadata(value: _126.MsgSetDenomMetadata): {
+                        typeUrl: string;
+                        value: _126.MsgSetDenomMetadata;
+                    };
+                    forceTransfer(value: _126.MsgForceTransfer): {
+                        typeUrl: string;
+                        value: _126.MsgForceTransfer;
+                    };
+                    updateParams(value: _126.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _126.MsgUpdateParams;
+                    };
+                };
+                toJSON: {
+                    createDenom(value: _126.MsgCreateDenom): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            subdenom: string;
+                        };
+                    };
+                    mint(value: _126.MsgMint): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            amount: {
+                                denom: string;
+                                amount: string;
+                            };
+                            mintToAddress: string;
+                        };
+                    };
+                    burn(value: _126.MsgBurn): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            amount: {
+                                denom: string;
+                                amount: string;
+                            };
+                            burnFromAddress: string;
+                        };
+                    };
+                    changeAdmin(value: _126.MsgChangeAdmin): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            denom: string;
+                            newAdmin: string;
+                        };
+                    };
+                    setDenomMetadata(value: _126.MsgSetDenomMetadata): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            metadata: {
+                                description: string;
+                                denomUnits: {
+                                    denom: string;
+                                    exponent: number;
+                                    aliases: string[];
+                                }[];
+                                base: string;
+                                display: string;
+                                name: string;
+                                symbol: string;
+                                uri: string;
+                                uriHash: string;
+                            };
+                        };
+                    };
+                    forceTransfer(value: _126.MsgForceTransfer): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            amount: {
+                                denom: string;
+                                amount: string;
+                            };
+                            transferFromAddress: string;
+                            transferToAddress: string;
+                        };
+                    };
+                    updateParams(value: _126.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            params: {
+                                sendEnabled: {
+                                    denom: string;
+                                    enabled: boolean;
+                                }[];
+                                defaultSendEnabled: boolean;
+                            };
+                        };
+                    };
+                };
+                fromJSON: {
+                    createDenom(value: any): {
+                        typeUrl: string;
+                        value: _126.MsgCreateDenom;
+                    };
+                    mint(value: any): {
+                        typeUrl: string;
+                        value: _126.MsgMint;
+                    };
+                    burn(value: any): {
+                        typeUrl: string;
+                        value: _126.MsgBurn;
+                    };
+                    changeAdmin(value: any): {
+                        typeUrl: string;
+                        value: _126.MsgChangeAdmin;
+                    };
+                    setDenomMetadata(value: any): {
+                        typeUrl: string;
+                        value: _126.MsgSetDenomMetadata;
+                    };
+                    forceTransfer(value: any): {
+                        typeUrl: string;
+                        value: _126.MsgForceTransfer;
+                    };
+                    updateParams(value: any): {
+                        typeUrl: string;
+                        value: _126.MsgUpdateParams;
+                    };
+                };
+                fromPartial: {
+                    createDenom(value: _126.MsgCreateDenom): {
+                        typeUrl: string;
+                        value: _126.MsgCreateDenom;
+                    };
+                    mint(value: _126.MsgMint): {
+                        typeUrl: string;
+                        value: _126.MsgMint;
+                    };
+                    burn(value: _126.MsgBurn): {
+                        typeUrl: string;
+                        value: _126.MsgBurn;
+                    };
+                    changeAdmin(value: _126.MsgChangeAdmin): {
+                        typeUrl: string;
+                        value: _126.MsgChangeAdmin;
+                    };
+                    setDenomMetadata(value: _126.MsgSetDenomMetadata): {
+                        typeUrl: string;
+                        value: _126.MsgSetDenomMetadata;
+                    };
+                    forceTransfer(value: _126.MsgForceTransfer): {
+                        typeUrl: string;
+                        value: _126.MsgForceTransfer;
+                    };
+                    updateParams(value: _126.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _126.MsgUpdateParams;
+                    };
+                };
+            };
+            AminoConverter: {
+                "/osmosis.tokenfactory.v1beta1.MsgCreateDenom": {
+                    aminoType: string;
+                    toAmino: (message: _126.MsgCreateDenom) => _126.MsgCreateDenomAmino;
+                    fromAmino: (object: _126.MsgCreateDenomAmino) => _126.MsgCreateDenom;
+                };
+                "/osmosis.tokenfactory.v1beta1.MsgMint": {
+                    aminoType: string;
+                    toAmino: (message: _126.MsgMint) => _126.MsgMintAmino;
+                    fromAmino: (object: _126.MsgMintAmino) => _126.MsgMint;
+                };
+                "/osmosis.tokenfactory.v1beta1.MsgBurn": {
+                    aminoType: string;
+                    toAmino: (message: _126.MsgBurn) => _126.MsgBurnAmino;
+                    fromAmino: (object: _126.MsgBurnAmino) => _126.MsgBurn;
+                };
+                "/osmosis.tokenfactory.v1beta1.MsgChangeAdmin": {
+                    aminoType: string;
+                    toAmino: (message: _126.MsgChangeAdmin) => _126.MsgChangeAdminAmino;
+                    fromAmino: (object: _126.MsgChangeAdminAmino) => _126.MsgChangeAdmin;
+                };
+                "/osmosis.tokenfactory.v1beta1.MsgSetDenomMetadata": {
+                    aminoType: string;
+                    toAmino: (message: _126.MsgSetDenomMetadata) => _126.MsgSetDenomMetadataAmino;
+                    fromAmino: (object: _126.MsgSetDenomMetadataAmino) => _126.MsgSetDenomMetadata;
+                };
+                "/osmosis.tokenfactory.v1beta1.MsgForceTransfer": {
+                    aminoType: string;
+                    toAmino: (message: _126.MsgForceTransfer) => _126.MsgForceTransferAmino;
+                    fromAmino: (object: _126.MsgForceTransferAmino) => _126.MsgForceTransfer;
+                };
+                "/osmosis.tokenfactory.v1beta1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _126.MsgUpdateParams) => _126.MsgUpdateParamsAmino;
+                    fromAmino: (object: _126.MsgUpdateParamsAmino) => _126.MsgUpdateParams;
+                };
+            };
+            MsgCreateDenom: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgCreateDenom;
+                isSDK(o: any): o is _126.MsgCreateDenomSDKType;
+                isAmino(o: any): o is _126.MsgCreateDenomAmino;
+                encode(message: _126.MsgCreateDenom, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgCreateDenom;
+                fromJSON(object: any): _126.MsgCreateDenom;
+                toJSON(message: _126.MsgCreateDenom): import("..").JsonSafe<_126.MsgCreateDenom>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgCreateDenom>, I>>(object: I): _126.MsgCreateDenom;
+                fromAmino(object: _126.MsgCreateDenomAmino): _126.MsgCreateDenom;
+                toAmino(message: _126.MsgCreateDenom): _126.MsgCreateDenomAmino;
+                fromAminoMsg(object: _126.MsgCreateDenomAminoMsg): _126.MsgCreateDenom;
+                toAminoMsg(message: _126.MsgCreateDenom): _126.MsgCreateDenomAminoMsg;
+                fromProtoMsg(message: _126.MsgCreateDenomProtoMsg): _126.MsgCreateDenom;
+                toProto(message: _126.MsgCreateDenom): Uint8Array;
+                toProtoMsg(message: _126.MsgCreateDenom): _126.MsgCreateDenomProtoMsg;
+            };
+            MsgCreateDenomResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgCreateDenomResponse;
+                isSDK(o: any): o is _126.MsgCreateDenomResponseSDKType;
+                isAmino(o: any): o is _126.MsgCreateDenomResponseAmino;
+                encode(message: _126.MsgCreateDenomResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgCreateDenomResponse;
+                fromJSON(object: any): _126.MsgCreateDenomResponse;
+                toJSON(message: _126.MsgCreateDenomResponse): import("..").JsonSafe<_126.MsgCreateDenomResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgCreateDenomResponse>, I>>(object: I): _126.MsgCreateDenomResponse;
+                fromAmino(object: _126.MsgCreateDenomResponseAmino): _126.MsgCreateDenomResponse;
+                toAmino(message: _126.MsgCreateDenomResponse): _126.MsgCreateDenomResponseAmino;
+                fromAminoMsg(object: _126.MsgCreateDenomResponseAminoMsg): _126.MsgCreateDenomResponse;
+                toAminoMsg(message: _126.MsgCreateDenomResponse): _126.MsgCreateDenomResponseAminoMsg;
+                fromProtoMsg(message: _126.MsgCreateDenomResponseProtoMsg): _126.MsgCreateDenomResponse;
+                toProto(message: _126.MsgCreateDenomResponse): Uint8Array;
+                toProtoMsg(message: _126.MsgCreateDenomResponse): _126.MsgCreateDenomResponseProtoMsg;
+            };
+            MsgMint: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgMint;
+                isSDK(o: any): o is _126.MsgMintSDKType;
+                isAmino(o: any): o is _126.MsgMintAmino;
+                encode(message: _126.MsgMint, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgMint;
+                fromJSON(object: any): _126.MsgMint;
+                toJSON(message: _126.MsgMint): import("..").JsonSafe<_126.MsgMint>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgMint>, I>>(object: I): _126.MsgMint;
+                fromAmino(object: _126.MsgMintAmino): _126.MsgMint;
+                toAmino(message: _126.MsgMint): _126.MsgMintAmino;
+                fromAminoMsg(object: _126.MsgMintAminoMsg): _126.MsgMint;
+                toAminoMsg(message: _126.MsgMint): _126.MsgMintAminoMsg;
+                fromProtoMsg(message: _126.MsgMintProtoMsg): _126.MsgMint;
+                toProto(message: _126.MsgMint): Uint8Array;
+                toProtoMsg(message: _126.MsgMint): _126.MsgMintProtoMsg;
+            };
+            MsgMintResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgMintResponse;
+                isSDK(o: any): o is _126.MsgMintResponseSDKType;
+                isAmino(o: any): o is _126.MsgMintResponseAmino;
+                encode(_: _126.MsgMintResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgMintResponse;
+                fromJSON(_: any): _126.MsgMintResponse;
+                toJSON(_: _126.MsgMintResponse): import("..").JsonSafe<_126.MsgMintResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgMintResponse>, I>>(_: I): _126.MsgMintResponse;
+                fromAmino(_: _126.MsgMintResponseAmino): _126.MsgMintResponse;
+                toAmino(_: _126.MsgMintResponse): _126.MsgMintResponseAmino;
+                fromAminoMsg(object: _126.MsgMintResponseAminoMsg): _126.MsgMintResponse;
+                toAminoMsg(message: _126.MsgMintResponse): _126.MsgMintResponseAminoMsg;
+                fromProtoMsg(message: _126.MsgMintResponseProtoMsg): _126.MsgMintResponse;
+                toProto(message: _126.MsgMintResponse): Uint8Array;
+                toProtoMsg(message: _126.MsgMintResponse): _126.MsgMintResponseProtoMsg;
+            };
+            MsgBurn: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgBurn;
+                isSDK(o: any): o is _126.MsgBurnSDKType;
+                isAmino(o: any): o is _126.MsgBurnAmino;
+                encode(message: _126.MsgBurn, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgBurn;
+                fromJSON(object: any): _126.MsgBurn;
+                toJSON(message: _126.MsgBurn): import("..").JsonSafe<_126.MsgBurn>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgBurn>, I>>(object: I): _126.MsgBurn;
+                fromAmino(object: _126.MsgBurnAmino): _126.MsgBurn;
+                toAmino(message: _126.MsgBurn): _126.MsgBurnAmino;
+                fromAminoMsg(object: _126.MsgBurnAminoMsg): _126.MsgBurn;
+                toAminoMsg(message: _126.MsgBurn): _126.MsgBurnAminoMsg;
+                fromProtoMsg(message: _126.MsgBurnProtoMsg): _126.MsgBurn;
+                toProto(message: _126.MsgBurn): Uint8Array;
+                toProtoMsg(message: _126.MsgBurn): _126.MsgBurnProtoMsg;
+            };
+            MsgBurnResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgBurnResponse;
+                isSDK(o: any): o is _126.MsgBurnResponseSDKType;
+                isAmino(o: any): o is _126.MsgBurnResponseAmino;
+                encode(_: _126.MsgBurnResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgBurnResponse;
+                fromJSON(_: any): _126.MsgBurnResponse;
+                toJSON(_: _126.MsgBurnResponse): import("..").JsonSafe<_126.MsgBurnResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgBurnResponse>, I>>(_: I): _126.MsgBurnResponse;
+                fromAmino(_: _126.MsgBurnResponseAmino): _126.MsgBurnResponse;
+                toAmino(_: _126.MsgBurnResponse): _126.MsgBurnResponseAmino;
+                fromAminoMsg(object: _126.MsgBurnResponseAminoMsg): _126.MsgBurnResponse;
+                toAminoMsg(message: _126.MsgBurnResponse): _126.MsgBurnResponseAminoMsg;
+                fromProtoMsg(message: _126.MsgBurnResponseProtoMsg): _126.MsgBurnResponse;
+                toProto(message: _126.MsgBurnResponse): Uint8Array;
+                toProtoMsg(message: _126.MsgBurnResponse): _126.MsgBurnResponseProtoMsg;
+            };
+            MsgChangeAdmin: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgChangeAdmin;
+                isSDK(o: any): o is _126.MsgChangeAdminSDKType;
+                isAmino(o: any): o is _126.MsgChangeAdminAmino;
+                encode(message: _126.MsgChangeAdmin, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgChangeAdmin;
+                fromJSON(object: any): _126.MsgChangeAdmin;
+                toJSON(message: _126.MsgChangeAdmin): import("..").JsonSafe<_126.MsgChangeAdmin>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgChangeAdmin>, I>>(object: I): _126.MsgChangeAdmin;
+                fromAmino(object: _126.MsgChangeAdminAmino): _126.MsgChangeAdmin;
+                toAmino(message: _126.MsgChangeAdmin): _126.MsgChangeAdminAmino;
+                fromAminoMsg(object: _126.MsgChangeAdminAminoMsg): _126.MsgChangeAdmin;
+                toAminoMsg(message: _126.MsgChangeAdmin): _126.MsgChangeAdminAminoMsg;
+                fromProtoMsg(message: _126.MsgChangeAdminProtoMsg): _126.MsgChangeAdmin;
+                toProto(message: _126.MsgChangeAdmin): Uint8Array;
+                toProtoMsg(message: _126.MsgChangeAdmin): _126.MsgChangeAdminProtoMsg;
+            };
+            MsgChangeAdminResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgChangeAdminResponse;
+                isSDK(o: any): o is _126.MsgChangeAdminResponseSDKType;
+                isAmino(o: any): o is _126.MsgChangeAdminResponseAmino;
+                encode(_: _126.MsgChangeAdminResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgChangeAdminResponse;
+                fromJSON(_: any): _126.MsgChangeAdminResponse;
+                toJSON(_: _126.MsgChangeAdminResponse): import("..").JsonSafe<_126.MsgChangeAdminResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgChangeAdminResponse>, I>>(_: I): _126.MsgChangeAdminResponse;
+                fromAmino(_: _126.MsgChangeAdminResponseAmino): _126.MsgChangeAdminResponse;
+                toAmino(_: _126.MsgChangeAdminResponse): _126.MsgChangeAdminResponseAmino;
+                fromAminoMsg(object: _126.MsgChangeAdminResponseAminoMsg): _126.MsgChangeAdminResponse;
+                toAminoMsg(message: _126.MsgChangeAdminResponse): _126.MsgChangeAdminResponseAminoMsg;
+                fromProtoMsg(message: _126.MsgChangeAdminResponseProtoMsg): _126.MsgChangeAdminResponse;
+                toProto(message: _126.MsgChangeAdminResponse): Uint8Array;
+                toProtoMsg(message: _126.MsgChangeAdminResponse): _126.MsgChangeAdminResponseProtoMsg;
+            };
+            MsgSetDenomMetadata: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgSetDenomMetadata;
+                isSDK(o: any): o is _126.MsgSetDenomMetadataSDKType;
+                isAmino(o: any): o is _126.MsgSetDenomMetadataAmino;
+                encode(message: _126.MsgSetDenomMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgSetDenomMetadata;
+                fromJSON(object: any): _126.MsgSetDenomMetadata;
+                toJSON(message: _126.MsgSetDenomMetadata): import("..").JsonSafe<_126.MsgSetDenomMetadata>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgSetDenomMetadata>, I>>(object: I): _126.MsgSetDenomMetadata;
+                fromAmino(object: _126.MsgSetDenomMetadataAmino): _126.MsgSetDenomMetadata;
+                toAmino(message: _126.MsgSetDenomMetadata): _126.MsgSetDenomMetadataAmino;
+                fromAminoMsg(object: _126.MsgSetDenomMetadataAminoMsg): _126.MsgSetDenomMetadata;
+                toAminoMsg(message: _126.MsgSetDenomMetadata): _126.MsgSetDenomMetadataAminoMsg;
+                fromProtoMsg(message: _126.MsgSetDenomMetadataProtoMsg): _126.MsgSetDenomMetadata;
+                toProto(message: _126.MsgSetDenomMetadata): Uint8Array;
+                toProtoMsg(message: _126.MsgSetDenomMetadata): _126.MsgSetDenomMetadataProtoMsg;
+            };
+            MsgSetDenomMetadataResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgSetDenomMetadataResponse;
+                isSDK(o: any): o is _126.MsgSetDenomMetadataResponseSDKType;
+                isAmino(o: any): o is _126.MsgSetDenomMetadataResponseAmino;
+                encode(_: _126.MsgSetDenomMetadataResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgSetDenomMetadataResponse;
+                fromJSON(_: any): _126.MsgSetDenomMetadataResponse;
+                toJSON(_: _126.MsgSetDenomMetadataResponse): import("..").JsonSafe<_126.MsgSetDenomMetadataResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgSetDenomMetadataResponse>, I>>(_: I): _126.MsgSetDenomMetadataResponse;
+                fromAmino(_: _126.MsgSetDenomMetadataResponseAmino): _126.MsgSetDenomMetadataResponse;
+                toAmino(_: _126.MsgSetDenomMetadataResponse): _126.MsgSetDenomMetadataResponseAmino;
+                fromAminoMsg(object: _126.MsgSetDenomMetadataResponseAminoMsg): _126.MsgSetDenomMetadataResponse;
+                toAminoMsg(message: _126.MsgSetDenomMetadataResponse): _126.MsgSetDenomMetadataResponseAminoMsg;
+                fromProtoMsg(message: _126.MsgSetDenomMetadataResponseProtoMsg): _126.MsgSetDenomMetadataResponse;
+                toProto(message: _126.MsgSetDenomMetadataResponse): Uint8Array;
+                toProtoMsg(message: _126.MsgSetDenomMetadataResponse): _126.MsgSetDenomMetadataResponseProtoMsg;
+            };
+            MsgForceTransfer: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgForceTransfer;
+                isSDK(o: any): o is _126.MsgForceTransferSDKType;
+                isAmino(o: any): o is _126.MsgForceTransferAmino;
+                encode(message: _126.MsgForceTransfer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgForceTransfer;
+                fromJSON(object: any): _126.MsgForceTransfer;
+                toJSON(message: _126.MsgForceTransfer): import("..").JsonSafe<_126.MsgForceTransfer>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgForceTransfer>, I>>(object: I): _126.MsgForceTransfer;
+                fromAmino(object: _126.MsgForceTransferAmino): _126.MsgForceTransfer;
+                toAmino(message: _126.MsgForceTransfer): _126.MsgForceTransferAmino;
+                fromAminoMsg(object: _126.MsgForceTransferAminoMsg): _126.MsgForceTransfer;
+                toAminoMsg(message: _126.MsgForceTransfer): _126.MsgForceTransferAminoMsg;
+                fromProtoMsg(message: _126.MsgForceTransferProtoMsg): _126.MsgForceTransfer;
+                toProto(message: _126.MsgForceTransfer): Uint8Array;
+                toProtoMsg(message: _126.MsgForceTransfer): _126.MsgForceTransferProtoMsg;
+            };
+            MsgForceTransferResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgForceTransferResponse;
+                isSDK(o: any): o is _126.MsgForceTransferResponseSDKType;
+                isAmino(o: any): o is _126.MsgForceTransferResponseAmino;
+                encode(_: _126.MsgForceTransferResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgForceTransferResponse;
+                fromJSON(_: any): _126.MsgForceTransferResponse;
+                toJSON(_: _126.MsgForceTransferResponse): import("..").JsonSafe<_126.MsgForceTransferResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgForceTransferResponse>, I>>(_: I): _126.MsgForceTransferResponse;
+                fromAmino(_: _126.MsgForceTransferResponseAmino): _126.MsgForceTransferResponse;
+                toAmino(_: _126.MsgForceTransferResponse): _126.MsgForceTransferResponseAmino;
+                fromAminoMsg(object: _126.MsgForceTransferResponseAminoMsg): _126.MsgForceTransferResponse;
+                toAminoMsg(message: _126.MsgForceTransferResponse): _126.MsgForceTransferResponseAminoMsg;
+                fromProtoMsg(message: _126.MsgForceTransferResponseProtoMsg): _126.MsgForceTransferResponse;
+                toProto(message: _126.MsgForceTransferResponse): Uint8Array;
+                toProtoMsg(message: _126.MsgForceTransferResponse): _126.MsgForceTransferResponseProtoMsg;
+            };
+            MsgUpdateParams: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgUpdateParams;
+                isSDK(o: any): o is _126.MsgUpdateParamsSDKType;
+                isAmino(o: any): o is _126.MsgUpdateParamsAmino;
+                encode(message: _126.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgUpdateParams;
+                fromJSON(object: any): _126.MsgUpdateParams;
+                toJSON(message: _126.MsgUpdateParams): import("..").JsonSafe<_126.MsgUpdateParams>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgUpdateParams>, I>>(object: I): _126.MsgUpdateParams;
+                fromAmino(object: _126.MsgUpdateParamsAmino): _126.MsgUpdateParams;
+                toAmino(message: _126.MsgUpdateParams): _126.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _126.MsgUpdateParamsAminoMsg): _126.MsgUpdateParams;
+                toAminoMsg(message: _126.MsgUpdateParams): _126.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _126.MsgUpdateParamsProtoMsg): _126.MsgUpdateParams;
+                toProto(message: _126.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _126.MsgUpdateParams): _126.MsgUpdateParamsProtoMsg;
+            };
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _126.MsgUpdateParamsResponse;
+                isSDK(o: any): o is _126.MsgUpdateParamsResponseSDKType;
+                isAmino(o: any): o is _126.MsgUpdateParamsResponseAmino;
+                encode(_: _126.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgUpdateParamsResponse;
+                fromJSON(_: any): _126.MsgUpdateParamsResponse;
+                toJSON(_: _126.MsgUpdateParamsResponse): import("..").JsonSafe<_126.MsgUpdateParamsResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_126.MsgUpdateParamsResponse>, I>>(_: I): _126.MsgUpdateParamsResponse;
+                fromAmino(_: _126.MsgUpdateParamsResponseAmino): _126.MsgUpdateParamsResponse;
+                toAmino(_: _126.MsgUpdateParamsResponse): _126.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _126.MsgUpdateParamsResponseAminoMsg): _126.MsgUpdateParamsResponse;
+                toAminoMsg(message: _126.MsgUpdateParamsResponse): _126.MsgUpdateParamsResponseAminoMsg;
+                fromProtoMsg(message: _126.MsgUpdateParamsResponseProtoMsg): _126.MsgUpdateParamsResponse;
+                toProto(message: _126.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _126.MsgUpdateParamsResponse): _126.MsgUpdateParamsResponseProtoMsg;
+            };
+            QueryParamsRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryParamsRequest;
+                isSDK(o: any): o is _125.QueryParamsRequestSDKType;
+                isAmino(o: any): o is _125.QueryParamsRequestAmino;
+                encode(_: _125.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryParamsRequest;
+                fromJSON(_: any): _125.QueryParamsRequest;
+                toJSON(_: _125.QueryParamsRequest): import("..").JsonSafe<_125.QueryParamsRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryParamsRequest>, I>>(_: I): _125.QueryParamsRequest;
+                fromAmino(_: _125.QueryParamsRequestAmino): _125.QueryParamsRequest;
+                toAmino(_: _125.QueryParamsRequest): _125.QueryParamsRequestAmino;
+                fromAminoMsg(object: _125.QueryParamsRequestAminoMsg): _125.QueryParamsRequest;
+                toAminoMsg(message: _125.QueryParamsRequest): _125.QueryParamsRequestAminoMsg;
+                fromProtoMsg(message: _125.QueryParamsRequestProtoMsg): _125.QueryParamsRequest;
+                toProto(message: _125.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _125.QueryParamsRequest): _125.QueryParamsRequestProtoMsg;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryParamsResponse;
+                isSDK(o: any): o is _125.QueryParamsResponseSDKType;
+                isAmino(o: any): o is _125.QueryParamsResponseAmino;
+                encode(message: _125.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryParamsResponse;
+                fromJSON(object: any): _125.QueryParamsResponse;
+                toJSON(message: _125.QueryParamsResponse): import("..").JsonSafe<_125.QueryParamsResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryParamsResponse>, I>>(object: I): _125.QueryParamsResponse;
+                fromAmino(object: _125.QueryParamsResponseAmino): _125.QueryParamsResponse;
+                toAmino(message: _125.QueryParamsResponse): _125.QueryParamsResponseAmino;
+                fromAminoMsg(object: _125.QueryParamsResponseAminoMsg): _125.QueryParamsResponse;
+                toAminoMsg(message: _125.QueryParamsResponse): _125.QueryParamsResponseAminoMsg;
+                fromProtoMsg(message: _125.QueryParamsResponseProtoMsg): _125.QueryParamsResponse;
+                toProto(message: _125.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _125.QueryParamsResponse): _125.QueryParamsResponseProtoMsg;
+            };
+            QueryDenomAuthorityMetadataRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryDenomAuthorityMetadataRequest;
+                isSDK(o: any): o is _125.QueryDenomAuthorityMetadataRequestSDKType;
+                isAmino(o: any): o is _125.QueryDenomAuthorityMetadataRequestAmino;
+                encode(message: _125.QueryDenomAuthorityMetadataRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryDenomAuthorityMetadataRequest;
+                fromJSON(object: any): _125.QueryDenomAuthorityMetadataRequest;
+                toJSON(message: _125.QueryDenomAuthorityMetadataRequest): import("..").JsonSafe<_125.QueryDenomAuthorityMetadataRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryDenomAuthorityMetadataRequest>, I>>(object: I): _125.QueryDenomAuthorityMetadataRequest;
+                fromAmino(object: _125.QueryDenomAuthorityMetadataRequestAmino): _125.QueryDenomAuthorityMetadataRequest;
+                toAmino(message: _125.QueryDenomAuthorityMetadataRequest): _125.QueryDenomAuthorityMetadataRequestAmino;
+                fromAminoMsg(object: _125.QueryDenomAuthorityMetadataRequestAminoMsg): _125.QueryDenomAuthorityMetadataRequest;
+                toAminoMsg(message: _125.QueryDenomAuthorityMetadataRequest): _125.QueryDenomAuthorityMetadataRequestAminoMsg;
+                fromProtoMsg(message: _125.QueryDenomAuthorityMetadataRequestProtoMsg): _125.QueryDenomAuthorityMetadataRequest;
+                toProto(message: _125.QueryDenomAuthorityMetadataRequest): Uint8Array;
+                toProtoMsg(message: _125.QueryDenomAuthorityMetadataRequest): _125.QueryDenomAuthorityMetadataRequestProtoMsg;
+            };
+            QueryDenomAuthorityMetadataResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryDenomAuthorityMetadataResponse;
+                isSDK(o: any): o is _125.QueryDenomAuthorityMetadataResponseSDKType;
+                isAmino(o: any): o is _125.QueryDenomAuthorityMetadataResponseAmino;
+                encode(message: _125.QueryDenomAuthorityMetadataResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryDenomAuthorityMetadataResponse;
+                fromJSON(object: any): _125.QueryDenomAuthorityMetadataResponse;
+                toJSON(message: _125.QueryDenomAuthorityMetadataResponse): import("..").JsonSafe<_125.QueryDenomAuthorityMetadataResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryDenomAuthorityMetadataResponse>, I>>(object: I): _125.QueryDenomAuthorityMetadataResponse;
+                fromAmino(object: _125.QueryDenomAuthorityMetadataResponseAmino): _125.QueryDenomAuthorityMetadataResponse;
+                toAmino(message: _125.QueryDenomAuthorityMetadataResponse): _125.QueryDenomAuthorityMetadataResponseAmino;
+                fromAminoMsg(object: _125.QueryDenomAuthorityMetadataResponseAminoMsg): _125.QueryDenomAuthorityMetadataResponse;
+                toAminoMsg(message: _125.QueryDenomAuthorityMetadataResponse): _125.QueryDenomAuthorityMetadataResponseAminoMsg;
+                fromProtoMsg(message: _125.QueryDenomAuthorityMetadataResponseProtoMsg): _125.QueryDenomAuthorityMetadataResponse;
+                toProto(message: _125.QueryDenomAuthorityMetadataResponse): Uint8Array;
+                toProtoMsg(message: _125.QueryDenomAuthorityMetadataResponse): _125.QueryDenomAuthorityMetadataResponseProtoMsg;
+            };
+            QueryDenomsFromCreatorRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryDenomsFromCreatorRequest;
+                isSDK(o: any): o is _125.QueryDenomsFromCreatorRequestSDKType;
+                isAmino(o: any): o is _125.QueryDenomsFromCreatorRequestAmino;
+                encode(message: _125.QueryDenomsFromCreatorRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryDenomsFromCreatorRequest;
+                fromJSON(object: any): _125.QueryDenomsFromCreatorRequest;
+                toJSON(message: _125.QueryDenomsFromCreatorRequest): import("..").JsonSafe<_125.QueryDenomsFromCreatorRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryDenomsFromCreatorRequest>, I>>(object: I): _125.QueryDenomsFromCreatorRequest;
+                fromAmino(object: _125.QueryDenomsFromCreatorRequestAmino): _125.QueryDenomsFromCreatorRequest;
+                toAmino(message: _125.QueryDenomsFromCreatorRequest): _125.QueryDenomsFromCreatorRequestAmino;
+                fromAminoMsg(object: _125.QueryDenomsFromCreatorRequestAminoMsg): _125.QueryDenomsFromCreatorRequest;
+                toAminoMsg(message: _125.QueryDenomsFromCreatorRequest): _125.QueryDenomsFromCreatorRequestAminoMsg;
+                fromProtoMsg(message: _125.QueryDenomsFromCreatorRequestProtoMsg): _125.QueryDenomsFromCreatorRequest;
+                toProto(message: _125.QueryDenomsFromCreatorRequest): Uint8Array;
+                toProtoMsg(message: _125.QueryDenomsFromCreatorRequest): _125.QueryDenomsFromCreatorRequestProtoMsg;
+            };
+            QueryDenomsFromCreatorResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryDenomsFromCreatorResponse;
+                isSDK(o: any): o is _125.QueryDenomsFromCreatorResponseSDKType;
+                isAmino(o: any): o is _125.QueryDenomsFromCreatorResponseAmino;
+                encode(message: _125.QueryDenomsFromCreatorResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryDenomsFromCreatorResponse;
+                fromJSON(object: any): _125.QueryDenomsFromCreatorResponse;
+                toJSON(message: _125.QueryDenomsFromCreatorResponse): import("..").JsonSafe<_125.QueryDenomsFromCreatorResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryDenomsFromCreatorResponse>, I>>(object: I): _125.QueryDenomsFromCreatorResponse;
+                fromAmino(object: _125.QueryDenomsFromCreatorResponseAmino): _125.QueryDenomsFromCreatorResponse;
+                toAmino(message: _125.QueryDenomsFromCreatorResponse): _125.QueryDenomsFromCreatorResponseAmino;
+                fromAminoMsg(object: _125.QueryDenomsFromCreatorResponseAminoMsg): _125.QueryDenomsFromCreatorResponse;
+                toAminoMsg(message: _125.QueryDenomsFromCreatorResponse): _125.QueryDenomsFromCreatorResponseAminoMsg;
+                fromProtoMsg(message: _125.QueryDenomsFromCreatorResponseProtoMsg): _125.QueryDenomsFromCreatorResponse;
+                toProto(message: _125.QueryDenomsFromCreatorResponse): Uint8Array;
+                toProtoMsg(message: _125.QueryDenomsFromCreatorResponse): _125.QueryDenomsFromCreatorResponseProtoMsg;
+            };
+            QueryDenomsFromAdminRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryDenomsFromAdminRequest;
+                isSDK(o: any): o is _125.QueryDenomsFromAdminRequestSDKType;
+                isAmino(o: any): o is _125.QueryDenomsFromAdminRequestAmino;
+                encode(message: _125.QueryDenomsFromAdminRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryDenomsFromAdminRequest;
+                fromJSON(object: any): _125.QueryDenomsFromAdminRequest;
+                toJSON(message: _125.QueryDenomsFromAdminRequest): import("..").JsonSafe<_125.QueryDenomsFromAdminRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryDenomsFromAdminRequest>, I>>(object: I): _125.QueryDenomsFromAdminRequest;
+                fromAmino(object: _125.QueryDenomsFromAdminRequestAmino): _125.QueryDenomsFromAdminRequest;
+                toAmino(message: _125.QueryDenomsFromAdminRequest): _125.QueryDenomsFromAdminRequestAmino;
+                fromAminoMsg(object: _125.QueryDenomsFromAdminRequestAminoMsg): _125.QueryDenomsFromAdminRequest;
+                toAminoMsg(message: _125.QueryDenomsFromAdminRequest): _125.QueryDenomsFromAdminRequestAminoMsg;
+                fromProtoMsg(message: _125.QueryDenomsFromAdminRequestProtoMsg): _125.QueryDenomsFromAdminRequest;
+                toProto(message: _125.QueryDenomsFromAdminRequest): Uint8Array;
+                toProtoMsg(message: _125.QueryDenomsFromAdminRequest): _125.QueryDenomsFromAdminRequestProtoMsg;
+            };
+            QueryDenomsFromAdminResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _125.QueryDenomsFromAdminResponse;
+                isSDK(o: any): o is _125.QueryDenomsFromAdminResponseSDKType;
+                isAmino(o: any): o is _125.QueryDenomsFromAdminResponseAmino;
+                encode(message: _125.QueryDenomsFromAdminResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryDenomsFromAdminResponse;
+                fromJSON(object: any): _125.QueryDenomsFromAdminResponse;
+                toJSON(message: _125.QueryDenomsFromAdminResponse): import("..").JsonSafe<_125.QueryDenomsFromAdminResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_125.QueryDenomsFromAdminResponse>, I>>(object: I): _125.QueryDenomsFromAdminResponse;
+                fromAmino(object: _125.QueryDenomsFromAdminResponseAmino): _125.QueryDenomsFromAdminResponse;
+                toAmino(message: _125.QueryDenomsFromAdminResponse): _125.QueryDenomsFromAdminResponseAmino;
+                fromAminoMsg(object: _125.QueryDenomsFromAdminResponseAminoMsg): _125.QueryDenomsFromAdminResponse;
+                toAminoMsg(message: _125.QueryDenomsFromAdminResponse): _125.QueryDenomsFromAdminResponseAminoMsg;
+                fromProtoMsg(message: _125.QueryDenomsFromAdminResponseProtoMsg): _125.QueryDenomsFromAdminResponse;
+                toProto(message: _125.QueryDenomsFromAdminResponse): Uint8Array;
+                toProtoMsg(message: _125.QueryDenomsFromAdminResponse): _125.QueryDenomsFromAdminResponseProtoMsg;
+            };
+            Params: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _124.Params;
+                isSDK(o: any): o is _124.ParamsSDKType;
+                isAmino(o: any): o is _124.ParamsAmino;
+                encode(message: _124.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _124.Params;
+                fromJSON(object: any): _124.Params;
+                toJSON(message: _124.Params): import("..").JsonSafe<_124.Params>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_124.Params>, I>>(object: I): _124.Params;
+                fromAmino(object: _124.ParamsAmino): _124.Params;
+                toAmino(message: _124.Params): _124.ParamsAmino;
+                fromAminoMsg(object: _124.ParamsAminoMsg): _124.Params;
+                toAminoMsg(message: _124.Params): _124.ParamsAminoMsg;
+                fromProtoMsg(message: _124.ParamsProtoMsg): _124.Params;
+                toProto(message: _124.Params): Uint8Array;
+                toProtoMsg(message: _124.Params): _124.ParamsProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _123.GenesisState;
+                isSDK(o: any): o is _123.GenesisStateSDKType;
+                isAmino(o: any): o is _123.GenesisStateAmino;
+                encode(message: _123.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.GenesisState;
+                fromJSON(object: any): _123.GenesisState;
+                toJSON(message: _123.GenesisState): import("..").JsonSafe<_123.GenesisState>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_123.GenesisState>, I>>(object: I): _123.GenesisState;
+                fromAmino(object: _123.GenesisStateAmino): _123.GenesisState;
+                toAmino(message: _123.GenesisState): _123.GenesisStateAmino;
+                fromAminoMsg(object: _123.GenesisStateAminoMsg): _123.GenesisState;
+                toAminoMsg(message: _123.GenesisState): _123.GenesisStateAminoMsg;
+                fromProtoMsg(message: _123.GenesisStateProtoMsg): _123.GenesisState;
+                toProto(message: _123.GenesisState): Uint8Array;
+                toProtoMsg(message: _123.GenesisState): _123.GenesisStateProtoMsg;
+            };
+            GenesisDenom: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _123.GenesisDenom;
+                isSDK(o: any): o is _123.GenesisDenomSDKType;
+                isAmino(o: any): o is _123.GenesisDenomAmino;
+                encode(message: _123.GenesisDenom, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.GenesisDenom;
+                fromJSON(object: any): _123.GenesisDenom;
+                toJSON(message: _123.GenesisDenom): import("..").JsonSafe<_123.GenesisDenom>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_123.GenesisDenom>, I>>(object: I): _123.GenesisDenom;
+                fromAmino(object: _123.GenesisDenomAmino): _123.GenesisDenom;
+                toAmino(message: _123.GenesisDenom): _123.GenesisDenomAmino;
+                fromAminoMsg(object: _123.GenesisDenomAminoMsg): _123.GenesisDenom;
+                toAminoMsg(message: _123.GenesisDenom): _123.GenesisDenomAminoMsg;
+                fromProtoMsg(message: _123.GenesisDenomProtoMsg): _123.GenesisDenom;
+                toProto(message: _123.GenesisDenom): Uint8Array;
+                toProtoMsg(message: _123.GenesisDenom): _123.GenesisDenomProtoMsg;
+            };
+            DenomAuthorityMetadata: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _122.DenomAuthorityMetadata;
+                isSDK(o: any): o is _122.DenomAuthorityMetadataSDKType;
+                isAmino(o: any): o is _122.DenomAuthorityMetadataAmino;
+                encode(message: _122.DenomAuthorityMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.DenomAuthorityMetadata;
+                fromJSON(object: any): _122.DenomAuthorityMetadata;
+                toJSON(message: _122.DenomAuthorityMetadata): import("..").JsonSafe<_122.DenomAuthorityMetadata>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_122.DenomAuthorityMetadata>, I>>(object: I): _122.DenomAuthorityMetadata;
+                fromAmino(object: _122.DenomAuthorityMetadataAmino): _122.DenomAuthorityMetadata;
+                toAmino(message: _122.DenomAuthorityMetadata): _122.DenomAuthorityMetadataAmino;
+                fromAminoMsg(object: _122.DenomAuthorityMetadataAminoMsg): _122.DenomAuthorityMetadata;
+                toAminoMsg(message: _122.DenomAuthorityMetadata): _122.DenomAuthorityMetadataAminoMsg;
+                fromProtoMsg(message: _122.DenomAuthorityMetadataProtoMsg): _122.DenomAuthorityMetadata;
+                toProto(message: _122.DenomAuthorityMetadata): Uint8Array;
+                toProtoMsg(message: _122.DenomAuthorityMetadata): _122.DenomAuthorityMetadataProtoMsg;
+            };
+        };
+    }
+    const ClientFactory: {
+        createRPCMsgClient: ({ rpc }: {
+            rpc: import("../helpers").Rpc;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                circuit: {
+                    v1: import("../cosmos/circuit/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
+                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                vesting: {
+                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+            osmosis: {
+                tokenfactory: {
+                    v1beta1: _251.MsgClientImpl;
+                };
+            };
+        }>;
+        createRPCMsgExtensions: ({ rpcEndpoint, signer }: {
+            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
+            signer: import("@cosmjs/proto-signing").OfflineSigner;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                circuit: {
+                    v1: import("../cosmos/circuit/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
+                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                vesting: {
+                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+            osmosis: {
+                tokenfactory: {
+                    v1beta1: _251.MsgClientImpl;
+                };
+            };
+        }>;
+        createRPCQueryClient: ({ rpcEndpoint }: {
+            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: {
+                        accounts(request?: import("../cosmos/auth/v1beta1/query").QueryAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountsResponse>;
+                        account(request: import("../cosmos/auth/v1beta1/query").QueryAccountRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountResponse>;
+                        accountAddressByID(request: import("../cosmos/auth/v1beta1/query").QueryAccountAddressByIDRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountAddressByIDResponse>;
+                        params(request?: import("../cosmos/auth/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryParamsResponse>;
+                        moduleAccounts(request?: import("../cosmos/auth/v1beta1/query").QueryModuleAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountsResponse>;
+                        moduleAccountByName(request: import("../cosmos/auth/v1beta1/query").QueryModuleAccountByNameRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountByNameResponse>;
+                        bech32Prefix(request?: import("../cosmos/auth/v1beta1/query").Bech32PrefixRequest): Promise<import("../cosmos/auth/v1beta1/query").Bech32PrefixResponse>;
+                        addressBytesToString(request: import("../cosmos/auth/v1beta1/query").AddressBytesToStringRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressBytesToStringResponse>;
+                        addressStringToBytes(request: import("../cosmos/auth/v1beta1/query").AddressStringToBytesRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressStringToBytesResponse>;
+                        accountInfo(request: import("../cosmos/auth/v1beta1/query").QueryAccountInfoRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountInfoResponse>;
+                    };
+                };
+                authz: {
+                    v1beta1: {
+                        grants(request: import("../cosmos/authz/v1beta1/query").QueryGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGrantsResponse>;
+                        granterGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranterGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranterGrantsResponse>;
+                        granteeGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsResponse>;
+                    };
+                };
+                bank: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/bank/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryBalanceResponse>;
+                        allBalances(request: import("../cosmos/bank/v1beta1/query").QueryAllBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryAllBalancesResponse>;
+                        spendableBalances(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesResponse>;
+                        spendableBalanceByDenom(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomResponse>;
+                        totalSupply(request?: import("../cosmos/bank/v1beta1/query").QueryTotalSupplyRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryTotalSupplyResponse>;
+                        supplyOf(request: import("../cosmos/bank/v1beta1/query").QuerySupplyOfRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySupplyOfResponse>;
+                        params(request?: import("../cosmos/bank/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryParamsResponse>;
+                        denomMetadata(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataResponse>;
+                        denomMetadataByQueryString(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataByQueryStringRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataByQueryStringResponse>;
+                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataResponse>;
+                        denomOwners(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersResponse>;
+                        sendEnabled(request: import("../cosmos/bank/v1beta1/query").QuerySendEnabledRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySendEnabledResponse>;
+                    };
+                };
+                base: {
+                    node: {
+                        v1beta1: {
+                            config(request?: import("../cosmos/base/node/v1beta1/query").ConfigRequest): Promise<import("../cosmos/base/node/v1beta1/query").ConfigResponse>;
+                            status(request?: import("../cosmos/base/node/v1beta1/query").StatusRequest): Promise<import("../cosmos/base/node/v1beta1/query").StatusResponse>;
+                        };
+                    };
+                };
+                circuit: {
+                    v1: {
+                        account(request: import("../cosmos/circuit/v1/query").QueryAccountRequest): Promise<import("../cosmos/circuit/v1/query").AccountResponse>;
+                        accounts(request?: import("../cosmos/circuit/v1/query").QueryAccountsRequest): Promise<import("../cosmos/circuit/v1/query").AccountsResponse>;
+                        disabledList(request?: import("../cosmos/circuit/v1/query").QueryDisabledListRequest): Promise<import("../cosmos/circuit/v1/query").DisabledListResponse>;
+                    };
+                };
+                consensus: {
+                    v1: {
+                        params(request?: import("../cosmos/consensus/v1/query").QueryParamsRequest): Promise<import("../cosmos/consensus/v1/query").QueryParamsResponse>;
+                    };
+                };
+                distribution: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/distribution/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryParamsResponse>;
+                        validatorDistributionInfo(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorDistributionInfoRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorDistributionInfoResponse>;
+                        validatorOutstandingRewards(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsResponse>;
+                        validatorCommission(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionResponse>;
+                        validatorSlashes(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesResponse>;
+                        delegationRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsResponse>;
+                        delegationTotalRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsResponse>;
+                        delegatorValidators(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorWithdrawAddress(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressResponse>;
+                        communityPool(request?: import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolResponse>;
+                    };
+                };
+                feegrant: {
+                    v1beta1: {
+                        allowance(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowanceRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowanceResponse>;
+                        allowances(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesResponse>;
+                        allowancesByGranter(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterResponse>;
+                    };
+                };
+                gov: {
+                    v1: {
+                        constitution(request?: import("../cosmos/gov/v1/query").QueryConstitutionRequest): Promise<import("../cosmos/gov/v1/query").QueryConstitutionResponse>;
+                        proposal(request: import("../cosmos/gov/v1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1/query").QueryTallyResultResponse>;
+                    };
+                    v1beta1: {
+                        proposal(request: import("../cosmos/gov/v1beta1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1beta1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1beta1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1beta1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1beta1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1beta1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1beta1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryTallyResultResponse>;
+                    };
+                };
+                group: {
+                    v1: {
+                        groupInfo(request: import("../cosmos/group/v1/query").QueryGroupInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupInfoResponse>;
+                        groupPolicyInfo(request: import("../cosmos/group/v1/query").QueryGroupPolicyInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPolicyInfoResponse>;
+                        groupMembers(request: import("../cosmos/group/v1/query").QueryGroupMembersRequest): Promise<import("../cosmos/group/v1/query").QueryGroupMembersResponse>;
+                        groupsByAdmin(request: import("../cosmos/group/v1/query").QueryGroupsByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByAdminResponse>;
+                        groupPoliciesByGroup(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupResponse>;
+                        groupPoliciesByAdmin(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminResponse>;
+                        proposal(request: import("../cosmos/group/v1/query").QueryProposalRequest): Promise<import("../cosmos/group/v1/query").QueryProposalResponse>;
+                        proposalsByGroupPolicy(request: import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyRequest): Promise<import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyResponse>;
+                        voteByProposalVoter(request: import("../cosmos/group/v1/query").QueryVoteByProposalVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVoteByProposalVoterResponse>;
+                        votesByProposal(request: import("../cosmos/group/v1/query").QueryVotesByProposalRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByProposalResponse>;
+                        votesByVoter(request: import("../cosmos/group/v1/query").QueryVotesByVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByVoterResponse>;
+                        groupsByMember(request: import("../cosmos/group/v1/query").QueryGroupsByMemberRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByMemberResponse>;
+                        tallyResult(request: import("../cosmos/group/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/group/v1/query").QueryTallyResultResponse>;
+                        groups(request?: import("../cosmos/group/v1/query").QueryGroupsRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsResponse>;
+                    };
+                };
+                mint: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/mint/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryParamsResponse>;
+                        inflation(request?: import("../cosmos/mint/v1beta1/query").QueryInflationRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryInflationResponse>;
+                        annualProvisions(request?: import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsResponse>;
+                    };
+                };
+                orm: {
+                    query: {
+                        v1alpha1: {
+                            get(request: import("../cosmos/orm/query/v1alpha1/query").GetRequest): Promise<import("../cosmos/orm/query/v1alpha1/query").GetResponse>;
+                            list(request: import("../cosmos/orm/query/v1alpha1/query").ListRequest): Promise<import("../cosmos/orm/query/v1alpha1/query").ListResponse>;
+                        };
+                    };
+                };
+                params: {
+                    v1beta1: {
+                        params(request: import("../cosmos/params/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/params/v1beta1/query").QueryParamsResponse>;
+                        subspaces(request?: import("../cosmos/params/v1beta1/query").QuerySubspacesRequest): Promise<import("../cosmos/params/v1beta1/query").QuerySubspacesResponse>;
+                    };
+                };
+                staking: {
+                    v1beta1: {
+                        validators(request: import("../cosmos/staking/v1beta1/query").QueryValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorsResponse>;
+                        validator(request: import("../cosmos/staking/v1beta1/query").QueryValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorResponse>;
+                        validatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsResponse>;
+                        validatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsResponse>;
+                        delegation(request: import("../cosmos/staking/v1beta1/query").QueryDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegationResponse>;
+                        unbondingDelegation(request: import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationResponse>;
+                        delegatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsResponse>;
+                        delegatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsResponse>;
+                        redelegations(request: import("../cosmos/staking/v1beta1/query").QueryRedelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryRedelegationsResponse>;
+                        delegatorValidators(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorValidator(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorResponse>;
+                        historicalInfo(request: import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoResponse>;
+                        pool(request?: import("../cosmos/staking/v1beta1/query").QueryPoolRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryPoolResponse>;
+                        params(request?: import("../cosmos/staking/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryParamsResponse>;
+                    };
+                };
+                tx: {
+                    v1beta1: {
+                        simulate(request: import("../cosmos/tx/v1beta1/service").SimulateRequest): Promise<import("../cosmos/tx/v1beta1/service").SimulateResponse>;
+                        getTx(request: import("../cosmos/tx/v1beta1/service").GetTxRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxResponse>;
+                        broadcastTx(request: import("../cosmos/tx/v1beta1/service").BroadcastTxRequest): Promise<import("../cosmos/tx/v1beta1/service").BroadcastTxResponse>;
+                        getTxsEvent(request: import("../cosmos/tx/v1beta1/service").GetTxsEventRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxsEventResponse>;
+                        getBlockWithTxs(request: import("../cosmos/tx/v1beta1/service").GetBlockWithTxsRequest): Promise<import("../cosmos/tx/v1beta1/service").GetBlockWithTxsResponse>;
+                        txDecode(request: import("../cosmos/tx/v1beta1/service").TxDecodeRequest): Promise<import("../cosmos/tx/v1beta1/service").TxDecodeResponse>;
+                        txEncode(request: import("../cosmos/tx/v1beta1/service").TxEncodeRequest): Promise<import("../cosmos/tx/v1beta1/service").TxEncodeResponse>;
+                        txEncodeAmino(request: import("../cosmos/tx/v1beta1/service").TxEncodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service").TxEncodeAminoResponse>;
+                        txDecodeAmino(request: import("../cosmos/tx/v1beta1/service").TxDecodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service").TxDecodeAminoResponse>;
+                    };
+                };
+                upgrade: {
+                    v1beta1: {
+                        currentPlan(request?: import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanResponse>;
+                        appliedPlan(request: import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanResponse>;
+                        upgradedConsensusState(request: import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateResponse>;
+                        moduleVersions(request: import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsResponse>;
+                        authority(request?: import("../cosmos/upgrade/v1beta1/query").QueryAuthorityRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAuthorityResponse>;
+                    };
+                };
+            };
+            osmosis: {
+                tokenfactory: {
+                    v1beta1: {
+                        params(request?: _125.QueryParamsRequest): Promise<_125.QueryParamsResponse>;
+                        denomAuthorityMetadata(request: _125.QueryDenomAuthorityMetadataRequest): Promise<_125.QueryDenomAuthorityMetadataResponse>;
+                        denomsFromCreator(request: _125.QueryDenomsFromCreatorRequest): Promise<_125.QueryDenomsFromCreatorResponse>;
+                        denomsFromAdmin(request: _125.QueryDenomsFromAdminRequest): Promise<_125.QueryDenomsFromAdminResponse>;
+                    };
+                };
+            };
+        }>;
+        createLCDClient: ({ restEndpoint }: {
+            restEndpoint: string;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/query.lcd").LCDQueryClient;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/query.lcd").LCDQueryClient;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/query.lcd").LCDQueryClient;
+                };
+                base: {
+                    node: {
+                        v1beta1: import("../cosmos/base/node/v1beta1/query.lcd").LCDQueryClient;
+                    };
+                };
+                circuit: {
+                    v1: import("../cosmos/circuit/v1/query.lcd").LCDQueryClient;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/query.lcd").LCDQueryClient;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/query.lcd").LCDQueryClient;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/query.lcd").LCDQueryClient;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/query.lcd").LCDQueryClient;
+                    v1beta1: import("../cosmos/gov/v1beta1/query.lcd").LCDQueryClient;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/query.lcd").LCDQueryClient;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/query.lcd").LCDQueryClient;
+                };
+                params: {
+                    v1beta1: import("../cosmos/params/v1beta1/query.lcd").LCDQueryClient;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/query.lcd").LCDQueryClient;
+                };
+                tx: {
+                    v1beta1: import("../cosmos/tx/v1beta1/service.lcd").LCDQueryClient;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/query.lcd").LCDQueryClient;
+                };
+            };
+            osmosis: {
+                tokenfactory: {
+                    v1beta1: _249.LCDQueryClient;
+                };
+            };
+        }>;
+    };
+}