@manifest-network/manifestjs 2.1.0

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

@@ -0,0 +1,997 @@
+import * as _127 from "./poa/v1/genesis";
+import * as _128 from "./poa/v1/params";
+import * as _129 from "./poa/v1/query";
+import * as _130 from "./poa/v1/tx";
+import * as _131 from "./poa/v1/validator";
+import * as _254 from "./poa/v1/query.lcd";
+import * as _255 from "./poa/v1/query.rpc.Query";
+import * as _256 from "./poa/v1/tx.rpc.msg";
+export declare namespace strangelove_ventures {
+    namespace poa {
+        const v1: {
+            MsgClientImpl: typeof _256.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _256.MsgClientImpl;
+            QueryClientImpl: typeof _255.QueryClientImpl;
+            createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                pendingValidators(request?: _129.QueryPendingValidatorsRequest): Promise<_129.PendingValidatorsResponse>;
+                consensusPower(request: _129.QueryConsensusPowerRequest): Promise<_129.QueryConsensusPowerResponse>;
+                poaAuthority(request?: _129.QueryPoaAuthorityRequest): Promise<_129.QueryPoaAuthorityResponse>;
+            };
+            LCDQueryClient: typeof _254.LCDQueryClient;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    createValidator(value: _130.MsgCreateValidator): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    setPower(value: _130.MsgSetPower): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    removeValidator(value: _130.MsgRemoveValidator): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    removePending(value: _130.MsgRemovePending): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    updateStakingParams(value: _130.MsgUpdateStakingParams): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                };
+                withTypeUrl: {
+                    createValidator(value: _130.MsgCreateValidator): {
+                        typeUrl: string;
+                        value: _130.MsgCreateValidator;
+                    };
+                    setPower(value: _130.MsgSetPower): {
+                        typeUrl: string;
+                        value: _130.MsgSetPower;
+                    };
+                    removeValidator(value: _130.MsgRemoveValidator): {
+                        typeUrl: string;
+                        value: _130.MsgRemoveValidator;
+                    };
+                    removePending(value: _130.MsgRemovePending): {
+                        typeUrl: string;
+                        value: _130.MsgRemovePending;
+                    };
+                    updateStakingParams(value: _130.MsgUpdateStakingParams): {
+                        typeUrl: string;
+                        value: _130.MsgUpdateStakingParams;
+                    };
+                };
+                toJSON: {
+                    createValidator(value: _130.MsgCreateValidator): {
+                        typeUrl: string;
+                        value: {
+                            description: {
+                                moniker: string;
+                                identity: string;
+                                website: string;
+                                securityContact: string;
+                                details: string;
+                            };
+                            commission: {
+                                rate: string;
+                                maxRate: string;
+                                maxChangeRate: string;
+                            };
+                            minSelfDelegation: string;
+                            delegatorAddress: string;
+                            validatorAddress: string;
+                            pubkey?: {
+                                $typeUrl?: "/google.protobuf.Any" | string;
+                                typeUrl: string;
+                                value: string;
+                            };
+                        };
+                    };
+                    setPower(value: _130.MsgSetPower): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            validatorAddress: string;
+                            power: string;
+                            unsafe: boolean;
+                        };
+                    };
+                    removeValidator(value: _130.MsgRemoveValidator): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            validatorAddress: string;
+                        };
+                    };
+                    removePending(value: _130.MsgRemovePending): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            validatorAddress: string;
+                        };
+                    };
+                    updateStakingParams(value: _130.MsgUpdateStakingParams): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            params: {
+                                unbondingTime: {
+                                    seconds: string;
+                                    nanos: number;
+                                };
+                                maxValidators: number;
+                                maxEntries: number;
+                                historicalEntries: number;
+                                bondDenom: string;
+                                minCommissionRate: string;
+                            };
+                        };
+                    };
+                };
+                fromJSON: {
+                    createValidator(value: any): {
+                        typeUrl: string;
+                        value: _130.MsgCreateValidator;
+                    };
+                    setPower(value: any): {
+                        typeUrl: string;
+                        value: _130.MsgSetPower;
+                    };
+                    removeValidator(value: any): {
+                        typeUrl: string;
+                        value: _130.MsgRemoveValidator;
+                    };
+                    removePending(value: any): {
+                        typeUrl: string;
+                        value: _130.MsgRemovePending;
+                    };
+                    updateStakingParams(value: any): {
+                        typeUrl: string;
+                        value: _130.MsgUpdateStakingParams;
+                    };
+                };
+                fromPartial: {
+                    createValidator(value: _130.MsgCreateValidator): {
+                        typeUrl: string;
+                        value: _130.MsgCreateValidator;
+                    };
+                    setPower(value: _130.MsgSetPower): {
+                        typeUrl: string;
+                        value: _130.MsgSetPower;
+                    };
+                    removeValidator(value: _130.MsgRemoveValidator): {
+                        typeUrl: string;
+                        value: _130.MsgRemoveValidator;
+                    };
+                    removePending(value: _130.MsgRemovePending): {
+                        typeUrl: string;
+                        value: _130.MsgRemovePending;
+                    };
+                    updateStakingParams(value: _130.MsgUpdateStakingParams): {
+                        typeUrl: string;
+                        value: _130.MsgUpdateStakingParams;
+                    };
+                };
+            };
+            AminoConverter: {
+                "/strangelove_ventures.poa.v1.MsgCreateValidator": {
+                    aminoType: string;
+                    toAmino: (message: _130.MsgCreateValidator) => _130.MsgCreateValidatorAmino;
+                    fromAmino: (object: _130.MsgCreateValidatorAmino) => _130.MsgCreateValidator;
+                };
+                "/strangelove_ventures.poa.v1.MsgSetPower": {
+                    aminoType: string;
+                    toAmino: (message: _130.MsgSetPower) => _130.MsgSetPowerAmino;
+                    fromAmino: (object: _130.MsgSetPowerAmino) => _130.MsgSetPower;
+                };
+                "/strangelove_ventures.poa.v1.MsgRemoveValidator": {
+                    aminoType: string;
+                    toAmino: (message: _130.MsgRemoveValidator) => _130.MsgRemoveValidatorAmino;
+                    fromAmino: (object: _130.MsgRemoveValidatorAmino) => _130.MsgRemoveValidator;
+                };
+                "/strangelove_ventures.poa.v1.MsgRemovePending": {
+                    aminoType: string;
+                    toAmino: (message: _130.MsgRemovePending) => _130.MsgRemovePendingAmino;
+                    fromAmino: (object: _130.MsgRemovePendingAmino) => _130.MsgRemovePending;
+                };
+                "/strangelove_ventures.poa.v1.MsgUpdateStakingParams": {
+                    aminoType: string;
+                    toAmino: (message: _130.MsgUpdateStakingParams) => _130.MsgUpdateStakingParamsAmino;
+                    fromAmino: (object: _130.MsgUpdateStakingParamsAmino) => _130.MsgUpdateStakingParams;
+                };
+            };
+            bondStatusFromJSON(object: any): _131.BondStatus;
+            bondStatusToJSON(object: _131.BondStatus): string;
+            BondStatus: typeof _131.BondStatus;
+            BondStatusSDKType: typeof _131.BondStatus;
+            BondStatusAmino: typeof _131.BondStatus;
+            Validators: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _131.Validators;
+                isSDK(o: any): o is _131.ValidatorsSDKType;
+                isAmino(o: any): o is _131.ValidatorsAmino;
+                encode(message: _131.Validators, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _131.Validators;
+                fromJSON(object: any): _131.Validators;
+                toJSON(message: _131.Validators): import("..").JsonSafe<_131.Validators>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_131.Validators>, I>>(object: I): _131.Validators;
+                fromAmino(object: _131.ValidatorsAmino): _131.Validators;
+                toAmino(message: _131.Validators): _131.ValidatorsAmino;
+                fromAminoMsg(object: _131.ValidatorsAminoMsg): _131.Validators;
+                toAminoMsg(message: _131.Validators): _131.ValidatorsAminoMsg;
+                fromProtoMsg(message: _131.ValidatorsProtoMsg): _131.Validators;
+                toProto(message: _131.Validators): Uint8Array;
+                toProtoMsg(message: _131.Validators): _131.ValidatorsProtoMsg;
+            };
+            Description: {
+                typeUrl: string;
+                is(o: any): o is _131.Description;
+                isSDK(o: any): o is _131.DescriptionSDKType;
+                isAmino(o: any): o is _131.DescriptionAmino;
+                encode(message: _131.Description, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _131.Description;
+                fromJSON(object: any): _131.Description;
+                toJSON(message: _131.Description): import("..").JsonSafe<_131.Description>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_131.Description>, I>>(object: I): _131.Description;
+                fromAmino(object: _131.DescriptionAmino): _131.Description;
+                toAmino(message: _131.Description): _131.DescriptionAmino;
+                fromAminoMsg(object: _131.DescriptionAminoMsg): _131.Description;
+                fromProtoMsg(message: _131.DescriptionProtoMsg): _131.Description;
+                toProto(message: _131.Description): Uint8Array;
+                toProtoMsg(message: _131.Description): _131.DescriptionProtoMsg;
+            };
+            CommissionRates: {
+                typeUrl: string;
+                is(o: any): o is _131.CommissionRates;
+                isSDK(o: any): o is _131.CommissionRatesSDKType;
+                isAmino(o: any): o is _131.CommissionRatesAmino;
+                encode(message: _131.CommissionRates, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _131.CommissionRates;
+                fromJSON(object: any): _131.CommissionRates;
+                toJSON(message: _131.CommissionRates): import("..").JsonSafe<_131.CommissionRates>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_131.CommissionRates>, I>>(object: I): _131.CommissionRates;
+                fromAmino(object: _131.CommissionRatesAmino): _131.CommissionRates;
+                toAmino(message: _131.CommissionRates): _131.CommissionRatesAmino;
+                fromAminoMsg(object: _131.CommissionRatesAminoMsg): _131.CommissionRates;
+                fromProtoMsg(message: _131.CommissionRatesProtoMsg): _131.CommissionRates;
+                toProto(message: _131.CommissionRates): Uint8Array;
+                toProtoMsg(message: _131.CommissionRates): _131.CommissionRatesProtoMsg;
+            };
+            Commission: {
+                typeUrl: string;
+                is(o: any): o is _131.Commission;
+                isSDK(o: any): o is _131.CommissionSDKType;
+                isAmino(o: any): o is _131.CommissionAmino;
+                encode(message: _131.Commission, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _131.Commission;
+                fromJSON(object: any): _131.Commission;
+                toJSON(message: _131.Commission): import("..").JsonSafe<_131.Commission>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_131.Commission>, I>>(object: I): _131.Commission;
+                fromAmino(object: _131.CommissionAmino): _131.Commission;
+                toAmino(message: _131.Commission): _131.CommissionAmino;
+                fromAminoMsg(object: _131.CommissionAminoMsg): _131.Commission;
+                fromProtoMsg(message: _131.CommissionProtoMsg): _131.Commission;
+                toProto(message: _131.Commission): Uint8Array;
+                toProtoMsg(message: _131.Commission): _131.CommissionProtoMsg;
+            };
+            Validator: {
+                typeUrl: string;
+                is(o: any): o is _131.Validator;
+                isSDK(o: any): o is _131.ValidatorSDKType;
+                isAmino(o: any): o is _131.ValidatorAmino;
+                encode(message: _131.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _131.Validator;
+                fromJSON(object: any): _131.Validator;
+                toJSON(message: _131.Validator): import("..").JsonSafe<_131.Validator>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_131.Validator>, I>>(object: I): _131.Validator;
+                fromAmino(object: _131.ValidatorAmino): _131.Validator;
+                toAmino(message: _131.Validator): _131.ValidatorAmino;
+                fromAminoMsg(object: _131.ValidatorAminoMsg): _131.Validator;
+                fromProtoMsg(message: _131.ValidatorProtoMsg): _131.Validator;
+                toProto(message: _131.Validator): Uint8Array;
+                toProtoMsg(message: _131.Validator): _131.ValidatorProtoMsg;
+            };
+            MsgSetPower: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _130.MsgSetPower;
+                isSDK(o: any): o is _130.MsgSetPowerSDKType;
+                isAmino(o: any): o is _130.MsgSetPowerAmino;
+                encode(message: _130.MsgSetPower, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgSetPower;
+                fromJSON(object: any): _130.MsgSetPower;
+                toJSON(message: _130.MsgSetPower): import("..").JsonSafe<_130.MsgSetPower>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgSetPower>, I>>(object: I): _130.MsgSetPower;
+                fromAmino(object: _130.MsgSetPowerAmino): _130.MsgSetPower;
+                toAmino(message: _130.MsgSetPower): _130.MsgSetPowerAmino;
+                fromAminoMsg(object: _130.MsgSetPowerAminoMsg): _130.MsgSetPower;
+                toAminoMsg(message: _130.MsgSetPower): _130.MsgSetPowerAminoMsg;
+                fromProtoMsg(message: _130.MsgSetPowerProtoMsg): _130.MsgSetPower;
+                toProto(message: _130.MsgSetPower): Uint8Array;
+                toProtoMsg(message: _130.MsgSetPower): _130.MsgSetPowerProtoMsg;
+            };
+            MsgSetPowerResponse: {
+                typeUrl: string;
+                is(o: any): o is _130.MsgSetPowerResponse;
+                isSDK(o: any): o is _130.MsgSetPowerResponseSDKType;
+                isAmino(o: any): o is _130.MsgSetPowerResponseAmino;
+                encode(_: _130.MsgSetPowerResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgSetPowerResponse;
+                fromJSON(_: any): _130.MsgSetPowerResponse;
+                toJSON(_: _130.MsgSetPowerResponse): import("..").JsonSafe<_130.MsgSetPowerResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgSetPowerResponse>, I>>(_: I): _130.MsgSetPowerResponse;
+                fromAmino(_: _130.MsgSetPowerResponseAmino): _130.MsgSetPowerResponse;
+                toAmino(_: _130.MsgSetPowerResponse): _130.MsgSetPowerResponseAmino;
+                fromAminoMsg(object: _130.MsgSetPowerResponseAminoMsg): _130.MsgSetPowerResponse;
+                fromProtoMsg(message: _130.MsgSetPowerResponseProtoMsg): _130.MsgSetPowerResponse;
+                toProto(message: _130.MsgSetPowerResponse): Uint8Array;
+                toProtoMsg(message: _130.MsgSetPowerResponse): _130.MsgSetPowerResponseProtoMsg;
+            };
+            MsgRemoveValidator: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _130.MsgRemoveValidator;
+                isSDK(o: any): o is _130.MsgRemoveValidatorSDKType;
+                isAmino(o: any): o is _130.MsgRemoveValidatorAmino;
+                encode(message: _130.MsgRemoveValidator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgRemoveValidator;
+                fromJSON(object: any): _130.MsgRemoveValidator;
+                toJSON(message: _130.MsgRemoveValidator): import("..").JsonSafe<_130.MsgRemoveValidator>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgRemoveValidator>, I>>(object: I): _130.MsgRemoveValidator;
+                fromAmino(object: _130.MsgRemoveValidatorAmino): _130.MsgRemoveValidator;
+                toAmino(message: _130.MsgRemoveValidator): _130.MsgRemoveValidatorAmino;
+                fromAminoMsg(object: _130.MsgRemoveValidatorAminoMsg): _130.MsgRemoveValidator;
+                toAminoMsg(message: _130.MsgRemoveValidator): _130.MsgRemoveValidatorAminoMsg;
+                fromProtoMsg(message: _130.MsgRemoveValidatorProtoMsg): _130.MsgRemoveValidator;
+                toProto(message: _130.MsgRemoveValidator): Uint8Array;
+                toProtoMsg(message: _130.MsgRemoveValidator): _130.MsgRemoveValidatorProtoMsg;
+            };
+            MsgRemoveValidatorResponse: {
+                typeUrl: string;
+                is(o: any): o is _130.MsgRemoveValidatorResponse;
+                isSDK(o: any): o is _130.MsgRemoveValidatorResponseSDKType;
+                isAmino(o: any): o is _130.MsgRemoveValidatorResponseAmino;
+                encode(_: _130.MsgRemoveValidatorResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgRemoveValidatorResponse;
+                fromJSON(_: any): _130.MsgRemoveValidatorResponse;
+                toJSON(_: _130.MsgRemoveValidatorResponse): import("..").JsonSafe<_130.MsgRemoveValidatorResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgRemoveValidatorResponse>, I>>(_: I): _130.MsgRemoveValidatorResponse;
+                fromAmino(_: _130.MsgRemoveValidatorResponseAmino): _130.MsgRemoveValidatorResponse;
+                toAmino(_: _130.MsgRemoveValidatorResponse): _130.MsgRemoveValidatorResponseAmino;
+                fromAminoMsg(object: _130.MsgRemoveValidatorResponseAminoMsg): _130.MsgRemoveValidatorResponse;
+                fromProtoMsg(message: _130.MsgRemoveValidatorResponseProtoMsg): _130.MsgRemoveValidatorResponse;
+                toProto(message: _130.MsgRemoveValidatorResponse): Uint8Array;
+                toProtoMsg(message: _130.MsgRemoveValidatorResponse): _130.MsgRemoveValidatorResponseProtoMsg;
+            };
+            MsgRemovePending: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _130.MsgRemovePending;
+                isSDK(o: any): o is _130.MsgRemovePendingSDKType;
+                isAmino(o: any): o is _130.MsgRemovePendingAmino;
+                encode(message: _130.MsgRemovePending, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgRemovePending;
+                fromJSON(object: any): _130.MsgRemovePending;
+                toJSON(message: _130.MsgRemovePending): import("..").JsonSafe<_130.MsgRemovePending>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgRemovePending>, I>>(object: I): _130.MsgRemovePending;
+                fromAmino(object: _130.MsgRemovePendingAmino): _130.MsgRemovePending;
+                toAmino(message: _130.MsgRemovePending): _130.MsgRemovePendingAmino;
+                fromAminoMsg(object: _130.MsgRemovePendingAminoMsg): _130.MsgRemovePending;
+                toAminoMsg(message: _130.MsgRemovePending): _130.MsgRemovePendingAminoMsg;
+                fromProtoMsg(message: _130.MsgRemovePendingProtoMsg): _130.MsgRemovePending;
+                toProto(message: _130.MsgRemovePending): Uint8Array;
+                toProtoMsg(message: _130.MsgRemovePending): _130.MsgRemovePendingProtoMsg;
+            };
+            MsgRemovePendingResponse: {
+                typeUrl: string;
+                is(o: any): o is _130.MsgRemovePendingResponse;
+                isSDK(o: any): o is _130.MsgRemovePendingResponseSDKType;
+                isAmino(o: any): o is _130.MsgRemovePendingResponseAmino;
+                encode(_: _130.MsgRemovePendingResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgRemovePendingResponse;
+                fromJSON(_: any): _130.MsgRemovePendingResponse;
+                toJSON(_: _130.MsgRemovePendingResponse): import("..").JsonSafe<_130.MsgRemovePendingResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgRemovePendingResponse>, I>>(_: I): _130.MsgRemovePendingResponse;
+                fromAmino(_: _130.MsgRemovePendingResponseAmino): _130.MsgRemovePendingResponse;
+                toAmino(_: _130.MsgRemovePendingResponse): _130.MsgRemovePendingResponseAmino;
+                fromAminoMsg(object: _130.MsgRemovePendingResponseAminoMsg): _130.MsgRemovePendingResponse;
+                fromProtoMsg(message: _130.MsgRemovePendingResponseProtoMsg): _130.MsgRemovePendingResponse;
+                toProto(message: _130.MsgRemovePendingResponse): Uint8Array;
+                toProtoMsg(message: _130.MsgRemovePendingResponse): _130.MsgRemovePendingResponseProtoMsg;
+            };
+            MsgUpdateStakingParams: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _130.MsgUpdateStakingParams;
+                isSDK(o: any): o is _130.MsgUpdateStakingParamsSDKType;
+                isAmino(o: any): o is _130.MsgUpdateStakingParamsAmino;
+                encode(message: _130.MsgUpdateStakingParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgUpdateStakingParams;
+                fromJSON(object: any): _130.MsgUpdateStakingParams;
+                toJSON(message: _130.MsgUpdateStakingParams): import("..").JsonSafe<_130.MsgUpdateStakingParams>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgUpdateStakingParams>, I>>(object: I): _130.MsgUpdateStakingParams;
+                fromAmino(object: _130.MsgUpdateStakingParamsAmino): _130.MsgUpdateStakingParams;
+                toAmino(message: _130.MsgUpdateStakingParams): _130.MsgUpdateStakingParamsAmino;
+                fromAminoMsg(object: _130.MsgUpdateStakingParamsAminoMsg): _130.MsgUpdateStakingParams;
+                toAminoMsg(message: _130.MsgUpdateStakingParams): _130.MsgUpdateStakingParamsAminoMsg;
+                fromProtoMsg(message: _130.MsgUpdateStakingParamsProtoMsg): _130.MsgUpdateStakingParams;
+                toProto(message: _130.MsgUpdateStakingParams): Uint8Array;
+                toProtoMsg(message: _130.MsgUpdateStakingParams): _130.MsgUpdateStakingParamsProtoMsg;
+            };
+            MsgUpdateStakingParamsResponse: {
+                typeUrl: string;
+                is(o: any): o is _130.MsgUpdateStakingParamsResponse;
+                isSDK(o: any): o is _130.MsgUpdateStakingParamsResponseSDKType;
+                isAmino(o: any): o is _130.MsgUpdateStakingParamsResponseAmino;
+                encode(_: _130.MsgUpdateStakingParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgUpdateStakingParamsResponse;
+                fromJSON(_: any): _130.MsgUpdateStakingParamsResponse;
+                toJSON(_: _130.MsgUpdateStakingParamsResponse): import("..").JsonSafe<_130.MsgUpdateStakingParamsResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgUpdateStakingParamsResponse>, I>>(_: I): _130.MsgUpdateStakingParamsResponse;
+                fromAmino(_: _130.MsgUpdateStakingParamsResponseAmino): _130.MsgUpdateStakingParamsResponse;
+                toAmino(_: _130.MsgUpdateStakingParamsResponse): _130.MsgUpdateStakingParamsResponseAmino;
+                fromAminoMsg(object: _130.MsgUpdateStakingParamsResponseAminoMsg): _130.MsgUpdateStakingParamsResponse;
+                fromProtoMsg(message: _130.MsgUpdateStakingParamsResponseProtoMsg): _130.MsgUpdateStakingParamsResponse;
+                toProto(message: _130.MsgUpdateStakingParamsResponse): Uint8Array;
+                toProtoMsg(message: _130.MsgUpdateStakingParamsResponse): _130.MsgUpdateStakingParamsResponseProtoMsg;
+            };
+            MsgCreateValidator: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _130.MsgCreateValidator;
+                isSDK(o: any): o is _130.MsgCreateValidatorSDKType;
+                isAmino(o: any): o is _130.MsgCreateValidatorAmino;
+                encode(message: _130.MsgCreateValidator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgCreateValidator;
+                fromJSON(object: any): _130.MsgCreateValidator;
+                toJSON(message: _130.MsgCreateValidator): import("..").JsonSafe<_130.MsgCreateValidator>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgCreateValidator>, I>>(object: I): _130.MsgCreateValidator;
+                fromAmino(object: _130.MsgCreateValidatorAmino): _130.MsgCreateValidator;
+                toAmino(message: _130.MsgCreateValidator): _130.MsgCreateValidatorAmino;
+                fromAminoMsg(object: _130.MsgCreateValidatorAminoMsg): _130.MsgCreateValidator;
+                toAminoMsg(message: _130.MsgCreateValidator): _130.MsgCreateValidatorAminoMsg;
+                fromProtoMsg(message: _130.MsgCreateValidatorProtoMsg): _130.MsgCreateValidator;
+                toProto(message: _130.MsgCreateValidator): Uint8Array;
+                toProtoMsg(message: _130.MsgCreateValidator): _130.MsgCreateValidatorProtoMsg;
+            };
+            MsgCreateValidatorResponse: {
+                typeUrl: string;
+                is(o: any): o is _130.MsgCreateValidatorResponse;
+                isSDK(o: any): o is _130.MsgCreateValidatorResponseSDKType;
+                isAmino(o: any): o is _130.MsgCreateValidatorResponseAmino;
+                encode(_: _130.MsgCreateValidatorResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgCreateValidatorResponse;
+                fromJSON(_: any): _130.MsgCreateValidatorResponse;
+                toJSON(_: _130.MsgCreateValidatorResponse): import("..").JsonSafe<_130.MsgCreateValidatorResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_130.MsgCreateValidatorResponse>, I>>(_: I): _130.MsgCreateValidatorResponse;
+                fromAmino(_: _130.MsgCreateValidatorResponseAmino): _130.MsgCreateValidatorResponse;
+                toAmino(_: _130.MsgCreateValidatorResponse): _130.MsgCreateValidatorResponseAmino;
+                fromAminoMsg(object: _130.MsgCreateValidatorResponseAminoMsg): _130.MsgCreateValidatorResponse;
+                fromProtoMsg(message: _130.MsgCreateValidatorResponseProtoMsg): _130.MsgCreateValidatorResponse;
+                toProto(message: _130.MsgCreateValidatorResponse): Uint8Array;
+                toProtoMsg(message: _130.MsgCreateValidatorResponse): _130.MsgCreateValidatorResponseProtoMsg;
+            };
+            QueryPendingValidatorsRequest: {
+                typeUrl: string;
+                is(o: any): o is _129.QueryPendingValidatorsRequest;
+                isSDK(o: any): o is _129.QueryPendingValidatorsRequestSDKType;
+                isAmino(o: any): o is _129.QueryPendingValidatorsRequestAmino;
+                encode(_: _129.QueryPendingValidatorsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.QueryPendingValidatorsRequest;
+                fromJSON(_: any): _129.QueryPendingValidatorsRequest;
+                toJSON(_: _129.QueryPendingValidatorsRequest): import("..").JsonSafe<_129.QueryPendingValidatorsRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_129.QueryPendingValidatorsRequest>, I>>(_: I): _129.QueryPendingValidatorsRequest;
+                fromAmino(_: _129.QueryPendingValidatorsRequestAmino): _129.QueryPendingValidatorsRequest;
+                toAmino(_: _129.QueryPendingValidatorsRequest): _129.QueryPendingValidatorsRequestAmino;
+                fromAminoMsg(object: _129.QueryPendingValidatorsRequestAminoMsg): _129.QueryPendingValidatorsRequest;
+                fromProtoMsg(message: _129.QueryPendingValidatorsRequestProtoMsg): _129.QueryPendingValidatorsRequest;
+                toProto(message: _129.QueryPendingValidatorsRequest): Uint8Array;
+                toProtoMsg(message: _129.QueryPendingValidatorsRequest): _129.QueryPendingValidatorsRequestProtoMsg;
+            };
+            PendingValidatorsResponse: {
+                typeUrl: string;
+                is(o: any): o is _129.PendingValidatorsResponse;
+                isSDK(o: any): o is _129.PendingValidatorsResponseSDKType;
+                isAmino(o: any): o is _129.PendingValidatorsResponseAmino;
+                encode(message: _129.PendingValidatorsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.PendingValidatorsResponse;
+                fromJSON(object: any): _129.PendingValidatorsResponse;
+                toJSON(message: _129.PendingValidatorsResponse): import("..").JsonSafe<_129.PendingValidatorsResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_129.PendingValidatorsResponse>, I>>(object: I): _129.PendingValidatorsResponse;
+                fromAmino(object: _129.PendingValidatorsResponseAmino): _129.PendingValidatorsResponse;
+                toAmino(message: _129.PendingValidatorsResponse): _129.PendingValidatorsResponseAmino;
+                fromAminoMsg(object: _129.PendingValidatorsResponseAminoMsg): _129.PendingValidatorsResponse;
+                fromProtoMsg(message: _129.PendingValidatorsResponseProtoMsg): _129.PendingValidatorsResponse;
+                toProto(message: _129.PendingValidatorsResponse): Uint8Array;
+                toProtoMsg(message: _129.PendingValidatorsResponse): _129.PendingValidatorsResponseProtoMsg;
+            };
+            QueryConsensusPowerRequest: {
+                typeUrl: string;
+                is(o: any): o is _129.QueryConsensusPowerRequest;
+                isSDK(o: any): o is _129.QueryConsensusPowerRequestSDKType;
+                isAmino(o: any): o is _129.QueryConsensusPowerRequestAmino;
+                encode(message: _129.QueryConsensusPowerRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.QueryConsensusPowerRequest;
+                fromJSON(object: any): _129.QueryConsensusPowerRequest;
+                toJSON(message: _129.QueryConsensusPowerRequest): import("..").JsonSafe<_129.QueryConsensusPowerRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_129.QueryConsensusPowerRequest>, I>>(object: I): _129.QueryConsensusPowerRequest;
+                fromAmino(object: _129.QueryConsensusPowerRequestAmino): _129.QueryConsensusPowerRequest;
+                toAmino(message: _129.QueryConsensusPowerRequest): _129.QueryConsensusPowerRequestAmino;
+                fromAminoMsg(object: _129.QueryConsensusPowerRequestAminoMsg): _129.QueryConsensusPowerRequest;
+                fromProtoMsg(message: _129.QueryConsensusPowerRequestProtoMsg): _129.QueryConsensusPowerRequest;
+                toProto(message: _129.QueryConsensusPowerRequest): Uint8Array;
+                toProtoMsg(message: _129.QueryConsensusPowerRequest): _129.QueryConsensusPowerRequestProtoMsg;
+            };
+            QueryConsensusPowerResponse: {
+                typeUrl: string;
+                is(o: any): o is _129.QueryConsensusPowerResponse;
+                isSDK(o: any): o is _129.QueryConsensusPowerResponseSDKType;
+                isAmino(o: any): o is _129.QueryConsensusPowerResponseAmino;
+                encode(message: _129.QueryConsensusPowerResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.QueryConsensusPowerResponse;
+                fromJSON(object: any): _129.QueryConsensusPowerResponse;
+                toJSON(message: _129.QueryConsensusPowerResponse): import("..").JsonSafe<_129.QueryConsensusPowerResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_129.QueryConsensusPowerResponse>, I>>(object: I): _129.QueryConsensusPowerResponse;
+                fromAmino(object: _129.QueryConsensusPowerResponseAmino): _129.QueryConsensusPowerResponse;
+                toAmino(message: _129.QueryConsensusPowerResponse): _129.QueryConsensusPowerResponseAmino;
+                fromAminoMsg(object: _129.QueryConsensusPowerResponseAminoMsg): _129.QueryConsensusPowerResponse;
+                fromProtoMsg(message: _129.QueryConsensusPowerResponseProtoMsg): _129.QueryConsensusPowerResponse;
+                toProto(message: _129.QueryConsensusPowerResponse): Uint8Array;
+                toProtoMsg(message: _129.QueryConsensusPowerResponse): _129.QueryConsensusPowerResponseProtoMsg;
+            };
+            QueryPoaAuthorityRequest: {
+                typeUrl: string;
+                is(o: any): o is _129.QueryPoaAuthorityRequest;
+                isSDK(o: any): o is _129.QueryPoaAuthorityRequestSDKType;
+                isAmino(o: any): o is _129.QueryPoaAuthorityRequestAmino;
+                encode(_: _129.QueryPoaAuthorityRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.QueryPoaAuthorityRequest;
+                fromJSON(_: any): _129.QueryPoaAuthorityRequest;
+                toJSON(_: _129.QueryPoaAuthorityRequest): import("..").JsonSafe<_129.QueryPoaAuthorityRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_129.QueryPoaAuthorityRequest>, I>>(_: I): _129.QueryPoaAuthorityRequest;
+                fromAmino(_: _129.QueryPoaAuthorityRequestAmino): _129.QueryPoaAuthorityRequest;
+                toAmino(_: _129.QueryPoaAuthorityRequest): _129.QueryPoaAuthorityRequestAmino;
+                fromAminoMsg(object: _129.QueryPoaAuthorityRequestAminoMsg): _129.QueryPoaAuthorityRequest;
+                fromProtoMsg(message: _129.QueryPoaAuthorityRequestProtoMsg): _129.QueryPoaAuthorityRequest;
+                toProto(message: _129.QueryPoaAuthorityRequest): Uint8Array;
+                toProtoMsg(message: _129.QueryPoaAuthorityRequest): _129.QueryPoaAuthorityRequestProtoMsg;
+            };
+            QueryPoaAuthorityResponse: {
+                typeUrl: string;
+                is(o: any): o is _129.QueryPoaAuthorityResponse;
+                isSDK(o: any): o is _129.QueryPoaAuthorityResponseSDKType;
+                isAmino(o: any): o is _129.QueryPoaAuthorityResponseAmino;
+                encode(message: _129.QueryPoaAuthorityResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.QueryPoaAuthorityResponse;
+                fromJSON(object: any): _129.QueryPoaAuthorityResponse;
+                toJSON(message: _129.QueryPoaAuthorityResponse): import("..").JsonSafe<_129.QueryPoaAuthorityResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_129.QueryPoaAuthorityResponse>, I>>(object: I): _129.QueryPoaAuthorityResponse;
+                fromAmino(object: _129.QueryPoaAuthorityResponseAmino): _129.QueryPoaAuthorityResponse;
+                toAmino(message: _129.QueryPoaAuthorityResponse): _129.QueryPoaAuthorityResponseAmino;
+                fromAminoMsg(object: _129.QueryPoaAuthorityResponseAminoMsg): _129.QueryPoaAuthorityResponse;
+                fromProtoMsg(message: _129.QueryPoaAuthorityResponseProtoMsg): _129.QueryPoaAuthorityResponse;
+                toProto(message: _129.QueryPoaAuthorityResponse): Uint8Array;
+                toProtoMsg(message: _129.QueryPoaAuthorityResponse): _129.QueryPoaAuthorityResponseProtoMsg;
+            };
+            StakingParams: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _128.StakingParams;
+                isSDK(o: any): o is _128.StakingParamsSDKType;
+                isAmino(o: any): o is _128.StakingParamsAmino;
+                encode(message: _128.StakingParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _128.StakingParams;
+                fromJSON(object: any): _128.StakingParams;
+                toJSON(message: _128.StakingParams): import("..").JsonSafe<_128.StakingParams>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_128.StakingParams>, I>>(object: I): _128.StakingParams;
+                fromAmino(object: _128.StakingParamsAmino): _128.StakingParams;
+                toAmino(message: _128.StakingParams): _128.StakingParamsAmino;
+                fromAminoMsg(object: _128.StakingParamsAminoMsg): _128.StakingParams;
+                toAminoMsg(message: _128.StakingParams): _128.StakingParamsAminoMsg;
+                fromProtoMsg(message: _128.StakingParamsProtoMsg): _128.StakingParams;
+                toProto(message: _128.StakingParams): Uint8Array;
+                toProtoMsg(message: _128.StakingParams): _128.StakingParamsProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                is(o: any): o is _127.GenesisState;
+                isSDK(o: any): o is _127.GenesisStateSDKType;
+                isAmino(o: any): o is _127.GenesisStateAmino;
+                encode(message: _127.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.GenesisState;
+                fromJSON(object: any): _127.GenesisState;
+                toJSON(message: _127.GenesisState): import("..").JsonSafe<_127.GenesisState>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_127.GenesisState>, I>>(object: I): _127.GenesisState;
+                fromAmino(object: _127.GenesisStateAmino): _127.GenesisState;
+                toAmino(message: _127.GenesisState): _127.GenesisStateAmino;
+                fromAminoMsg(object: _127.GenesisStateAminoMsg): _127.GenesisState;
+                fromProtoMsg(message: _127.GenesisStateProtoMsg): _127.GenesisState;
+                toProto(message: _127.GenesisState): Uint8Array;
+                toProtoMsg(message: _127.GenesisState): _127.GenesisStateProtoMsg;
+            };
+            PowerCache: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _127.PowerCache;
+                isSDK(o: any): o is _127.PowerCacheSDKType;
+                isAmino(o: any): o is _127.PowerCacheAmino;
+                encode(message: _127.PowerCache, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.PowerCache;
+                fromJSON(object: any): _127.PowerCache;
+                toJSON(message: _127.PowerCache): import("..").JsonSafe<_127.PowerCache>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_127.PowerCache>, I>>(object: I): _127.PowerCache;
+                fromAmino(object: _127.PowerCacheAmino): _127.PowerCache;
+                toAmino(message: _127.PowerCache): _127.PowerCacheAmino;
+                fromAminoMsg(object: _127.PowerCacheAminoMsg): _127.PowerCache;
+                toAminoMsg(message: _127.PowerCache): _127.PowerCacheAminoMsg;
+                fromProtoMsg(message: _127.PowerCacheProtoMsg): _127.PowerCache;
+                toProto(message: _127.PowerCache): Uint8Array;
+                toProtoMsg(message: _127.PowerCache): _127.PowerCacheProtoMsg;
+            };
+        };
+    }
+    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;
+                };
+            };
+            strangelove_ventures: {
+                poa: {
+                    v1: _256.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;
+                };
+            };
+            strangelove_ventures: {
+                poa: {
+                    v1: _256.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>;
+                    };
+                };
+            };
+            strangelove_ventures: {
+                poa: {
+                    v1: {
+                        pendingValidators(request?: _129.QueryPendingValidatorsRequest): Promise<_129.PendingValidatorsResponse>;
+                        consensusPower(request: _129.QueryConsensusPowerRequest): Promise<_129.QueryConsensusPowerResponse>;
+                        poaAuthority(request?: _129.QueryPoaAuthorityRequest): Promise<_129.QueryPoaAuthorityResponse>;
+                    };
+                };
+            };
+        }>;
+        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;
+                };
+            };
+            strangelove_ventures: {
+                poa: {
+                    v1: _254.LCDQueryClient;
+                };
+            };
+        }>;
+    };
+}