import * as _127 from './airdrop/tx';
import * as _135 from './claim/tx';
import * as _149 from './icaoracle/tx';
import * as _151 from './interchainquery/v1/messages';
import * as _163 from './stakedym/stakedym';
import * as _164 from './stakedym/tx';
import * as _176 from './stakeibc/tx';
import * as _177 from './stakeibc/validator';
import * as _180 from './staketia/staketia';
import * as _181 from './staketia/tx';
export declare namespace stride {
    const airdrop: {
        registry: readonly [string, import("..").TelescopeGeneratedType<any, any, any>][];
        load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
        MessageComposer: {
            encoded: {
                claimDaily(value: _127.MsgClaimDaily): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                claimEarly(value: _127.MsgClaimEarly): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                createAirdrop(value: _127.MsgCreateAirdrop): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateAirdrop(value: _127.MsgUpdateAirdrop): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                addAllocations(value: _127.MsgAddAllocations): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateUserAllocation(value: _127.MsgUpdateUserAllocation): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                linkAddresses(value: _127.MsgLinkAddresses): {
                    typeUrl: string;
                    value: Uint8Array;
                };
            };
            withTypeUrl: {
                claimDaily(value: _127.MsgClaimDaily): {
                    typeUrl: string;
                    value: _127.MsgClaimDaily;
                };
                claimEarly(value: _127.MsgClaimEarly): {
                    typeUrl: string;
                    value: _127.MsgClaimEarly;
                };
                createAirdrop(value: _127.MsgCreateAirdrop): {
                    typeUrl: string;
                    value: _127.MsgCreateAirdrop;
                };
                updateAirdrop(value: _127.MsgUpdateAirdrop): {
                    typeUrl: string;
                    value: _127.MsgUpdateAirdrop;
                };
                addAllocations(value: _127.MsgAddAllocations): {
                    typeUrl: string;
                    value: _127.MsgAddAllocations;
                };
                updateUserAllocation(value: _127.MsgUpdateUserAllocation): {
                    typeUrl: string;
                    value: _127.MsgUpdateUserAllocation;
                };
                linkAddresses(value: _127.MsgLinkAddresses): {
                    typeUrl: string;
                    value: _127.MsgLinkAddresses;
                };
            };
            fromPartial: {
                claimDaily(value: _127.MsgClaimDaily): {
                    typeUrl: string;
                    value: _127.MsgClaimDaily;
                };
                claimEarly(value: _127.MsgClaimEarly): {
                    typeUrl: string;
                    value: _127.MsgClaimEarly;
                };
                createAirdrop(value: _127.MsgCreateAirdrop): {
                    typeUrl: string;
                    value: _127.MsgCreateAirdrop;
                };
                updateAirdrop(value: _127.MsgUpdateAirdrop): {
                    typeUrl: string;
                    value: _127.MsgUpdateAirdrop;
                };
                addAllocations(value: _127.MsgAddAllocations): {
                    typeUrl: string;
                    value: _127.MsgAddAllocations;
                };
                updateUserAllocation(value: _127.MsgUpdateUserAllocation): {
                    typeUrl: string;
                    value: _127.MsgUpdateUserAllocation;
                };
                linkAddresses(value: _127.MsgLinkAddresses): {
                    typeUrl: string;
                    value: _127.MsgLinkAddresses;
                };
            };
        };
        AminoConverter: {
            "/stride.airdrop.MsgClaimDaily": {
                aminoType: string;
                toAmino: (message: _127.MsgClaimDaily) => _127.MsgClaimDailyAmino;
                fromAmino: (object: _127.MsgClaimDailyAmino) => _127.MsgClaimDaily;
            };
            "/stride.airdrop.MsgClaimEarly": {
                aminoType: string;
                toAmino: (message: _127.MsgClaimEarly) => _127.MsgClaimEarlyAmino;
                fromAmino: (object: _127.MsgClaimEarlyAmino) => _127.MsgClaimEarly;
            };
            "/stride.airdrop.MsgCreateAirdrop": {
                aminoType: string;
                toAmino: (message: _127.MsgCreateAirdrop) => _127.MsgCreateAirdropAmino;
                fromAmino: (object: _127.MsgCreateAirdropAmino) => _127.MsgCreateAirdrop;
            };
            "/stride.airdrop.MsgUpdateAirdrop": {
                aminoType: string;
                toAmino: (message: _127.MsgUpdateAirdrop) => _127.MsgUpdateAirdropAmino;
                fromAmino: (object: _127.MsgUpdateAirdropAmino) => _127.MsgUpdateAirdrop;
            };
            "/stride.airdrop.MsgAddAllocations": {
                aminoType: string;
                toAmino: (message: _127.MsgAddAllocations) => _127.MsgAddAllocationsAmino;
                fromAmino: (object: _127.MsgAddAllocationsAmino) => _127.MsgAddAllocations;
            };
            "/stride.airdrop.MsgUpdateUserAllocation": {
                aminoType: string;
                toAmino: (message: _127.MsgUpdateUserAllocation) => _127.MsgUpdateUserAllocationAmino;
                fromAmino: (object: _127.MsgUpdateUserAllocationAmino) => _127.MsgUpdateUserAllocation;
            };
            "/stride.airdrop.MsgLinkAddresses": {
                aminoType: string;
                toAmino: (message: _127.MsgLinkAddresses) => _127.MsgLinkAddressesAmino;
                fromAmino: (object: _127.MsgLinkAddressesAmino) => _127.MsgLinkAddresses;
            };
        };
        MsgClaimDaily: {
            typeUrl: string;
            encode(message: _127.MsgClaimDaily, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgClaimDaily;
            fromPartial(object: Partial<_127.MsgClaimDaily>): _127.MsgClaimDaily;
            fromAmino(object: _127.MsgClaimDailyAmino): _127.MsgClaimDaily;
            toAmino(message: _127.MsgClaimDaily): _127.MsgClaimDailyAmino;
            fromAminoMsg(object: _127.MsgClaimDailyAminoMsg): _127.MsgClaimDaily;
            toAminoMsg(message: _127.MsgClaimDaily): _127.MsgClaimDailyAminoMsg;
            fromProtoMsg(message: _127.MsgClaimDailyProtoMsg): _127.MsgClaimDaily;
            toProto(message: _127.MsgClaimDaily): Uint8Array;
            toProtoMsg(message: _127.MsgClaimDaily): _127.MsgClaimDailyProtoMsg;
        };
        MsgClaimDailyResponse: {
            typeUrl: string;
            encode(_: _127.MsgClaimDailyResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgClaimDailyResponse;
            fromPartial(_: Partial<_127.MsgClaimDailyResponse>): _127.MsgClaimDailyResponse;
            fromAmino(_: _127.MsgClaimDailyResponseAmino): _127.MsgClaimDailyResponse;
            toAmino(_: _127.MsgClaimDailyResponse): _127.MsgClaimDailyResponseAmino;
            fromAminoMsg(object: _127.MsgClaimDailyResponseAminoMsg): _127.MsgClaimDailyResponse;
            fromProtoMsg(message: _127.MsgClaimDailyResponseProtoMsg): _127.MsgClaimDailyResponse;
            toProto(message: _127.MsgClaimDailyResponse): Uint8Array;
            toProtoMsg(message: _127.MsgClaimDailyResponse): _127.MsgClaimDailyResponseProtoMsg;
        };
        MsgClaimEarly: {
            typeUrl: string;
            encode(message: _127.MsgClaimEarly, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgClaimEarly;
            fromPartial(object: Partial<_127.MsgClaimEarly>): _127.MsgClaimEarly;
            fromAmino(object: _127.MsgClaimEarlyAmino): _127.MsgClaimEarly;
            toAmino(message: _127.MsgClaimEarly): _127.MsgClaimEarlyAmino;
            fromAminoMsg(object: _127.MsgClaimEarlyAminoMsg): _127.MsgClaimEarly;
            toAminoMsg(message: _127.MsgClaimEarly): _127.MsgClaimEarlyAminoMsg;
            fromProtoMsg(message: _127.MsgClaimEarlyProtoMsg): _127.MsgClaimEarly;
            toProto(message: _127.MsgClaimEarly): Uint8Array;
            toProtoMsg(message: _127.MsgClaimEarly): _127.MsgClaimEarlyProtoMsg;
        };
        MsgClaimEarlyResponse: {
            typeUrl: string;
            encode(_: _127.MsgClaimEarlyResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgClaimEarlyResponse;
            fromPartial(_: Partial<_127.MsgClaimEarlyResponse>): _127.MsgClaimEarlyResponse;
            fromAmino(_: _127.MsgClaimEarlyResponseAmino): _127.MsgClaimEarlyResponse;
            toAmino(_: _127.MsgClaimEarlyResponse): _127.MsgClaimEarlyResponseAmino;
            fromAminoMsg(object: _127.MsgClaimEarlyResponseAminoMsg): _127.MsgClaimEarlyResponse;
            fromProtoMsg(message: _127.MsgClaimEarlyResponseProtoMsg): _127.MsgClaimEarlyResponse;
            toProto(message: _127.MsgClaimEarlyResponse): Uint8Array;
            toProtoMsg(message: _127.MsgClaimEarlyResponse): _127.MsgClaimEarlyResponseProtoMsg;
        };
        MsgCreateAirdrop: {
            typeUrl: string;
            encode(message: _127.MsgCreateAirdrop, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgCreateAirdrop;
            fromPartial(object: Partial<_127.MsgCreateAirdrop>): _127.MsgCreateAirdrop;
            fromAmino(object: _127.MsgCreateAirdropAmino): _127.MsgCreateAirdrop;
            toAmino(message: _127.MsgCreateAirdrop): _127.MsgCreateAirdropAmino;
            fromAminoMsg(object: _127.MsgCreateAirdropAminoMsg): _127.MsgCreateAirdrop;
            toAminoMsg(message: _127.MsgCreateAirdrop): _127.MsgCreateAirdropAminoMsg;
            fromProtoMsg(message: _127.MsgCreateAirdropProtoMsg): _127.MsgCreateAirdrop;
            toProto(message: _127.MsgCreateAirdrop): Uint8Array;
            toProtoMsg(message: _127.MsgCreateAirdrop): _127.MsgCreateAirdropProtoMsg;
        };
        MsgCreateAirdropResponse: {
            typeUrl: string;
            encode(_: _127.MsgCreateAirdropResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgCreateAirdropResponse;
            fromPartial(_: Partial<_127.MsgCreateAirdropResponse>): _127.MsgCreateAirdropResponse;
            fromAmino(_: _127.MsgCreateAirdropResponseAmino): _127.MsgCreateAirdropResponse;
            toAmino(_: _127.MsgCreateAirdropResponse): _127.MsgCreateAirdropResponseAmino;
            fromAminoMsg(object: _127.MsgCreateAirdropResponseAminoMsg): _127.MsgCreateAirdropResponse;
            fromProtoMsg(message: _127.MsgCreateAirdropResponseProtoMsg): _127.MsgCreateAirdropResponse;
            toProto(message: _127.MsgCreateAirdropResponse): Uint8Array;
            toProtoMsg(message: _127.MsgCreateAirdropResponse): _127.MsgCreateAirdropResponseProtoMsg;
        };
        MsgUpdateAirdrop: {
            typeUrl: string;
            encode(message: _127.MsgUpdateAirdrop, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgUpdateAirdrop;
            fromPartial(object: Partial<_127.MsgUpdateAirdrop>): _127.MsgUpdateAirdrop;
            fromAmino(object: _127.MsgUpdateAirdropAmino): _127.MsgUpdateAirdrop;
            toAmino(message: _127.MsgUpdateAirdrop): _127.MsgUpdateAirdropAmino;
            fromAminoMsg(object: _127.MsgUpdateAirdropAminoMsg): _127.MsgUpdateAirdrop;
            toAminoMsg(message: _127.MsgUpdateAirdrop): _127.MsgUpdateAirdropAminoMsg;
            fromProtoMsg(message: _127.MsgUpdateAirdropProtoMsg): _127.MsgUpdateAirdrop;
            toProto(message: _127.MsgUpdateAirdrop): Uint8Array;
            toProtoMsg(message: _127.MsgUpdateAirdrop): _127.MsgUpdateAirdropProtoMsg;
        };
        MsgUpdateAirdropResponse: {
            typeUrl: string;
            encode(_: _127.MsgUpdateAirdropResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgUpdateAirdropResponse;
            fromPartial(_: Partial<_127.MsgUpdateAirdropResponse>): _127.MsgUpdateAirdropResponse;
            fromAmino(_: _127.MsgUpdateAirdropResponseAmino): _127.MsgUpdateAirdropResponse;
            toAmino(_: _127.MsgUpdateAirdropResponse): _127.MsgUpdateAirdropResponseAmino;
            fromAminoMsg(object: _127.MsgUpdateAirdropResponseAminoMsg): _127.MsgUpdateAirdropResponse;
            fromProtoMsg(message: _127.MsgUpdateAirdropResponseProtoMsg): _127.MsgUpdateAirdropResponse;
            toProto(message: _127.MsgUpdateAirdropResponse): Uint8Array;
            toProtoMsg(message: _127.MsgUpdateAirdropResponse): _127.MsgUpdateAirdropResponseProtoMsg;
        };
        RawAllocation: {
            typeUrl: string;
            encode(message: _127.RawAllocation, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.RawAllocation;
            fromPartial(object: Partial<_127.RawAllocation>): _127.RawAllocation;
            fromAmino(object: _127.RawAllocationAmino): _127.RawAllocation;
            toAmino(message: _127.RawAllocation): _127.RawAllocationAmino;
            fromAminoMsg(object: _127.RawAllocationAminoMsg): _127.RawAllocation;
            fromProtoMsg(message: _127.RawAllocationProtoMsg): _127.RawAllocation;
            toProto(message: _127.RawAllocation): Uint8Array;
            toProtoMsg(message: _127.RawAllocation): _127.RawAllocationProtoMsg;
        };
        MsgAddAllocations: {
            typeUrl: string;
            encode(message: _127.MsgAddAllocations, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgAddAllocations;
            fromPartial(object: Partial<_127.MsgAddAllocations>): _127.MsgAddAllocations;
            fromAmino(object: _127.MsgAddAllocationsAmino): _127.MsgAddAllocations;
            toAmino(message: _127.MsgAddAllocations): _127.MsgAddAllocationsAmino;
            fromAminoMsg(object: _127.MsgAddAllocationsAminoMsg): _127.MsgAddAllocations;
            toAminoMsg(message: _127.MsgAddAllocations): _127.MsgAddAllocationsAminoMsg;
            fromProtoMsg(message: _127.MsgAddAllocationsProtoMsg): _127.MsgAddAllocations;
            toProto(message: _127.MsgAddAllocations): Uint8Array;
            toProtoMsg(message: _127.MsgAddAllocations): _127.MsgAddAllocationsProtoMsg;
        };
        MsgAddAllocationsResponse: {
            typeUrl: string;
            encode(_: _127.MsgAddAllocationsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgAddAllocationsResponse;
            fromPartial(_: Partial<_127.MsgAddAllocationsResponse>): _127.MsgAddAllocationsResponse;
            fromAmino(_: _127.MsgAddAllocationsResponseAmino): _127.MsgAddAllocationsResponse;
            toAmino(_: _127.MsgAddAllocationsResponse): _127.MsgAddAllocationsResponseAmino;
            fromAminoMsg(object: _127.MsgAddAllocationsResponseAminoMsg): _127.MsgAddAllocationsResponse;
            fromProtoMsg(message: _127.MsgAddAllocationsResponseProtoMsg): _127.MsgAddAllocationsResponse;
            toProto(message: _127.MsgAddAllocationsResponse): Uint8Array;
            toProtoMsg(message: _127.MsgAddAllocationsResponse): _127.MsgAddAllocationsResponseProtoMsg;
        };
        MsgUpdateUserAllocation: {
            typeUrl: string;
            encode(message: _127.MsgUpdateUserAllocation, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgUpdateUserAllocation;
            fromPartial(object: Partial<_127.MsgUpdateUserAllocation>): _127.MsgUpdateUserAllocation;
            fromAmino(object: _127.MsgUpdateUserAllocationAmino): _127.MsgUpdateUserAllocation;
            toAmino(message: _127.MsgUpdateUserAllocation): _127.MsgUpdateUserAllocationAmino;
            fromAminoMsg(object: _127.MsgUpdateUserAllocationAminoMsg): _127.MsgUpdateUserAllocation;
            toAminoMsg(message: _127.MsgUpdateUserAllocation): _127.MsgUpdateUserAllocationAminoMsg;
            fromProtoMsg(message: _127.MsgUpdateUserAllocationProtoMsg): _127.MsgUpdateUserAllocation;
            toProto(message: _127.MsgUpdateUserAllocation): Uint8Array;
            toProtoMsg(message: _127.MsgUpdateUserAllocation): _127.MsgUpdateUserAllocationProtoMsg;
        };
        MsgUpdateUserAllocationResponse: {
            typeUrl: string;
            encode(_: _127.MsgUpdateUserAllocationResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgUpdateUserAllocationResponse;
            fromPartial(_: Partial<_127.MsgUpdateUserAllocationResponse>): _127.MsgUpdateUserAllocationResponse;
            fromAmino(_: _127.MsgUpdateUserAllocationResponseAmino): _127.MsgUpdateUserAllocationResponse;
            toAmino(_: _127.MsgUpdateUserAllocationResponse): _127.MsgUpdateUserAllocationResponseAmino;
            fromAminoMsg(object: _127.MsgUpdateUserAllocationResponseAminoMsg): _127.MsgUpdateUserAllocationResponse;
            fromProtoMsg(message: _127.MsgUpdateUserAllocationResponseProtoMsg): _127.MsgUpdateUserAllocationResponse;
            toProto(message: _127.MsgUpdateUserAllocationResponse): Uint8Array;
            toProtoMsg(message: _127.MsgUpdateUserAllocationResponse): _127.MsgUpdateUserAllocationResponseProtoMsg;
        };
        MsgLinkAddresses: {
            typeUrl: string;
            encode(message: _127.MsgLinkAddresses, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgLinkAddresses;
            fromPartial(object: Partial<_127.MsgLinkAddresses>): _127.MsgLinkAddresses;
            fromAmino(object: _127.MsgLinkAddressesAmino): _127.MsgLinkAddresses;
            toAmino(message: _127.MsgLinkAddresses): _127.MsgLinkAddressesAmino;
            fromAminoMsg(object: _127.MsgLinkAddressesAminoMsg): _127.MsgLinkAddresses;
            toAminoMsg(message: _127.MsgLinkAddresses): _127.MsgLinkAddressesAminoMsg;
            fromProtoMsg(message: _127.MsgLinkAddressesProtoMsg): _127.MsgLinkAddresses;
            toProto(message: _127.MsgLinkAddresses): Uint8Array;
            toProtoMsg(message: _127.MsgLinkAddresses): _127.MsgLinkAddressesProtoMsg;
        };
        MsgLinkAddressesResponse: {
            typeUrl: string;
            encode(_: _127.MsgLinkAddressesResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _127.MsgLinkAddressesResponse;
            fromPartial(_: Partial<_127.MsgLinkAddressesResponse>): _127.MsgLinkAddressesResponse;
            fromAmino(_: _127.MsgLinkAddressesResponseAmino): _127.MsgLinkAddressesResponse;
            toAmino(_: _127.MsgLinkAddressesResponse): _127.MsgLinkAddressesResponseAmino;
            fromAminoMsg(object: _127.MsgLinkAddressesResponseAminoMsg): _127.MsgLinkAddressesResponse;
            fromProtoMsg(message: _127.MsgLinkAddressesResponseProtoMsg): _127.MsgLinkAddressesResponse;
            toProto(message: _127.MsgLinkAddressesResponse): Uint8Array;
            toProtoMsg(message: _127.MsgLinkAddressesResponse): _127.MsgLinkAddressesResponseProtoMsg;
        };
    };
    const claim: {
        registry: readonly [string, import("..").TelescopeGeneratedType<any, any, any>][];
        load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
        MessageComposer: {
            encoded: {
                setAirdropAllocations(value: _135.MsgSetAirdropAllocations): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                claimFreeAmount(value: _135.MsgClaimFreeAmount): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                createAirdrop(value: _135.MsgCreateAirdrop): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                deleteAirdrop(value: _135.MsgDeleteAirdrop): {
                    typeUrl: string;
                    value: Uint8Array;
                };
            };
            withTypeUrl: {
                setAirdropAllocations(value: _135.MsgSetAirdropAllocations): {
                    typeUrl: string;
                    value: _135.MsgSetAirdropAllocations;
                };
                claimFreeAmount(value: _135.MsgClaimFreeAmount): {
                    typeUrl: string;
                    value: _135.MsgClaimFreeAmount;
                };
                createAirdrop(value: _135.MsgCreateAirdrop): {
                    typeUrl: string;
                    value: _135.MsgCreateAirdrop;
                };
                deleteAirdrop(value: _135.MsgDeleteAirdrop): {
                    typeUrl: string;
                    value: _135.MsgDeleteAirdrop;
                };
            };
            fromPartial: {
                setAirdropAllocations(value: _135.MsgSetAirdropAllocations): {
                    typeUrl: string;
                    value: _135.MsgSetAirdropAllocations;
                };
                claimFreeAmount(value: _135.MsgClaimFreeAmount): {
                    typeUrl: string;
                    value: _135.MsgClaimFreeAmount;
                };
                createAirdrop(value: _135.MsgCreateAirdrop): {
                    typeUrl: string;
                    value: _135.MsgCreateAirdrop;
                };
                deleteAirdrop(value: _135.MsgDeleteAirdrop): {
                    typeUrl: string;
                    value: _135.MsgDeleteAirdrop;
                };
            };
        };
        AminoConverter: {
            "/stride.claim.MsgSetAirdropAllocations": {
                aminoType: string;
                toAmino: (message: _135.MsgSetAirdropAllocations) => _135.MsgSetAirdropAllocationsAmino;
                fromAmino: (object: _135.MsgSetAirdropAllocationsAmino) => _135.MsgSetAirdropAllocations;
            };
            "/stride.claim.MsgClaimFreeAmount": {
                aminoType: string;
                toAmino: (message: _135.MsgClaimFreeAmount) => _135.MsgClaimFreeAmountAmino;
                fromAmino: (object: _135.MsgClaimFreeAmountAmino) => _135.MsgClaimFreeAmount;
            };
            "/stride.claim.MsgCreateAirdrop": {
                aminoType: string;
                toAmino: (message: _135.MsgCreateAirdrop) => _135.MsgCreateAirdropAmino;
                fromAmino: (object: _135.MsgCreateAirdropAmino) => _135.MsgCreateAirdrop;
            };
            "/stride.claim.MsgDeleteAirdrop": {
                aminoType: string;
                toAmino: (message: _135.MsgDeleteAirdrop) => _135.MsgDeleteAirdropAmino;
                fromAmino: (object: _135.MsgDeleteAirdropAmino) => _135.MsgDeleteAirdrop;
            };
        };
        MsgSetAirdropAllocations: {
            typeUrl: string;
            encode(message: _135.MsgSetAirdropAllocations, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgSetAirdropAllocations;
            fromPartial(object: Partial<_135.MsgSetAirdropAllocations>): _135.MsgSetAirdropAllocations;
            fromAmino(object: _135.MsgSetAirdropAllocationsAmino): _135.MsgSetAirdropAllocations;
            toAmino(message: _135.MsgSetAirdropAllocations): _135.MsgSetAirdropAllocationsAmino;
            fromAminoMsg(object: _135.MsgSetAirdropAllocationsAminoMsg): _135.MsgSetAirdropAllocations;
            fromProtoMsg(message: _135.MsgSetAirdropAllocationsProtoMsg): _135.MsgSetAirdropAllocations;
            toProto(message: _135.MsgSetAirdropAllocations): Uint8Array;
            toProtoMsg(message: _135.MsgSetAirdropAllocations): _135.MsgSetAirdropAllocationsProtoMsg;
        };
        MsgSetAirdropAllocationsResponse: {
            typeUrl: string;
            encode(_: _135.MsgSetAirdropAllocationsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgSetAirdropAllocationsResponse;
            fromPartial(_: Partial<_135.MsgSetAirdropAllocationsResponse>): _135.MsgSetAirdropAllocationsResponse;
            fromAmino(_: _135.MsgSetAirdropAllocationsResponseAmino): _135.MsgSetAirdropAllocationsResponse;
            toAmino(_: _135.MsgSetAirdropAllocationsResponse): _135.MsgSetAirdropAllocationsResponseAmino;
            fromAminoMsg(object: _135.MsgSetAirdropAllocationsResponseAminoMsg): _135.MsgSetAirdropAllocationsResponse;
            fromProtoMsg(message: _135.MsgSetAirdropAllocationsResponseProtoMsg): _135.MsgSetAirdropAllocationsResponse;
            toProto(message: _135.MsgSetAirdropAllocationsResponse): Uint8Array;
            toProtoMsg(message: _135.MsgSetAirdropAllocationsResponse): _135.MsgSetAirdropAllocationsResponseProtoMsg;
        };
        MsgClaimFreeAmount: {
            typeUrl: string;
            encode(message: _135.MsgClaimFreeAmount, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgClaimFreeAmount;
            fromPartial(object: Partial<_135.MsgClaimFreeAmount>): _135.MsgClaimFreeAmount;
            fromAmino(object: _135.MsgClaimFreeAmountAmino): _135.MsgClaimFreeAmount;
            toAmino(message: _135.MsgClaimFreeAmount): _135.MsgClaimFreeAmountAmino;
            fromAminoMsg(object: _135.MsgClaimFreeAmountAminoMsg): _135.MsgClaimFreeAmount;
            toAminoMsg(message: _135.MsgClaimFreeAmount): _135.MsgClaimFreeAmountAminoMsg;
            fromProtoMsg(message: _135.MsgClaimFreeAmountProtoMsg): _135.MsgClaimFreeAmount;
            toProto(message: _135.MsgClaimFreeAmount): Uint8Array;
            toProtoMsg(message: _135.MsgClaimFreeAmount): _135.MsgClaimFreeAmountProtoMsg;
        };
        MsgClaimFreeAmountResponse: {
            typeUrl: string;
            encode(message: _135.MsgClaimFreeAmountResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgClaimFreeAmountResponse;
            fromPartial(object: Partial<_135.MsgClaimFreeAmountResponse>): _135.MsgClaimFreeAmountResponse;
            fromAmino(object: _135.MsgClaimFreeAmountResponseAmino): _135.MsgClaimFreeAmountResponse;
            toAmino(message: _135.MsgClaimFreeAmountResponse): _135.MsgClaimFreeAmountResponseAmino;
            fromAminoMsg(object: _135.MsgClaimFreeAmountResponseAminoMsg): _135.MsgClaimFreeAmountResponse;
            fromProtoMsg(message: _135.MsgClaimFreeAmountResponseProtoMsg): _135.MsgClaimFreeAmountResponse;
            toProto(message: _135.MsgClaimFreeAmountResponse): Uint8Array;
            toProtoMsg(message: _135.MsgClaimFreeAmountResponse): _135.MsgClaimFreeAmountResponseProtoMsg;
        };
        MsgCreateAirdrop: {
            typeUrl: string;
            encode(message: _135.MsgCreateAirdrop, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgCreateAirdrop;
            fromPartial(object: Partial<_135.MsgCreateAirdrop>): _135.MsgCreateAirdrop;
            fromAmino(object: _135.MsgCreateAirdropAmino): _135.MsgCreateAirdrop;
            toAmino(message: _135.MsgCreateAirdrop): _135.MsgCreateAirdropAmino;
            fromAminoMsg(object: _135.MsgCreateAirdropAminoMsg): _135.MsgCreateAirdrop;
            fromProtoMsg(message: _135.MsgCreateAirdropProtoMsg): _135.MsgCreateAirdrop;
            toProto(message: _135.MsgCreateAirdrop): Uint8Array;
            toProtoMsg(message: _135.MsgCreateAirdrop): _135.MsgCreateAirdropProtoMsg;
        };
        MsgCreateAirdropResponse: {
            typeUrl: string;
            encode(_: _135.MsgCreateAirdropResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgCreateAirdropResponse;
            fromPartial(_: Partial<_135.MsgCreateAirdropResponse>): _135.MsgCreateAirdropResponse;
            fromAmino(_: _135.MsgCreateAirdropResponseAmino): _135.MsgCreateAirdropResponse;
            toAmino(_: _135.MsgCreateAirdropResponse): _135.MsgCreateAirdropResponseAmino;
            fromAminoMsg(object: _135.MsgCreateAirdropResponseAminoMsg): _135.MsgCreateAirdropResponse;
            fromProtoMsg(message: _135.MsgCreateAirdropResponseProtoMsg): _135.MsgCreateAirdropResponse;
            toProto(message: _135.MsgCreateAirdropResponse): Uint8Array;
            toProtoMsg(message: _135.MsgCreateAirdropResponse): _135.MsgCreateAirdropResponseProtoMsg;
        };
        MsgDeleteAirdrop: {
            typeUrl: string;
            encode(message: _135.MsgDeleteAirdrop, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgDeleteAirdrop;
            fromPartial(object: Partial<_135.MsgDeleteAirdrop>): _135.MsgDeleteAirdrop;
            fromAmino(object: _135.MsgDeleteAirdropAmino): _135.MsgDeleteAirdrop;
            toAmino(message: _135.MsgDeleteAirdrop): _135.MsgDeleteAirdropAmino;
            fromAminoMsg(object: _135.MsgDeleteAirdropAminoMsg): _135.MsgDeleteAirdrop;
            fromProtoMsg(message: _135.MsgDeleteAirdropProtoMsg): _135.MsgDeleteAirdrop;
            toProto(message: _135.MsgDeleteAirdrop): Uint8Array;
            toProtoMsg(message: _135.MsgDeleteAirdrop): _135.MsgDeleteAirdropProtoMsg;
        };
        MsgDeleteAirdropResponse: {
            typeUrl: string;
            encode(_: _135.MsgDeleteAirdropResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _135.MsgDeleteAirdropResponse;
            fromPartial(_: Partial<_135.MsgDeleteAirdropResponse>): _135.MsgDeleteAirdropResponse;
            fromAmino(_: _135.MsgDeleteAirdropResponseAmino): _135.MsgDeleteAirdropResponse;
            toAmino(_: _135.MsgDeleteAirdropResponse): _135.MsgDeleteAirdropResponseAmino;
            fromAminoMsg(object: _135.MsgDeleteAirdropResponseAminoMsg): _135.MsgDeleteAirdropResponse;
            fromProtoMsg(message: _135.MsgDeleteAirdropResponseProtoMsg): _135.MsgDeleteAirdropResponse;
            toProto(message: _135.MsgDeleteAirdropResponse): Uint8Array;
            toProtoMsg(message: _135.MsgDeleteAirdropResponse): _135.MsgDeleteAirdropResponseProtoMsg;
        };
    };
    const icaoracle: {
        registry: readonly [string, import("..").TelescopeGeneratedType<any, any, any>][];
        load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
        MessageComposer: {
            encoded: {
                addOracle(value: _149.MsgAddOracle): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                instantiateOracle(value: _149.MsgInstantiateOracle): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                restoreOracleICA(value: _149.MsgRestoreOracleICA): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                toggleOracle(value: _149.MsgToggleOracle): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                removeOracle(value: _149.MsgRemoveOracle): {
                    typeUrl: string;
                    value: Uint8Array;
                };
            };
            withTypeUrl: {
                addOracle(value: _149.MsgAddOracle): {
                    typeUrl: string;
                    value: _149.MsgAddOracle;
                };
                instantiateOracle(value: _149.MsgInstantiateOracle): {
                    typeUrl: string;
                    value: _149.MsgInstantiateOracle;
                };
                restoreOracleICA(value: _149.MsgRestoreOracleICA): {
                    typeUrl: string;
                    value: _149.MsgRestoreOracleICA;
                };
                toggleOracle(value: _149.MsgToggleOracle): {
                    typeUrl: string;
                    value: _149.MsgToggleOracle;
                };
                removeOracle(value: _149.MsgRemoveOracle): {
                    typeUrl: string;
                    value: _149.MsgRemoveOracle;
                };
            };
            fromPartial: {
                addOracle(value: _149.MsgAddOracle): {
                    typeUrl: string;
                    value: _149.MsgAddOracle;
                };
                instantiateOracle(value: _149.MsgInstantiateOracle): {
                    typeUrl: string;
                    value: _149.MsgInstantiateOracle;
                };
                restoreOracleICA(value: _149.MsgRestoreOracleICA): {
                    typeUrl: string;
                    value: _149.MsgRestoreOracleICA;
                };
                toggleOracle(value: _149.MsgToggleOracle): {
                    typeUrl: string;
                    value: _149.MsgToggleOracle;
                };
                removeOracle(value: _149.MsgRemoveOracle): {
                    typeUrl: string;
                    value: _149.MsgRemoveOracle;
                };
            };
        };
        AminoConverter: {
            "/stride.icaoracle.MsgAddOracle": {
                aminoType: string;
                toAmino: (message: _149.MsgAddOracle) => _149.MsgAddOracleAmino;
                fromAmino: (object: _149.MsgAddOracleAmino) => _149.MsgAddOracle;
            };
            "/stride.icaoracle.MsgInstantiateOracle": {
                aminoType: string;
                toAmino: (message: _149.MsgInstantiateOracle) => _149.MsgInstantiateOracleAmino;
                fromAmino: (object: _149.MsgInstantiateOracleAmino) => _149.MsgInstantiateOracle;
            };
            "/stride.icaoracle.MsgRestoreOracleICA": {
                aminoType: string;
                toAmino: (message: _149.MsgRestoreOracleICA) => _149.MsgRestoreOracleICAAmino;
                fromAmino: (object: _149.MsgRestoreOracleICAAmino) => _149.MsgRestoreOracleICA;
            };
            "/stride.icaoracle.MsgToggleOracle": {
                aminoType: string;
                toAmino: (message: _149.MsgToggleOracle) => _149.MsgToggleOracleAmino;
                fromAmino: (object: _149.MsgToggleOracleAmino) => _149.MsgToggleOracle;
            };
            "/stride.icaoracle.MsgRemoveOracle": {
                aminoType: string;
                toAmino: (message: _149.MsgRemoveOracle) => _149.MsgRemoveOracleAmino;
                fromAmino: (object: _149.MsgRemoveOracleAmino) => _149.MsgRemoveOracle;
            };
        };
        MsgAddOracle: {
            typeUrl: string;
            encode(message: _149.MsgAddOracle, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgAddOracle;
            fromPartial(object: Partial<_149.MsgAddOracle>): _149.MsgAddOracle;
            fromAmino(object: _149.MsgAddOracleAmino): _149.MsgAddOracle;
            toAmino(message: _149.MsgAddOracle): _149.MsgAddOracleAmino;
            fromAminoMsg(object: _149.MsgAddOracleAminoMsg): _149.MsgAddOracle;
            toAminoMsg(message: _149.MsgAddOracle): _149.MsgAddOracleAminoMsg;
            fromProtoMsg(message: _149.MsgAddOracleProtoMsg): _149.MsgAddOracle;
            toProto(message: _149.MsgAddOracle): Uint8Array;
            toProtoMsg(message: _149.MsgAddOracle): _149.MsgAddOracleProtoMsg;
        };
        MsgAddOracleResponse: {
            typeUrl: string;
            encode(_: _149.MsgAddOracleResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgAddOracleResponse;
            fromPartial(_: Partial<_149.MsgAddOracleResponse>): _149.MsgAddOracleResponse;
            fromAmino(_: _149.MsgAddOracleResponseAmino): _149.MsgAddOracleResponse;
            toAmino(_: _149.MsgAddOracleResponse): _149.MsgAddOracleResponseAmino;
            fromAminoMsg(object: _149.MsgAddOracleResponseAminoMsg): _149.MsgAddOracleResponse;
            fromProtoMsg(message: _149.MsgAddOracleResponseProtoMsg): _149.MsgAddOracleResponse;
            toProto(message: _149.MsgAddOracleResponse): Uint8Array;
            toProtoMsg(message: _149.MsgAddOracleResponse): _149.MsgAddOracleResponseProtoMsg;
        };
        MsgInstantiateOracle: {
            typeUrl: string;
            encode(message: _149.MsgInstantiateOracle, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgInstantiateOracle;
            fromPartial(object: Partial<_149.MsgInstantiateOracle>): _149.MsgInstantiateOracle;
            fromAmino(object: _149.MsgInstantiateOracleAmino): _149.MsgInstantiateOracle;
            toAmino(message: _149.MsgInstantiateOracle): _149.MsgInstantiateOracleAmino;
            fromAminoMsg(object: _149.MsgInstantiateOracleAminoMsg): _149.MsgInstantiateOracle;
            toAminoMsg(message: _149.MsgInstantiateOracle): _149.MsgInstantiateOracleAminoMsg;
            fromProtoMsg(message: _149.MsgInstantiateOracleProtoMsg): _149.MsgInstantiateOracle;
            toProto(message: _149.MsgInstantiateOracle): Uint8Array;
            toProtoMsg(message: _149.MsgInstantiateOracle): _149.MsgInstantiateOracleProtoMsg;
        };
        MsgInstantiateOracleResponse: {
            typeUrl: string;
            encode(_: _149.MsgInstantiateOracleResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgInstantiateOracleResponse;
            fromPartial(_: Partial<_149.MsgInstantiateOracleResponse>): _149.MsgInstantiateOracleResponse;
            fromAmino(_: _149.MsgInstantiateOracleResponseAmino): _149.MsgInstantiateOracleResponse;
            toAmino(_: _149.MsgInstantiateOracleResponse): _149.MsgInstantiateOracleResponseAmino;
            fromAminoMsg(object: _149.MsgInstantiateOracleResponseAminoMsg): _149.MsgInstantiateOracleResponse;
            fromProtoMsg(message: _149.MsgInstantiateOracleResponseProtoMsg): _149.MsgInstantiateOracleResponse;
            toProto(message: _149.MsgInstantiateOracleResponse): Uint8Array;
            toProtoMsg(message: _149.MsgInstantiateOracleResponse): _149.MsgInstantiateOracleResponseProtoMsg;
        };
        MsgRestoreOracleICA: {
            typeUrl: string;
            encode(message: _149.MsgRestoreOracleICA, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgRestoreOracleICA;
            fromPartial(object: Partial<_149.MsgRestoreOracleICA>): _149.MsgRestoreOracleICA;
            fromAmino(object: _149.MsgRestoreOracleICAAmino): _149.MsgRestoreOracleICA;
            toAmino(message: _149.MsgRestoreOracleICA): _149.MsgRestoreOracleICAAmino;
            fromAminoMsg(object: _149.MsgRestoreOracleICAAminoMsg): _149.MsgRestoreOracleICA;
            toAminoMsg(message: _149.MsgRestoreOracleICA): _149.MsgRestoreOracleICAAminoMsg;
            fromProtoMsg(message: _149.MsgRestoreOracleICAProtoMsg): _149.MsgRestoreOracleICA;
            toProto(message: _149.MsgRestoreOracleICA): Uint8Array;
            toProtoMsg(message: _149.MsgRestoreOracleICA): _149.MsgRestoreOracleICAProtoMsg;
        };
        MsgRestoreOracleICAResponse: {
            typeUrl: string;
            encode(_: _149.MsgRestoreOracleICAResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgRestoreOracleICAResponse;
            fromPartial(_: Partial<_149.MsgRestoreOracleICAResponse>): _149.MsgRestoreOracleICAResponse;
            fromAmino(_: _149.MsgRestoreOracleICAResponseAmino): _149.MsgRestoreOracleICAResponse;
            toAmino(_: _149.MsgRestoreOracleICAResponse): _149.MsgRestoreOracleICAResponseAmino;
            fromAminoMsg(object: _149.MsgRestoreOracleICAResponseAminoMsg): _149.MsgRestoreOracleICAResponse;
            fromProtoMsg(message: _149.MsgRestoreOracleICAResponseProtoMsg): _149.MsgRestoreOracleICAResponse;
            toProto(message: _149.MsgRestoreOracleICAResponse): Uint8Array;
            toProtoMsg(message: _149.MsgRestoreOracleICAResponse): _149.MsgRestoreOracleICAResponseProtoMsg;
        };
        MsgToggleOracle: {
            typeUrl: string;
            encode(message: _149.MsgToggleOracle, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgToggleOracle;
            fromPartial(object: Partial<_149.MsgToggleOracle>): _149.MsgToggleOracle;
            fromAmino(object: _149.MsgToggleOracleAmino): _149.MsgToggleOracle;
            toAmino(message: _149.MsgToggleOracle): _149.MsgToggleOracleAmino;
            fromAminoMsg(object: _149.MsgToggleOracleAminoMsg): _149.MsgToggleOracle;
            toAminoMsg(message: _149.MsgToggleOracle): _149.MsgToggleOracleAminoMsg;
            fromProtoMsg(message: _149.MsgToggleOracleProtoMsg): _149.MsgToggleOracle;
            toProto(message: _149.MsgToggleOracle): Uint8Array;
            toProtoMsg(message: _149.MsgToggleOracle): _149.MsgToggleOracleProtoMsg;
        };
        MsgToggleOracleResponse: {
            typeUrl: string;
            encode(_: _149.MsgToggleOracleResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgToggleOracleResponse;
            fromPartial(_: Partial<_149.MsgToggleOracleResponse>): _149.MsgToggleOracleResponse;
            fromAmino(_: _149.MsgToggleOracleResponseAmino): _149.MsgToggleOracleResponse;
            toAmino(_: _149.MsgToggleOracleResponse): _149.MsgToggleOracleResponseAmino;
            fromAminoMsg(object: _149.MsgToggleOracleResponseAminoMsg): _149.MsgToggleOracleResponse;
            fromProtoMsg(message: _149.MsgToggleOracleResponseProtoMsg): _149.MsgToggleOracleResponse;
            toProto(message: _149.MsgToggleOracleResponse): Uint8Array;
            toProtoMsg(message: _149.MsgToggleOracleResponse): _149.MsgToggleOracleResponseProtoMsg;
        };
        MsgRemoveOracle: {
            typeUrl: string;
            encode(message: _149.MsgRemoveOracle, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgRemoveOracle;
            fromPartial(object: Partial<_149.MsgRemoveOracle>): _149.MsgRemoveOracle;
            fromAmino(object: _149.MsgRemoveOracleAmino): _149.MsgRemoveOracle;
            toAmino(message: _149.MsgRemoveOracle): _149.MsgRemoveOracleAmino;
            fromAminoMsg(object: _149.MsgRemoveOracleAminoMsg): _149.MsgRemoveOracle;
            toAminoMsg(message: _149.MsgRemoveOracle): _149.MsgRemoveOracleAminoMsg;
            fromProtoMsg(message: _149.MsgRemoveOracleProtoMsg): _149.MsgRemoveOracle;
            toProto(message: _149.MsgRemoveOracle): Uint8Array;
            toProtoMsg(message: _149.MsgRemoveOracle): _149.MsgRemoveOracleProtoMsg;
        };
        MsgRemoveOracleResponse: {
            typeUrl: string;
            encode(_: _149.MsgRemoveOracleResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _149.MsgRemoveOracleResponse;
            fromPartial(_: Partial<_149.MsgRemoveOracleResponse>): _149.MsgRemoveOracleResponse;
            fromAmino(_: _149.MsgRemoveOracleResponseAmino): _149.MsgRemoveOracleResponse;
            toAmino(_: _149.MsgRemoveOracleResponse): _149.MsgRemoveOracleResponseAmino;
            fromAminoMsg(object: _149.MsgRemoveOracleResponseAminoMsg): _149.MsgRemoveOracleResponse;
            fromProtoMsg(message: _149.MsgRemoveOracleResponseProtoMsg): _149.MsgRemoveOracleResponse;
            toProto(message: _149.MsgRemoveOracleResponse): Uint8Array;
            toProtoMsg(message: _149.MsgRemoveOracleResponse): _149.MsgRemoveOracleResponseProtoMsg;
        };
    };
    namespace interchainquery {
        const v1: {
            registry: readonly [string, import("..").TelescopeGeneratedType<any, any, any>][];
            load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
            MessageComposer: {
                encoded: {
                    submitQueryResponse(value: _151.MsgSubmitQueryResponse): {
                        typeUrl: string;
                        value: Uint8Array;
                    };
                };
                withTypeUrl: {
                    submitQueryResponse(value: _151.MsgSubmitQueryResponse): {
                        typeUrl: string;
                        value: _151.MsgSubmitQueryResponse;
                    };
                };
                fromPartial: {
                    submitQueryResponse(value: _151.MsgSubmitQueryResponse): {
                        typeUrl: string;
                        value: _151.MsgSubmitQueryResponse;
                    };
                };
            };
            AminoConverter: {
                "/stride.interchainquery.v1.MsgSubmitQueryResponse": {
                    aminoType: string;
                    toAmino: (message: _151.MsgSubmitQueryResponse) => _151.MsgSubmitQueryResponseAmino;
                    fromAmino: (object: _151.MsgSubmitQueryResponseAmino) => _151.MsgSubmitQueryResponse;
                };
            };
            MsgSubmitQueryResponse: {
                typeUrl: string;
                encode(message: _151.MsgSubmitQueryResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
                decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _151.MsgSubmitQueryResponse;
                fromPartial(object: Partial<_151.MsgSubmitQueryResponse>): _151.MsgSubmitQueryResponse;
                fromAmino(object: _151.MsgSubmitQueryResponseAmino): _151.MsgSubmitQueryResponse;
                toAmino(message: _151.MsgSubmitQueryResponse): _151.MsgSubmitQueryResponseAmino;
                fromAminoMsg(object: _151.MsgSubmitQueryResponseAminoMsg): _151.MsgSubmitQueryResponse;
                fromProtoMsg(message: _151.MsgSubmitQueryResponseProtoMsg): _151.MsgSubmitQueryResponse;
                toProto(message: _151.MsgSubmitQueryResponse): Uint8Array;
                toProtoMsg(message: _151.MsgSubmitQueryResponse): _151.MsgSubmitQueryResponseProtoMsg;
            };
            MsgSubmitQueryResponseResponse: {
                typeUrl: string;
                encode(_: _151.MsgSubmitQueryResponseResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
                decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _151.MsgSubmitQueryResponseResponse;
                fromPartial(_: Partial<_151.MsgSubmitQueryResponseResponse>): _151.MsgSubmitQueryResponseResponse;
                fromAmino(_: _151.MsgSubmitQueryResponseResponseAmino): _151.MsgSubmitQueryResponseResponse;
                toAmino(_: _151.MsgSubmitQueryResponseResponse): _151.MsgSubmitQueryResponseResponseAmino;
                fromAminoMsg(object: _151.MsgSubmitQueryResponseResponseAminoMsg): _151.MsgSubmitQueryResponseResponse;
                fromProtoMsg(message: _151.MsgSubmitQueryResponseResponseProtoMsg): _151.MsgSubmitQueryResponseResponse;
                toProto(message: _151.MsgSubmitQueryResponseResponse): Uint8Array;
                toProtoMsg(message: _151.MsgSubmitQueryResponseResponse): _151.MsgSubmitQueryResponseResponseProtoMsg;
            };
        };
    }
    const stakedym: {
        registry: readonly [string, import("..").TelescopeGeneratedType<any, any, any>][];
        load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
        MessageComposer: {
            encoded: {
                liquidStake(value: _164.MsgLiquidStake): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                redeemStake(value: _164.MsgRedeemStake): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                confirmDelegation(value: _164.MsgConfirmDelegation): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                confirmUndelegation(value: _164.MsgConfirmUndelegation): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                confirmUnbondedTokenSweep(value: _164.MsgConfirmUnbondedTokenSweep): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                adjustDelegatedBalance(value: _164.MsgAdjustDelegatedBalance): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateInnerRedemptionRateBounds(value: _164.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                resumeHostZone(value: _164.MsgResumeHostZone): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                refreshRedemptionRate(value: _164.MsgRefreshRedemptionRate): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                overwriteDelegationRecord(value: _164.MsgOverwriteDelegationRecord): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                overwriteUnbondingRecord(value: _164.MsgOverwriteUnbondingRecord): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                overwriteRedemptionRecord(value: _164.MsgOverwriteRedemptionRecord): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                setOperatorAddress(value: _164.MsgSetOperatorAddress): {
                    typeUrl: string;
                    value: Uint8Array;
                };
            };
            withTypeUrl: {
                liquidStake(value: _164.MsgLiquidStake): {
                    typeUrl: string;
                    value: _164.MsgLiquidStake;
                };
                redeemStake(value: _164.MsgRedeemStake): {
                    typeUrl: string;
                    value: _164.MsgRedeemStake;
                };
                confirmDelegation(value: _164.MsgConfirmDelegation): {
                    typeUrl: string;
                    value: _164.MsgConfirmDelegation;
                };
                confirmUndelegation(value: _164.MsgConfirmUndelegation): {
                    typeUrl: string;
                    value: _164.MsgConfirmUndelegation;
                };
                confirmUnbondedTokenSweep(value: _164.MsgConfirmUnbondedTokenSweep): {
                    typeUrl: string;
                    value: _164.MsgConfirmUnbondedTokenSweep;
                };
                adjustDelegatedBalance(value: _164.MsgAdjustDelegatedBalance): {
                    typeUrl: string;
                    value: _164.MsgAdjustDelegatedBalance;
                };
                updateInnerRedemptionRateBounds(value: _164.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: _164.MsgUpdateInnerRedemptionRateBounds;
                };
                resumeHostZone(value: _164.MsgResumeHostZone): {
                    typeUrl: string;
                    value: _164.MsgResumeHostZone;
                };
                refreshRedemptionRate(value: _164.MsgRefreshRedemptionRate): {
                    typeUrl: string;
                    value: _164.MsgRefreshRedemptionRate;
                };
                overwriteDelegationRecord(value: _164.MsgOverwriteDelegationRecord): {
                    typeUrl: string;
                    value: _164.MsgOverwriteDelegationRecord;
                };
                overwriteUnbondingRecord(value: _164.MsgOverwriteUnbondingRecord): {
                    typeUrl: string;
                    value: _164.MsgOverwriteUnbondingRecord;
                };
                overwriteRedemptionRecord(value: _164.MsgOverwriteRedemptionRecord): {
                    typeUrl: string;
                    value: _164.MsgOverwriteRedemptionRecord;
                };
                setOperatorAddress(value: _164.MsgSetOperatorAddress): {
                    typeUrl: string;
                    value: _164.MsgSetOperatorAddress;
                };
            };
            fromPartial: {
                liquidStake(value: _164.MsgLiquidStake): {
                    typeUrl: string;
                    value: _164.MsgLiquidStake;
                };
                redeemStake(value: _164.MsgRedeemStake): {
                    typeUrl: string;
                    value: _164.MsgRedeemStake;
                };
                confirmDelegation(value: _164.MsgConfirmDelegation): {
                    typeUrl: string;
                    value: _164.MsgConfirmDelegation;
                };
                confirmUndelegation(value: _164.MsgConfirmUndelegation): {
                    typeUrl: string;
                    value: _164.MsgConfirmUndelegation;
                };
                confirmUnbondedTokenSweep(value: _164.MsgConfirmUnbondedTokenSweep): {
                    typeUrl: string;
                    value: _164.MsgConfirmUnbondedTokenSweep;
                };
                adjustDelegatedBalance(value: _164.MsgAdjustDelegatedBalance): {
                    typeUrl: string;
                    value: _164.MsgAdjustDelegatedBalance;
                };
                updateInnerRedemptionRateBounds(value: _164.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: _164.MsgUpdateInnerRedemptionRateBounds;
                };
                resumeHostZone(value: _164.MsgResumeHostZone): {
                    typeUrl: string;
                    value: _164.MsgResumeHostZone;
                };
                refreshRedemptionRate(value: _164.MsgRefreshRedemptionRate): {
                    typeUrl: string;
                    value: _164.MsgRefreshRedemptionRate;
                };
                overwriteDelegationRecord(value: _164.MsgOverwriteDelegationRecord): {
                    typeUrl: string;
                    value: _164.MsgOverwriteDelegationRecord;
                };
                overwriteUnbondingRecord(value: _164.MsgOverwriteUnbondingRecord): {
                    typeUrl: string;
                    value: _164.MsgOverwriteUnbondingRecord;
                };
                overwriteRedemptionRecord(value: _164.MsgOverwriteRedemptionRecord): {
                    typeUrl: string;
                    value: _164.MsgOverwriteRedemptionRecord;
                };
                setOperatorAddress(value: _164.MsgSetOperatorAddress): {
                    typeUrl: string;
                    value: _164.MsgSetOperatorAddress;
                };
            };
        };
        AminoConverter: {
            "/stride.stakedym.MsgLiquidStake": {
                aminoType: string;
                toAmino: (message: _164.MsgLiquidStake) => _164.MsgLiquidStakeAmino;
                fromAmino: (object: _164.MsgLiquidStakeAmino) => _164.MsgLiquidStake;
            };
            "/stride.stakedym.MsgRedeemStake": {
                aminoType: string;
                toAmino: (message: _164.MsgRedeemStake) => _164.MsgRedeemStakeAmino;
                fromAmino: (object: _164.MsgRedeemStakeAmino) => _164.MsgRedeemStake;
            };
            "/stride.stakedym.MsgConfirmDelegation": {
                aminoType: string;
                toAmino: (message: _164.MsgConfirmDelegation) => _164.MsgConfirmDelegationAmino;
                fromAmino: (object: _164.MsgConfirmDelegationAmino) => _164.MsgConfirmDelegation;
            };
            "/stride.stakedym.MsgConfirmUndelegation": {
                aminoType: string;
                toAmino: (message: _164.MsgConfirmUndelegation) => _164.MsgConfirmUndelegationAmino;
                fromAmino: (object: _164.MsgConfirmUndelegationAmino) => _164.MsgConfirmUndelegation;
            };
            "/stride.stakedym.MsgConfirmUnbondedTokenSweep": {
                aminoType: string;
                toAmino: (message: _164.MsgConfirmUnbondedTokenSweep) => _164.MsgConfirmUnbondedTokenSweepAmino;
                fromAmino: (object: _164.MsgConfirmUnbondedTokenSweepAmino) => _164.MsgConfirmUnbondedTokenSweep;
            };
            "/stride.stakedym.MsgAdjustDelegatedBalance": {
                aminoType: string;
                toAmino: (message: _164.MsgAdjustDelegatedBalance) => _164.MsgAdjustDelegatedBalanceAmino;
                fromAmino: (object: _164.MsgAdjustDelegatedBalanceAmino) => _164.MsgAdjustDelegatedBalance;
            };
            "/stride.stakedym.MsgUpdateInnerRedemptionRateBounds": {
                aminoType: string;
                toAmino: (message: _164.MsgUpdateInnerRedemptionRateBounds) => _164.MsgUpdateInnerRedemptionRateBoundsAmino;
                fromAmino: (object: _164.MsgUpdateInnerRedemptionRateBoundsAmino) => _164.MsgUpdateInnerRedemptionRateBounds;
            };
            "/stride.stakedym.MsgResumeHostZone": {
                aminoType: string;
                toAmino: (message: _164.MsgResumeHostZone) => _164.MsgResumeHostZoneAmino;
                fromAmino: (object: _164.MsgResumeHostZoneAmino) => _164.MsgResumeHostZone;
            };
            "/stride.stakedym.MsgRefreshRedemptionRate": {
                aminoType: string;
                toAmino: (message: _164.MsgRefreshRedemptionRate) => _164.MsgRefreshRedemptionRateAmino;
                fromAmino: (object: _164.MsgRefreshRedemptionRateAmino) => _164.MsgRefreshRedemptionRate;
            };
            "/stride.stakedym.MsgOverwriteDelegationRecord": {
                aminoType: string;
                toAmino: (message: _164.MsgOverwriteDelegationRecord) => _164.MsgOverwriteDelegationRecordAmino;
                fromAmino: (object: _164.MsgOverwriteDelegationRecordAmino) => _164.MsgOverwriteDelegationRecord;
            };
            "/stride.stakedym.MsgOverwriteUnbondingRecord": {
                aminoType: string;
                toAmino: (message: _164.MsgOverwriteUnbondingRecord) => _164.MsgOverwriteUnbondingRecordAmino;
                fromAmino: (object: _164.MsgOverwriteUnbondingRecordAmino) => _164.MsgOverwriteUnbondingRecord;
            };
            "/stride.stakedym.MsgOverwriteRedemptionRecord": {
                aminoType: string;
                toAmino: (message: _164.MsgOverwriteRedemptionRecord) => _164.MsgOverwriteRedemptionRecordAmino;
                fromAmino: (object: _164.MsgOverwriteRedemptionRecordAmino) => _164.MsgOverwriteRedemptionRecord;
            };
            "/stride.stakedym.MsgSetOperatorAddress": {
                aminoType: string;
                toAmino: (message: _164.MsgSetOperatorAddress) => _164.MsgSetOperatorAddressAmino;
                fromAmino: (object: _164.MsgSetOperatorAddressAmino) => _164.MsgSetOperatorAddress;
            };
        };
        overwritableRecordTypeFromJSON(object: any): _164.OverwritableRecordType;
        overwritableRecordTypeToJSON(object: _164.OverwritableRecordType): string;
        OverwritableRecordType: typeof _164.OverwritableRecordType;
        OverwritableRecordTypeSDKType: typeof _164.OverwritableRecordType;
        OverwritableRecordTypeAmino: typeof _164.OverwritableRecordType;
        MsgLiquidStake: {
            typeUrl: string;
            encode(message: _164.MsgLiquidStake, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgLiquidStake;
            fromPartial(object: Partial<_164.MsgLiquidStake>): _164.MsgLiquidStake;
            fromAmino(object: _164.MsgLiquidStakeAmino): _164.MsgLiquidStake;
            toAmino(message: _164.MsgLiquidStake): _164.MsgLiquidStakeAmino;
            fromAminoMsg(object: _164.MsgLiquidStakeAminoMsg): _164.MsgLiquidStake;
            toAminoMsg(message: _164.MsgLiquidStake): _164.MsgLiquidStakeAminoMsg;
            fromProtoMsg(message: _164.MsgLiquidStakeProtoMsg): _164.MsgLiquidStake;
            toProto(message: _164.MsgLiquidStake): Uint8Array;
            toProtoMsg(message: _164.MsgLiquidStake): _164.MsgLiquidStakeProtoMsg;
        };
        MsgLiquidStakeResponse: {
            typeUrl: string;
            encode(message: _164.MsgLiquidStakeResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgLiquidStakeResponse;
            fromPartial(object: Partial<_164.MsgLiquidStakeResponse>): _164.MsgLiquidStakeResponse;
            fromAmino(object: _164.MsgLiquidStakeResponseAmino): _164.MsgLiquidStakeResponse;
            toAmino(message: _164.MsgLiquidStakeResponse): _164.MsgLiquidStakeResponseAmino;
            fromAminoMsg(object: _164.MsgLiquidStakeResponseAminoMsg): _164.MsgLiquidStakeResponse;
            fromProtoMsg(message: _164.MsgLiquidStakeResponseProtoMsg): _164.MsgLiquidStakeResponse;
            toProto(message: _164.MsgLiquidStakeResponse): Uint8Array;
            toProtoMsg(message: _164.MsgLiquidStakeResponse): _164.MsgLiquidStakeResponseProtoMsg;
        };
        MsgRedeemStake: {
            typeUrl: string;
            encode(message: _164.MsgRedeemStake, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgRedeemStake;
            fromPartial(object: Partial<_164.MsgRedeemStake>): _164.MsgRedeemStake;
            fromAmino(object: _164.MsgRedeemStakeAmino): _164.MsgRedeemStake;
            toAmino(message: _164.MsgRedeemStake): _164.MsgRedeemStakeAmino;
            fromAminoMsg(object: _164.MsgRedeemStakeAminoMsg): _164.MsgRedeemStake;
            toAminoMsg(message: _164.MsgRedeemStake): _164.MsgRedeemStakeAminoMsg;
            fromProtoMsg(message: _164.MsgRedeemStakeProtoMsg): _164.MsgRedeemStake;
            toProto(message: _164.MsgRedeemStake): Uint8Array;
            toProtoMsg(message: _164.MsgRedeemStake): _164.MsgRedeemStakeProtoMsg;
        };
        MsgRedeemStakeResponse: {
            typeUrl: string;
            encode(message: _164.MsgRedeemStakeResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgRedeemStakeResponse;
            fromPartial(object: Partial<_164.MsgRedeemStakeResponse>): _164.MsgRedeemStakeResponse;
            fromAmino(object: _164.MsgRedeemStakeResponseAmino): _164.MsgRedeemStakeResponse;
            toAmino(message: _164.MsgRedeemStakeResponse): _164.MsgRedeemStakeResponseAmino;
            fromAminoMsg(object: _164.MsgRedeemStakeResponseAminoMsg): _164.MsgRedeemStakeResponse;
            fromProtoMsg(message: _164.MsgRedeemStakeResponseProtoMsg): _164.MsgRedeemStakeResponse;
            toProto(message: _164.MsgRedeemStakeResponse): Uint8Array;
            toProtoMsg(message: _164.MsgRedeemStakeResponse): _164.MsgRedeemStakeResponseProtoMsg;
        };
        MsgConfirmDelegation: {
            typeUrl: string;
            encode(message: _164.MsgConfirmDelegation, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgConfirmDelegation;
            fromPartial(object: Partial<_164.MsgConfirmDelegation>): _164.MsgConfirmDelegation;
            fromAmino(object: _164.MsgConfirmDelegationAmino): _164.MsgConfirmDelegation;
            toAmino(message: _164.MsgConfirmDelegation): _164.MsgConfirmDelegationAmino;
            fromAminoMsg(object: _164.MsgConfirmDelegationAminoMsg): _164.MsgConfirmDelegation;
            toAminoMsg(message: _164.MsgConfirmDelegation): _164.MsgConfirmDelegationAminoMsg;
            fromProtoMsg(message: _164.MsgConfirmDelegationProtoMsg): _164.MsgConfirmDelegation;
            toProto(message: _164.MsgConfirmDelegation): Uint8Array;
            toProtoMsg(message: _164.MsgConfirmDelegation): _164.MsgConfirmDelegationProtoMsg;
        };
        MsgConfirmDelegationResponse: {
            typeUrl: string;
            encode(_: _164.MsgConfirmDelegationResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgConfirmDelegationResponse;
            fromPartial(_: Partial<_164.MsgConfirmDelegationResponse>): _164.MsgConfirmDelegationResponse;
            fromAmino(_: _164.MsgConfirmDelegationResponseAmino): _164.MsgConfirmDelegationResponse;
            toAmino(_: _164.MsgConfirmDelegationResponse): _164.MsgConfirmDelegationResponseAmino;
            fromAminoMsg(object: _164.MsgConfirmDelegationResponseAminoMsg): _164.MsgConfirmDelegationResponse;
            fromProtoMsg(message: _164.MsgConfirmDelegationResponseProtoMsg): _164.MsgConfirmDelegationResponse;
            toProto(message: _164.MsgConfirmDelegationResponse): Uint8Array;
            toProtoMsg(message: _164.MsgConfirmDelegationResponse): _164.MsgConfirmDelegationResponseProtoMsg;
        };
        MsgConfirmUndelegation: {
            typeUrl: string;
            encode(message: _164.MsgConfirmUndelegation, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgConfirmUndelegation;
            fromPartial(object: Partial<_164.MsgConfirmUndelegation>): _164.MsgConfirmUndelegation;
            fromAmino(object: _164.MsgConfirmUndelegationAmino): _164.MsgConfirmUndelegation;
            toAmino(message: _164.MsgConfirmUndelegation): _164.MsgConfirmUndelegationAmino;
            fromAminoMsg(object: _164.MsgConfirmUndelegationAminoMsg): _164.MsgConfirmUndelegation;
            toAminoMsg(message: _164.MsgConfirmUndelegation): _164.MsgConfirmUndelegationAminoMsg;
            fromProtoMsg(message: _164.MsgConfirmUndelegationProtoMsg): _164.MsgConfirmUndelegation;
            toProto(message: _164.MsgConfirmUndelegation): Uint8Array;
            toProtoMsg(message: _164.MsgConfirmUndelegation): _164.MsgConfirmUndelegationProtoMsg;
        };
        MsgConfirmUndelegationResponse: {
            typeUrl: string;
            encode(_: _164.MsgConfirmUndelegationResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgConfirmUndelegationResponse;
            fromPartial(_: Partial<_164.MsgConfirmUndelegationResponse>): _164.MsgConfirmUndelegationResponse;
            fromAmino(_: _164.MsgConfirmUndelegationResponseAmino): _164.MsgConfirmUndelegationResponse;
            toAmino(_: _164.MsgConfirmUndelegationResponse): _164.MsgConfirmUndelegationResponseAmino;
            fromAminoMsg(object: _164.MsgConfirmUndelegationResponseAminoMsg): _164.MsgConfirmUndelegationResponse;
            fromProtoMsg(message: _164.MsgConfirmUndelegationResponseProtoMsg): _164.MsgConfirmUndelegationResponse;
            toProto(message: _164.MsgConfirmUndelegationResponse): Uint8Array;
            toProtoMsg(message: _164.MsgConfirmUndelegationResponse): _164.MsgConfirmUndelegationResponseProtoMsg;
        };
        MsgConfirmUnbondedTokenSweep: {
            typeUrl: string;
            encode(message: _164.MsgConfirmUnbondedTokenSweep, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgConfirmUnbondedTokenSweep;
            fromPartial(object: Partial<_164.MsgConfirmUnbondedTokenSweep>): _164.MsgConfirmUnbondedTokenSweep;
            fromAmino(object: _164.MsgConfirmUnbondedTokenSweepAmino): _164.MsgConfirmUnbondedTokenSweep;
            toAmino(message: _164.MsgConfirmUnbondedTokenSweep): _164.MsgConfirmUnbondedTokenSweepAmino;
            fromAminoMsg(object: _164.MsgConfirmUnbondedTokenSweepAminoMsg): _164.MsgConfirmUnbondedTokenSweep;
            toAminoMsg(message: _164.MsgConfirmUnbondedTokenSweep): _164.MsgConfirmUnbondedTokenSweepAminoMsg;
            fromProtoMsg(message: _164.MsgConfirmUnbondedTokenSweepProtoMsg): _164.MsgConfirmUnbondedTokenSweep;
            toProto(message: _164.MsgConfirmUnbondedTokenSweep): Uint8Array;
            toProtoMsg(message: _164.MsgConfirmUnbondedTokenSweep): _164.MsgConfirmUnbondedTokenSweepProtoMsg;
        };
        MsgConfirmUnbondedTokenSweepResponse: {
            typeUrl: string;
            encode(_: _164.MsgConfirmUnbondedTokenSweepResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgConfirmUnbondedTokenSweepResponse;
            fromPartial(_: Partial<_164.MsgConfirmUnbondedTokenSweepResponse>): _164.MsgConfirmUnbondedTokenSweepResponse;
            fromAmino(_: _164.MsgConfirmUnbondedTokenSweepResponseAmino): _164.MsgConfirmUnbondedTokenSweepResponse;
            toAmino(_: _164.MsgConfirmUnbondedTokenSweepResponse): _164.MsgConfirmUnbondedTokenSweepResponseAmino;
            fromAminoMsg(object: _164.MsgConfirmUnbondedTokenSweepResponseAminoMsg): _164.MsgConfirmUnbondedTokenSweepResponse;
            fromProtoMsg(message: _164.MsgConfirmUnbondedTokenSweepResponseProtoMsg): _164.MsgConfirmUnbondedTokenSweepResponse;
            toProto(message: _164.MsgConfirmUnbondedTokenSweepResponse): Uint8Array;
            toProtoMsg(message: _164.MsgConfirmUnbondedTokenSweepResponse): _164.MsgConfirmUnbondedTokenSweepResponseProtoMsg;
        };
        MsgAdjustDelegatedBalance: {
            typeUrl: string;
            encode(message: _164.MsgAdjustDelegatedBalance, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgAdjustDelegatedBalance;
            fromPartial(object: Partial<_164.MsgAdjustDelegatedBalance>): _164.MsgAdjustDelegatedBalance;
            fromAmino(object: _164.MsgAdjustDelegatedBalanceAmino): _164.MsgAdjustDelegatedBalance;
            toAmino(message: _164.MsgAdjustDelegatedBalance): _164.MsgAdjustDelegatedBalanceAmino;
            fromAminoMsg(object: _164.MsgAdjustDelegatedBalanceAminoMsg): _164.MsgAdjustDelegatedBalance;
            toAminoMsg(message: _164.MsgAdjustDelegatedBalance): _164.MsgAdjustDelegatedBalanceAminoMsg;
            fromProtoMsg(message: _164.MsgAdjustDelegatedBalanceProtoMsg): _164.MsgAdjustDelegatedBalance;
            toProto(message: _164.MsgAdjustDelegatedBalance): Uint8Array;
            toProtoMsg(message: _164.MsgAdjustDelegatedBalance): _164.MsgAdjustDelegatedBalanceProtoMsg;
        };
        MsgAdjustDelegatedBalanceResponse: {
            typeUrl: string;
            encode(_: _164.MsgAdjustDelegatedBalanceResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgAdjustDelegatedBalanceResponse;
            fromPartial(_: Partial<_164.MsgAdjustDelegatedBalanceResponse>): _164.MsgAdjustDelegatedBalanceResponse;
            fromAmino(_: _164.MsgAdjustDelegatedBalanceResponseAmino): _164.MsgAdjustDelegatedBalanceResponse;
            toAmino(_: _164.MsgAdjustDelegatedBalanceResponse): _164.MsgAdjustDelegatedBalanceResponseAmino;
            fromAminoMsg(object: _164.MsgAdjustDelegatedBalanceResponseAminoMsg): _164.MsgAdjustDelegatedBalanceResponse;
            fromProtoMsg(message: _164.MsgAdjustDelegatedBalanceResponseProtoMsg): _164.MsgAdjustDelegatedBalanceResponse;
            toProto(message: _164.MsgAdjustDelegatedBalanceResponse): Uint8Array;
            toProtoMsg(message: _164.MsgAdjustDelegatedBalanceResponse): _164.MsgAdjustDelegatedBalanceResponseProtoMsg;
        };
        MsgUpdateInnerRedemptionRateBounds: {
            typeUrl: string;
            encode(message: _164.MsgUpdateInnerRedemptionRateBounds, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgUpdateInnerRedemptionRateBounds;
            fromPartial(object: Partial<_164.MsgUpdateInnerRedemptionRateBounds>): _164.MsgUpdateInnerRedemptionRateBounds;
            fromAmino(object: _164.MsgUpdateInnerRedemptionRateBoundsAmino): _164.MsgUpdateInnerRedemptionRateBounds;
            toAmino(message: _164.MsgUpdateInnerRedemptionRateBounds): _164.MsgUpdateInnerRedemptionRateBoundsAmino;
            fromAminoMsg(object: _164.MsgUpdateInnerRedemptionRateBoundsAminoMsg): _164.MsgUpdateInnerRedemptionRateBounds;
            toAminoMsg(message: _164.MsgUpdateInnerRedemptionRateBounds): _164.MsgUpdateInnerRedemptionRateBoundsAminoMsg;
            fromProtoMsg(message: _164.MsgUpdateInnerRedemptionRateBoundsProtoMsg): _164.MsgUpdateInnerRedemptionRateBounds;
            toProto(message: _164.MsgUpdateInnerRedemptionRateBounds): Uint8Array;
            toProtoMsg(message: _164.MsgUpdateInnerRedemptionRateBounds): _164.MsgUpdateInnerRedemptionRateBoundsProtoMsg;
        };
        MsgUpdateInnerRedemptionRateBoundsResponse: {
            typeUrl: string;
            encode(_: _164.MsgUpdateInnerRedemptionRateBoundsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromPartial(_: Partial<_164.MsgUpdateInnerRedemptionRateBoundsResponse>): _164.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromAmino(_: _164.MsgUpdateInnerRedemptionRateBoundsResponseAmino): _164.MsgUpdateInnerRedemptionRateBoundsResponse;
            toAmino(_: _164.MsgUpdateInnerRedemptionRateBoundsResponse): _164.MsgUpdateInnerRedemptionRateBoundsResponseAmino;
            fromAminoMsg(object: _164.MsgUpdateInnerRedemptionRateBoundsResponseAminoMsg): _164.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromProtoMsg(message: _164.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg): _164.MsgUpdateInnerRedemptionRateBoundsResponse;
            toProto(message: _164.MsgUpdateInnerRedemptionRateBoundsResponse): Uint8Array;
            toProtoMsg(message: _164.MsgUpdateInnerRedemptionRateBoundsResponse): _164.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg;
        };
        MsgResumeHostZone: {
            typeUrl: string;
            encode(message: _164.MsgResumeHostZone, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgResumeHostZone;
            fromPartial(object: Partial<_164.MsgResumeHostZone>): _164.MsgResumeHostZone;
            fromAmino(object: _164.MsgResumeHostZoneAmino): _164.MsgResumeHostZone;
            toAmino(message: _164.MsgResumeHostZone): _164.MsgResumeHostZoneAmino;
            fromAminoMsg(object: _164.MsgResumeHostZoneAminoMsg): _164.MsgResumeHostZone;
            toAminoMsg(message: _164.MsgResumeHostZone): _164.MsgResumeHostZoneAminoMsg;
            fromProtoMsg(message: _164.MsgResumeHostZoneProtoMsg): _164.MsgResumeHostZone;
            toProto(message: _164.MsgResumeHostZone): Uint8Array;
            toProtoMsg(message: _164.MsgResumeHostZone): _164.MsgResumeHostZoneProtoMsg;
        };
        MsgResumeHostZoneResponse: {
            typeUrl: string;
            encode(_: _164.MsgResumeHostZoneResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgResumeHostZoneResponse;
            fromPartial(_: Partial<_164.MsgResumeHostZoneResponse>): _164.MsgResumeHostZoneResponse;
            fromAmino(_: _164.MsgResumeHostZoneResponseAmino): _164.MsgResumeHostZoneResponse;
            toAmino(_: _164.MsgResumeHostZoneResponse): _164.MsgResumeHostZoneResponseAmino;
            fromAminoMsg(object: _164.MsgResumeHostZoneResponseAminoMsg): _164.MsgResumeHostZoneResponse;
            fromProtoMsg(message: _164.MsgResumeHostZoneResponseProtoMsg): _164.MsgResumeHostZoneResponse;
            toProto(message: _164.MsgResumeHostZoneResponse): Uint8Array;
            toProtoMsg(message: _164.MsgResumeHostZoneResponse): _164.MsgResumeHostZoneResponseProtoMsg;
        };
        MsgRefreshRedemptionRate: {
            typeUrl: string;
            encode(message: _164.MsgRefreshRedemptionRate, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgRefreshRedemptionRate;
            fromPartial(object: Partial<_164.MsgRefreshRedemptionRate>): _164.MsgRefreshRedemptionRate;
            fromAmino(object: _164.MsgRefreshRedemptionRateAmino): _164.MsgRefreshRedemptionRate;
            toAmino(message: _164.MsgRefreshRedemptionRate): _164.MsgRefreshRedemptionRateAmino;
            fromAminoMsg(object: _164.MsgRefreshRedemptionRateAminoMsg): _164.MsgRefreshRedemptionRate;
            toAminoMsg(message: _164.MsgRefreshRedemptionRate): _164.MsgRefreshRedemptionRateAminoMsg;
            fromProtoMsg(message: _164.MsgRefreshRedemptionRateProtoMsg): _164.MsgRefreshRedemptionRate;
            toProto(message: _164.MsgRefreshRedemptionRate): Uint8Array;
            toProtoMsg(message: _164.MsgRefreshRedemptionRate): _164.MsgRefreshRedemptionRateProtoMsg;
        };
        MsgRefreshRedemptionRateResponse: {
            typeUrl: string;
            encode(_: _164.MsgRefreshRedemptionRateResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgRefreshRedemptionRateResponse;
            fromPartial(_: Partial<_164.MsgRefreshRedemptionRateResponse>): _164.MsgRefreshRedemptionRateResponse;
            fromAmino(_: _164.MsgRefreshRedemptionRateResponseAmino): _164.MsgRefreshRedemptionRateResponse;
            toAmino(_: _164.MsgRefreshRedemptionRateResponse): _164.MsgRefreshRedemptionRateResponseAmino;
            fromAminoMsg(object: _164.MsgRefreshRedemptionRateResponseAminoMsg): _164.MsgRefreshRedemptionRateResponse;
            fromProtoMsg(message: _164.MsgRefreshRedemptionRateResponseProtoMsg): _164.MsgRefreshRedemptionRateResponse;
            toProto(message: _164.MsgRefreshRedemptionRateResponse): Uint8Array;
            toProtoMsg(message: _164.MsgRefreshRedemptionRateResponse): _164.MsgRefreshRedemptionRateResponseProtoMsg;
        };
        MsgOverwriteDelegationRecord: {
            typeUrl: string;
            encode(message: _164.MsgOverwriteDelegationRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgOverwriteDelegationRecord;
            fromPartial(object: Partial<_164.MsgOverwriteDelegationRecord>): _164.MsgOverwriteDelegationRecord;
            fromAmino(object: _164.MsgOverwriteDelegationRecordAmino): _164.MsgOverwriteDelegationRecord;
            toAmino(message: _164.MsgOverwriteDelegationRecord): _164.MsgOverwriteDelegationRecordAmino;
            fromAminoMsg(object: _164.MsgOverwriteDelegationRecordAminoMsg): _164.MsgOverwriteDelegationRecord;
            toAminoMsg(message: _164.MsgOverwriteDelegationRecord): _164.MsgOverwriteDelegationRecordAminoMsg;
            fromProtoMsg(message: _164.MsgOverwriteDelegationRecordProtoMsg): _164.MsgOverwriteDelegationRecord;
            toProto(message: _164.MsgOverwriteDelegationRecord): Uint8Array;
            toProtoMsg(message: _164.MsgOverwriteDelegationRecord): _164.MsgOverwriteDelegationRecordProtoMsg;
        };
        MsgOverwriteDelegationRecordResponse: {
            typeUrl: string;
            encode(_: _164.MsgOverwriteDelegationRecordResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgOverwriteDelegationRecordResponse;
            fromPartial(_: Partial<_164.MsgOverwriteDelegationRecordResponse>): _164.MsgOverwriteDelegationRecordResponse;
            fromAmino(_: _164.MsgOverwriteDelegationRecordResponseAmino): _164.MsgOverwriteDelegationRecordResponse;
            toAmino(_: _164.MsgOverwriteDelegationRecordResponse): _164.MsgOverwriteDelegationRecordResponseAmino;
            fromAminoMsg(object: _164.MsgOverwriteDelegationRecordResponseAminoMsg): _164.MsgOverwriteDelegationRecordResponse;
            fromProtoMsg(message: _164.MsgOverwriteDelegationRecordResponseProtoMsg): _164.MsgOverwriteDelegationRecordResponse;
            toProto(message: _164.MsgOverwriteDelegationRecordResponse): Uint8Array;
            toProtoMsg(message: _164.MsgOverwriteDelegationRecordResponse): _164.MsgOverwriteDelegationRecordResponseProtoMsg;
        };
        MsgOverwriteUnbondingRecord: {
            typeUrl: string;
            encode(message: _164.MsgOverwriteUnbondingRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgOverwriteUnbondingRecord;
            fromPartial(object: Partial<_164.MsgOverwriteUnbondingRecord>): _164.MsgOverwriteUnbondingRecord;
            fromAmino(object: _164.MsgOverwriteUnbondingRecordAmino): _164.MsgOverwriteUnbondingRecord;
            toAmino(message: _164.MsgOverwriteUnbondingRecord): _164.MsgOverwriteUnbondingRecordAmino;
            fromAminoMsg(object: _164.MsgOverwriteUnbondingRecordAminoMsg): _164.MsgOverwriteUnbondingRecord;
            toAminoMsg(message: _164.MsgOverwriteUnbondingRecord): _164.MsgOverwriteUnbondingRecordAminoMsg;
            fromProtoMsg(message: _164.MsgOverwriteUnbondingRecordProtoMsg): _164.MsgOverwriteUnbondingRecord;
            toProto(message: _164.MsgOverwriteUnbondingRecord): Uint8Array;
            toProtoMsg(message: _164.MsgOverwriteUnbondingRecord): _164.MsgOverwriteUnbondingRecordProtoMsg;
        };
        MsgOverwriteUnbondingRecordResponse: {
            typeUrl: string;
            encode(_: _164.MsgOverwriteUnbondingRecordResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgOverwriteUnbondingRecordResponse;
            fromPartial(_: Partial<_164.MsgOverwriteUnbondingRecordResponse>): _164.MsgOverwriteUnbondingRecordResponse;
            fromAmino(_: _164.MsgOverwriteUnbondingRecordResponseAmino): _164.MsgOverwriteUnbondingRecordResponse;
            toAmino(_: _164.MsgOverwriteUnbondingRecordResponse): _164.MsgOverwriteUnbondingRecordResponseAmino;
            fromAminoMsg(object: _164.MsgOverwriteUnbondingRecordResponseAminoMsg): _164.MsgOverwriteUnbondingRecordResponse;
            fromProtoMsg(message: _164.MsgOverwriteUnbondingRecordResponseProtoMsg): _164.MsgOverwriteUnbondingRecordResponse;
            toProto(message: _164.MsgOverwriteUnbondingRecordResponse): Uint8Array;
            toProtoMsg(message: _164.MsgOverwriteUnbondingRecordResponse): _164.MsgOverwriteUnbondingRecordResponseProtoMsg;
        };
        MsgOverwriteRedemptionRecord: {
            typeUrl: string;
            encode(message: _164.MsgOverwriteRedemptionRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgOverwriteRedemptionRecord;
            fromPartial(object: Partial<_164.MsgOverwriteRedemptionRecord>): _164.MsgOverwriteRedemptionRecord;
            fromAmino(object: _164.MsgOverwriteRedemptionRecordAmino): _164.MsgOverwriteRedemptionRecord;
            toAmino(message: _164.MsgOverwriteRedemptionRecord): _164.MsgOverwriteRedemptionRecordAmino;
            fromAminoMsg(object: _164.MsgOverwriteRedemptionRecordAminoMsg): _164.MsgOverwriteRedemptionRecord;
            toAminoMsg(message: _164.MsgOverwriteRedemptionRecord): _164.MsgOverwriteRedemptionRecordAminoMsg;
            fromProtoMsg(message: _164.MsgOverwriteRedemptionRecordProtoMsg): _164.MsgOverwriteRedemptionRecord;
            toProto(message: _164.MsgOverwriteRedemptionRecord): Uint8Array;
            toProtoMsg(message: _164.MsgOverwriteRedemptionRecord): _164.MsgOverwriteRedemptionRecordProtoMsg;
        };
        MsgOverwriteRedemptionRecordResponse: {
            typeUrl: string;
            encode(_: _164.MsgOverwriteRedemptionRecordResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgOverwriteRedemptionRecordResponse;
            fromPartial(_: Partial<_164.MsgOverwriteRedemptionRecordResponse>): _164.MsgOverwriteRedemptionRecordResponse;
            fromAmino(_: _164.MsgOverwriteRedemptionRecordResponseAmino): _164.MsgOverwriteRedemptionRecordResponse;
            toAmino(_: _164.MsgOverwriteRedemptionRecordResponse): _164.MsgOverwriteRedemptionRecordResponseAmino;
            fromAminoMsg(object: _164.MsgOverwriteRedemptionRecordResponseAminoMsg): _164.MsgOverwriteRedemptionRecordResponse;
            fromProtoMsg(message: _164.MsgOverwriteRedemptionRecordResponseProtoMsg): _164.MsgOverwriteRedemptionRecordResponse;
            toProto(message: _164.MsgOverwriteRedemptionRecordResponse): Uint8Array;
            toProtoMsg(message: _164.MsgOverwriteRedemptionRecordResponse): _164.MsgOverwriteRedemptionRecordResponseProtoMsg;
        };
        MsgSetOperatorAddress: {
            typeUrl: string;
            encode(message: _164.MsgSetOperatorAddress, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgSetOperatorAddress;
            fromPartial(object: Partial<_164.MsgSetOperatorAddress>): _164.MsgSetOperatorAddress;
            fromAmino(object: _164.MsgSetOperatorAddressAmino): _164.MsgSetOperatorAddress;
            toAmino(message: _164.MsgSetOperatorAddress): _164.MsgSetOperatorAddressAmino;
            fromAminoMsg(object: _164.MsgSetOperatorAddressAminoMsg): _164.MsgSetOperatorAddress;
            toAminoMsg(message: _164.MsgSetOperatorAddress): _164.MsgSetOperatorAddressAminoMsg;
            fromProtoMsg(message: _164.MsgSetOperatorAddressProtoMsg): _164.MsgSetOperatorAddress;
            toProto(message: _164.MsgSetOperatorAddress): Uint8Array;
            toProtoMsg(message: _164.MsgSetOperatorAddress): _164.MsgSetOperatorAddressProtoMsg;
        };
        MsgSetOperatorAddressResponse: {
            typeUrl: string;
            encode(_: _164.MsgSetOperatorAddressResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _164.MsgSetOperatorAddressResponse;
            fromPartial(_: Partial<_164.MsgSetOperatorAddressResponse>): _164.MsgSetOperatorAddressResponse;
            fromAmino(_: _164.MsgSetOperatorAddressResponseAmino): _164.MsgSetOperatorAddressResponse;
            toAmino(_: _164.MsgSetOperatorAddressResponse): _164.MsgSetOperatorAddressResponseAmino;
            fromAminoMsg(object: _164.MsgSetOperatorAddressResponseAminoMsg): _164.MsgSetOperatorAddressResponse;
            fromProtoMsg(message: _164.MsgSetOperatorAddressResponseProtoMsg): _164.MsgSetOperatorAddressResponse;
            toProto(message: _164.MsgSetOperatorAddressResponse): Uint8Array;
            toProtoMsg(message: _164.MsgSetOperatorAddressResponse): _164.MsgSetOperatorAddressResponseProtoMsg;
        };
        delegationRecordStatusFromJSON(object: any): _163.DelegationRecordStatus;
        delegationRecordStatusToJSON(object: _163.DelegationRecordStatus): string;
        unbondingRecordStatusFromJSON(object: any): _163.UnbondingRecordStatus;
        unbondingRecordStatusToJSON(object: _163.UnbondingRecordStatus): string;
        DelegationRecordStatus: typeof _163.DelegationRecordStatus;
        DelegationRecordStatusSDKType: typeof _163.DelegationRecordStatus;
        DelegationRecordStatusAmino: typeof _163.DelegationRecordStatus;
        UnbondingRecordStatus: typeof _163.UnbondingRecordStatus;
        UnbondingRecordStatusSDKType: typeof _163.UnbondingRecordStatus;
        UnbondingRecordStatusAmino: typeof _163.UnbondingRecordStatus;
        HostZone: {
            typeUrl: string;
            encode(message: _163.HostZone, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _163.HostZone;
            fromPartial(object: Partial<_163.HostZone>): _163.HostZone;
            fromAmino(object: _163.HostZoneAmino): _163.HostZone;
            toAmino(message: _163.HostZone): _163.HostZoneAmino;
            fromAminoMsg(object: _163.HostZoneAminoMsg): _163.HostZone;
            fromProtoMsg(message: _163.HostZoneProtoMsg): _163.HostZone;
            toProto(message: _163.HostZone): Uint8Array;
            toProtoMsg(message: _163.HostZone): _163.HostZoneProtoMsg;
        };
        DelegationRecord: {
            typeUrl: string;
            encode(message: _163.DelegationRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _163.DelegationRecord;
            fromPartial(object: Partial<_163.DelegationRecord>): _163.DelegationRecord;
            fromAmino(object: _163.DelegationRecordAmino): _163.DelegationRecord;
            toAmino(message: _163.DelegationRecord): _163.DelegationRecordAmino;
            fromAminoMsg(object: _163.DelegationRecordAminoMsg): _163.DelegationRecord;
            fromProtoMsg(message: _163.DelegationRecordProtoMsg): _163.DelegationRecord;
            toProto(message: _163.DelegationRecord): Uint8Array;
            toProtoMsg(message: _163.DelegationRecord): _163.DelegationRecordProtoMsg;
        };
        UnbondingRecord: {
            typeUrl: string;
            encode(message: _163.UnbondingRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _163.UnbondingRecord;
            fromPartial(object: Partial<_163.UnbondingRecord>): _163.UnbondingRecord;
            fromAmino(object: _163.UnbondingRecordAmino): _163.UnbondingRecord;
            toAmino(message: _163.UnbondingRecord): _163.UnbondingRecordAmino;
            fromAminoMsg(object: _163.UnbondingRecordAminoMsg): _163.UnbondingRecord;
            fromProtoMsg(message: _163.UnbondingRecordProtoMsg): _163.UnbondingRecord;
            toProto(message: _163.UnbondingRecord): Uint8Array;
            toProtoMsg(message: _163.UnbondingRecord): _163.UnbondingRecordProtoMsg;
        };
        RedemptionRecord: {
            typeUrl: string;
            encode(message: _163.RedemptionRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _163.RedemptionRecord;
            fromPartial(object: Partial<_163.RedemptionRecord>): _163.RedemptionRecord;
            fromAmino(object: _163.RedemptionRecordAmino): _163.RedemptionRecord;
            toAmino(message: _163.RedemptionRecord): _163.RedemptionRecordAmino;
            fromAminoMsg(object: _163.RedemptionRecordAminoMsg): _163.RedemptionRecord;
            fromProtoMsg(message: _163.RedemptionRecordProtoMsg): _163.RedemptionRecord;
            toProto(message: _163.RedemptionRecord): Uint8Array;
            toProtoMsg(message: _163.RedemptionRecord): _163.RedemptionRecordProtoMsg;
        };
        SlashRecord: {
            typeUrl: string;
            encode(message: _163.SlashRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _163.SlashRecord;
            fromPartial(object: Partial<_163.SlashRecord>): _163.SlashRecord;
            fromAmino(object: _163.SlashRecordAmino): _163.SlashRecord;
            toAmino(message: _163.SlashRecord): _163.SlashRecordAmino;
            fromAminoMsg(object: _163.SlashRecordAminoMsg): _163.SlashRecord;
            fromProtoMsg(message: _163.SlashRecordProtoMsg): _163.SlashRecord;
            toProto(message: _163.SlashRecord): Uint8Array;
            toProtoMsg(message: _163.SlashRecord): _163.SlashRecordProtoMsg;
        };
    };
    const stakeibc: {
        registry: readonly [string, import("..").TelescopeGeneratedType<any, any, any>][];
        load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
        MessageComposer: {
            encoded: {
                liquidStake(value: _176.MsgLiquidStake): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                lSMLiquidStake(value: _176.MsgLSMLiquidStake): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                redeemStake(value: _176.MsgRedeemStake): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                registerHostZone(value: _176.MsgRegisterHostZone): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                claimUndelegatedTokens(value: _176.MsgClaimUndelegatedTokens): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                rebalanceValidators(value: _176.MsgRebalanceValidators): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                addValidators(value: _176.MsgAddValidators): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                changeValidatorWeight(value: _176.MsgChangeValidatorWeights): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                deleteValidator(value: _176.MsgDeleteValidator): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                restoreInterchainAccount(value: _176.MsgRestoreInterchainAccount): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateValidatorSharesExchRate(value: _176.MsgUpdateValidatorSharesExchRate): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                calibrateDelegation(value: _176.MsgCalibrateDelegation): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                clearBalance(value: _176.MsgClearBalance): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateInnerRedemptionRateBounds(value: _176.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                resumeHostZone(value: _176.MsgResumeHostZone): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                createTradeRoute(value: _176.MsgCreateTradeRoute): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                deleteTradeRoute(value: _176.MsgDeleteTradeRoute): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateTradeRoute(value: _176.MsgUpdateTradeRoute): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                setCommunityPoolRebate(value: _176.MsgSetCommunityPoolRebate): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                toggleTradeController(value: _176.MsgToggleTradeController): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateHostZoneParams(value: _176.MsgUpdateHostZoneParams): {
                    typeUrl: string;
                    value: Uint8Array;
                };
            };
            withTypeUrl: {
                liquidStake(value: _176.MsgLiquidStake): {
                    typeUrl: string;
                    value: _176.MsgLiquidStake;
                };
                lSMLiquidStake(value: _176.MsgLSMLiquidStake): {
                    typeUrl: string;
                    value: _176.MsgLSMLiquidStake;
                };
                redeemStake(value: _176.MsgRedeemStake): {
                    typeUrl: string;
                    value: _176.MsgRedeemStake;
                };
                registerHostZone(value: _176.MsgRegisterHostZone): {
                    typeUrl: string;
                    value: _176.MsgRegisterHostZone;
                };
                claimUndelegatedTokens(value: _176.MsgClaimUndelegatedTokens): {
                    typeUrl: string;
                    value: _176.MsgClaimUndelegatedTokens;
                };
                rebalanceValidators(value: _176.MsgRebalanceValidators): {
                    typeUrl: string;
                    value: _176.MsgRebalanceValidators;
                };
                addValidators(value: _176.MsgAddValidators): {
                    typeUrl: string;
                    value: _176.MsgAddValidators;
                };
                changeValidatorWeight(value: _176.MsgChangeValidatorWeights): {
                    typeUrl: string;
                    value: _176.MsgChangeValidatorWeights;
                };
                deleteValidator(value: _176.MsgDeleteValidator): {
                    typeUrl: string;
                    value: _176.MsgDeleteValidator;
                };
                restoreInterchainAccount(value: _176.MsgRestoreInterchainAccount): {
                    typeUrl: string;
                    value: _176.MsgRestoreInterchainAccount;
                };
                updateValidatorSharesExchRate(value: _176.MsgUpdateValidatorSharesExchRate): {
                    typeUrl: string;
                    value: _176.MsgUpdateValidatorSharesExchRate;
                };
                calibrateDelegation(value: _176.MsgCalibrateDelegation): {
                    typeUrl: string;
                    value: _176.MsgCalibrateDelegation;
                };
                clearBalance(value: _176.MsgClearBalance): {
                    typeUrl: string;
                    value: _176.MsgClearBalance;
                };
                updateInnerRedemptionRateBounds(value: _176.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: _176.MsgUpdateInnerRedemptionRateBounds;
                };
                resumeHostZone(value: _176.MsgResumeHostZone): {
                    typeUrl: string;
                    value: _176.MsgResumeHostZone;
                };
                createTradeRoute(value: _176.MsgCreateTradeRoute): {
                    typeUrl: string;
                    value: _176.MsgCreateTradeRoute;
                };
                deleteTradeRoute(value: _176.MsgDeleteTradeRoute): {
                    typeUrl: string;
                    value: _176.MsgDeleteTradeRoute;
                };
                updateTradeRoute(value: _176.MsgUpdateTradeRoute): {
                    typeUrl: string;
                    value: _176.MsgUpdateTradeRoute;
                };
                setCommunityPoolRebate(value: _176.MsgSetCommunityPoolRebate): {
                    typeUrl: string;
                    value: _176.MsgSetCommunityPoolRebate;
                };
                toggleTradeController(value: _176.MsgToggleTradeController): {
                    typeUrl: string;
                    value: _176.MsgToggleTradeController;
                };
                updateHostZoneParams(value: _176.MsgUpdateHostZoneParams): {
                    typeUrl: string;
                    value: _176.MsgUpdateHostZoneParams;
                };
            };
            fromPartial: {
                liquidStake(value: _176.MsgLiquidStake): {
                    typeUrl: string;
                    value: _176.MsgLiquidStake;
                };
                lSMLiquidStake(value: _176.MsgLSMLiquidStake): {
                    typeUrl: string;
                    value: _176.MsgLSMLiquidStake;
                };
                redeemStake(value: _176.MsgRedeemStake): {
                    typeUrl: string;
                    value: _176.MsgRedeemStake;
                };
                registerHostZone(value: _176.MsgRegisterHostZone): {
                    typeUrl: string;
                    value: _176.MsgRegisterHostZone;
                };
                claimUndelegatedTokens(value: _176.MsgClaimUndelegatedTokens): {
                    typeUrl: string;
                    value: _176.MsgClaimUndelegatedTokens;
                };
                rebalanceValidators(value: _176.MsgRebalanceValidators): {
                    typeUrl: string;
                    value: _176.MsgRebalanceValidators;
                };
                addValidators(value: _176.MsgAddValidators): {
                    typeUrl: string;
                    value: _176.MsgAddValidators;
                };
                changeValidatorWeight(value: _176.MsgChangeValidatorWeights): {
                    typeUrl: string;
                    value: _176.MsgChangeValidatorWeights;
                };
                deleteValidator(value: _176.MsgDeleteValidator): {
                    typeUrl: string;
                    value: _176.MsgDeleteValidator;
                };
                restoreInterchainAccount(value: _176.MsgRestoreInterchainAccount): {
                    typeUrl: string;
                    value: _176.MsgRestoreInterchainAccount;
                };
                updateValidatorSharesExchRate(value: _176.MsgUpdateValidatorSharesExchRate): {
                    typeUrl: string;
                    value: _176.MsgUpdateValidatorSharesExchRate;
                };
                calibrateDelegation(value: _176.MsgCalibrateDelegation): {
                    typeUrl: string;
                    value: _176.MsgCalibrateDelegation;
                };
                clearBalance(value: _176.MsgClearBalance): {
                    typeUrl: string;
                    value: _176.MsgClearBalance;
                };
                updateInnerRedemptionRateBounds(value: _176.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: _176.MsgUpdateInnerRedemptionRateBounds;
                };
                resumeHostZone(value: _176.MsgResumeHostZone): {
                    typeUrl: string;
                    value: _176.MsgResumeHostZone;
                };
                createTradeRoute(value: _176.MsgCreateTradeRoute): {
                    typeUrl: string;
                    value: _176.MsgCreateTradeRoute;
                };
                deleteTradeRoute(value: _176.MsgDeleteTradeRoute): {
                    typeUrl: string;
                    value: _176.MsgDeleteTradeRoute;
                };
                updateTradeRoute(value: _176.MsgUpdateTradeRoute): {
                    typeUrl: string;
                    value: _176.MsgUpdateTradeRoute;
                };
                setCommunityPoolRebate(value: _176.MsgSetCommunityPoolRebate): {
                    typeUrl: string;
                    value: _176.MsgSetCommunityPoolRebate;
                };
                toggleTradeController(value: _176.MsgToggleTradeController): {
                    typeUrl: string;
                    value: _176.MsgToggleTradeController;
                };
                updateHostZoneParams(value: _176.MsgUpdateHostZoneParams): {
                    typeUrl: string;
                    value: _176.MsgUpdateHostZoneParams;
                };
            };
        };
        AminoConverter: {
            "/stride.stakeibc.MsgLiquidStake": {
                aminoType: string;
                toAmino: (message: _176.MsgLiquidStake) => _176.MsgLiquidStakeAmino;
                fromAmino: (object: _176.MsgLiquidStakeAmino) => _176.MsgLiquidStake;
            };
            "/stride.stakeibc.MsgLSMLiquidStake": {
                aminoType: string;
                toAmino: (message: _176.MsgLSMLiquidStake) => _176.MsgLSMLiquidStakeAmino;
                fromAmino: (object: _176.MsgLSMLiquidStakeAmino) => _176.MsgLSMLiquidStake;
            };
            "/stride.stakeibc.MsgRedeemStake": {
                aminoType: string;
                toAmino: (message: _176.MsgRedeemStake) => _176.MsgRedeemStakeAmino;
                fromAmino: (object: _176.MsgRedeemStakeAmino) => _176.MsgRedeemStake;
            };
            "/stride.stakeibc.MsgRegisterHostZone": {
                aminoType: string;
                toAmino: (message: _176.MsgRegisterHostZone) => _176.MsgRegisterHostZoneAmino;
                fromAmino: (object: _176.MsgRegisterHostZoneAmino) => _176.MsgRegisterHostZone;
            };
            "/stride.stakeibc.MsgClaimUndelegatedTokens": {
                aminoType: string;
                toAmino: (message: _176.MsgClaimUndelegatedTokens) => _176.MsgClaimUndelegatedTokensAmino;
                fromAmino: (object: _176.MsgClaimUndelegatedTokensAmino) => _176.MsgClaimUndelegatedTokens;
            };
            "/stride.stakeibc.MsgRebalanceValidators": {
                aminoType: string;
                toAmino: (message: _176.MsgRebalanceValidators) => _176.MsgRebalanceValidatorsAmino;
                fromAmino: (object: _176.MsgRebalanceValidatorsAmino) => _176.MsgRebalanceValidators;
            };
            "/stride.stakeibc.MsgAddValidators": {
                aminoType: string;
                toAmino: (message: _176.MsgAddValidators) => _176.MsgAddValidatorsAmino;
                fromAmino: (object: _176.MsgAddValidatorsAmino) => _176.MsgAddValidators;
            };
            "/stride.stakeibc.MsgChangeValidatorWeights": {
                aminoType: string;
                toAmino: (message: _176.MsgChangeValidatorWeights) => _176.MsgChangeValidatorWeightsAmino;
                fromAmino: (object: _176.MsgChangeValidatorWeightsAmino) => _176.MsgChangeValidatorWeights;
            };
            "/stride.stakeibc.MsgDeleteValidator": {
                aminoType: string;
                toAmino: (message: _176.MsgDeleteValidator) => _176.MsgDeleteValidatorAmino;
                fromAmino: (object: _176.MsgDeleteValidatorAmino) => _176.MsgDeleteValidator;
            };
            "/stride.stakeibc.MsgRestoreInterchainAccount": {
                aminoType: string;
                toAmino: (message: _176.MsgRestoreInterchainAccount) => _176.MsgRestoreInterchainAccountAmino;
                fromAmino: (object: _176.MsgRestoreInterchainAccountAmino) => _176.MsgRestoreInterchainAccount;
            };
            "/stride.stakeibc.MsgUpdateValidatorSharesExchRate": {
                aminoType: string;
                toAmino: (message: _176.MsgUpdateValidatorSharesExchRate) => _176.MsgUpdateValidatorSharesExchRateAmino;
                fromAmino: (object: _176.MsgUpdateValidatorSharesExchRateAmino) => _176.MsgUpdateValidatorSharesExchRate;
            };
            "/stride.stakeibc.MsgCalibrateDelegation": {
                aminoType: string;
                toAmino: (message: _176.MsgCalibrateDelegation) => _176.MsgCalibrateDelegationAmino;
                fromAmino: (object: _176.MsgCalibrateDelegationAmino) => _176.MsgCalibrateDelegation;
            };
            "/stride.stakeibc.MsgClearBalance": {
                aminoType: string;
                toAmino: (message: _176.MsgClearBalance) => _176.MsgClearBalanceAmino;
                fromAmino: (object: _176.MsgClearBalanceAmino) => _176.MsgClearBalance;
            };
            "/stride.stakeibc.MsgUpdateInnerRedemptionRateBounds": {
                aminoType: string;
                toAmino: (message: _176.MsgUpdateInnerRedemptionRateBounds) => _176.MsgUpdateInnerRedemptionRateBoundsAmino;
                fromAmino: (object: _176.MsgUpdateInnerRedemptionRateBoundsAmino) => _176.MsgUpdateInnerRedemptionRateBounds;
            };
            "/stride.stakeibc.MsgResumeHostZone": {
                aminoType: string;
                toAmino: (message: _176.MsgResumeHostZone) => _176.MsgResumeHostZoneAmino;
                fromAmino: (object: _176.MsgResumeHostZoneAmino) => _176.MsgResumeHostZone;
            };
            "/stride.stakeibc.MsgCreateTradeRoute": {
                aminoType: string;
                toAmino: (message: _176.MsgCreateTradeRoute) => _176.MsgCreateTradeRouteAmino;
                fromAmino: (object: _176.MsgCreateTradeRouteAmino) => _176.MsgCreateTradeRoute;
            };
            "/stride.stakeibc.MsgDeleteTradeRoute": {
                aminoType: string;
                toAmino: (message: _176.MsgDeleteTradeRoute) => _176.MsgDeleteTradeRouteAmino;
                fromAmino: (object: _176.MsgDeleteTradeRouteAmino) => _176.MsgDeleteTradeRoute;
            };
            "/stride.stakeibc.MsgUpdateTradeRoute": {
                aminoType: string;
                toAmino: (message: _176.MsgUpdateTradeRoute) => _176.MsgUpdateTradeRouteAmino;
                fromAmino: (object: _176.MsgUpdateTradeRouteAmino) => _176.MsgUpdateTradeRoute;
            };
            "/stride.stakeibc.MsgSetCommunityPoolRebate": {
                aminoType: string;
                toAmino: (message: _176.MsgSetCommunityPoolRebate) => _176.MsgSetCommunityPoolRebateAmino;
                fromAmino: (object: _176.MsgSetCommunityPoolRebateAmino) => _176.MsgSetCommunityPoolRebate;
            };
            "/stride.stakeibc.MsgToggleTradeController": {
                aminoType: string;
                toAmino: (message: _176.MsgToggleTradeController) => _176.MsgToggleTradeControllerAmino;
                fromAmino: (object: _176.MsgToggleTradeControllerAmino) => _176.MsgToggleTradeController;
            };
            "/stride.stakeibc.MsgUpdateHostZoneParams": {
                aminoType: string;
                toAmino: (message: _176.MsgUpdateHostZoneParams) => _176.MsgUpdateHostZoneParamsAmino;
                fromAmino: (object: _176.MsgUpdateHostZoneParamsAmino) => _176.MsgUpdateHostZoneParams;
            };
        };
        Validator: {
            typeUrl: string;
            encode(message: _177.Validator, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _177.Validator;
            fromPartial(object: Partial<_177.Validator>): _177.Validator;
            fromAmino(object: _177.ValidatorAmino): _177.Validator;
            toAmino(message: _177.Validator): _177.ValidatorAmino;
            fromAminoMsg(object: _177.ValidatorAminoMsg): _177.Validator;
            fromProtoMsg(message: _177.ValidatorProtoMsg): _177.Validator;
            toProto(message: _177.Validator): Uint8Array;
            toProtoMsg(message: _177.Validator): _177.ValidatorProtoMsg;
        };
        authzPermissionChangeFromJSON(object: any): _176.AuthzPermissionChange;
        authzPermissionChangeToJSON(object: _176.AuthzPermissionChange): string;
        AuthzPermissionChange: typeof _176.AuthzPermissionChange;
        AuthzPermissionChangeSDKType: typeof _176.AuthzPermissionChange;
        AuthzPermissionChangeAmino: typeof _176.AuthzPermissionChange;
        MsgUpdateInnerRedemptionRateBounds: {
            typeUrl: string;
            encode(message: _176.MsgUpdateInnerRedemptionRateBounds, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateInnerRedemptionRateBounds;
            fromPartial(object: Partial<_176.MsgUpdateInnerRedemptionRateBounds>): _176.MsgUpdateInnerRedemptionRateBounds;
            fromAmino(object: _176.MsgUpdateInnerRedemptionRateBoundsAmino): _176.MsgUpdateInnerRedemptionRateBounds;
            toAmino(message: _176.MsgUpdateInnerRedemptionRateBounds): _176.MsgUpdateInnerRedemptionRateBoundsAmino;
            fromAminoMsg(object: _176.MsgUpdateInnerRedemptionRateBoundsAminoMsg): _176.MsgUpdateInnerRedemptionRateBounds;
            fromProtoMsg(message: _176.MsgUpdateInnerRedemptionRateBoundsProtoMsg): _176.MsgUpdateInnerRedemptionRateBounds;
            toProto(message: _176.MsgUpdateInnerRedemptionRateBounds): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateInnerRedemptionRateBounds): _176.MsgUpdateInnerRedemptionRateBoundsProtoMsg;
        };
        MsgUpdateInnerRedemptionRateBoundsResponse: {
            typeUrl: string;
            encode(_: _176.MsgUpdateInnerRedemptionRateBoundsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromPartial(_: Partial<_176.MsgUpdateInnerRedemptionRateBoundsResponse>): _176.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromAmino(_: _176.MsgUpdateInnerRedemptionRateBoundsResponseAmino): _176.MsgUpdateInnerRedemptionRateBoundsResponse;
            toAmino(_: _176.MsgUpdateInnerRedemptionRateBoundsResponse): _176.MsgUpdateInnerRedemptionRateBoundsResponseAmino;
            fromAminoMsg(object: _176.MsgUpdateInnerRedemptionRateBoundsResponseAminoMsg): _176.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromProtoMsg(message: _176.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg): _176.MsgUpdateInnerRedemptionRateBoundsResponse;
            toProto(message: _176.MsgUpdateInnerRedemptionRateBoundsResponse): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateInnerRedemptionRateBoundsResponse): _176.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg;
        };
        MsgLiquidStake: {
            typeUrl: string;
            encode(message: _176.MsgLiquidStake, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgLiquidStake;
            fromPartial(object: Partial<_176.MsgLiquidStake>): _176.MsgLiquidStake;
            fromAmino(object: _176.MsgLiquidStakeAmino): _176.MsgLiquidStake;
            toAmino(message: _176.MsgLiquidStake): _176.MsgLiquidStakeAmino;
            fromAminoMsg(object: _176.MsgLiquidStakeAminoMsg): _176.MsgLiquidStake;
            toAminoMsg(message: _176.MsgLiquidStake): _176.MsgLiquidStakeAminoMsg;
            fromProtoMsg(message: _176.MsgLiquidStakeProtoMsg): _176.MsgLiquidStake;
            toProto(message: _176.MsgLiquidStake): Uint8Array;
            toProtoMsg(message: _176.MsgLiquidStake): _176.MsgLiquidStakeProtoMsg;
        };
        MsgLiquidStakeResponse: {
            typeUrl: string;
            encode(message: _176.MsgLiquidStakeResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgLiquidStakeResponse;
            fromPartial(object: Partial<_176.MsgLiquidStakeResponse>): _176.MsgLiquidStakeResponse;
            fromAmino(object: _176.MsgLiquidStakeResponseAmino): _176.MsgLiquidStakeResponse;
            toAmino(message: _176.MsgLiquidStakeResponse): _176.MsgLiquidStakeResponseAmino;
            fromAminoMsg(object: _176.MsgLiquidStakeResponseAminoMsg): _176.MsgLiquidStakeResponse;
            fromProtoMsg(message: _176.MsgLiquidStakeResponseProtoMsg): _176.MsgLiquidStakeResponse;
            toProto(message: _176.MsgLiquidStakeResponse): Uint8Array;
            toProtoMsg(message: _176.MsgLiquidStakeResponse): _176.MsgLiquidStakeResponseProtoMsg;
        };
        MsgLSMLiquidStake: {
            typeUrl: string;
            encode(message: _176.MsgLSMLiquidStake, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgLSMLiquidStake;
            fromPartial(object: Partial<_176.MsgLSMLiquidStake>): _176.MsgLSMLiquidStake;
            fromAmino(object: _176.MsgLSMLiquidStakeAmino): _176.MsgLSMLiquidStake;
            toAmino(message: _176.MsgLSMLiquidStake): _176.MsgLSMLiquidStakeAmino;
            fromAminoMsg(object: _176.MsgLSMLiquidStakeAminoMsg): _176.MsgLSMLiquidStake;
            toAminoMsg(message: _176.MsgLSMLiquidStake): _176.MsgLSMLiquidStakeAminoMsg;
            fromProtoMsg(message: _176.MsgLSMLiquidStakeProtoMsg): _176.MsgLSMLiquidStake;
            toProto(message: _176.MsgLSMLiquidStake): Uint8Array;
            toProtoMsg(message: _176.MsgLSMLiquidStake): _176.MsgLSMLiquidStakeProtoMsg;
        };
        MsgLSMLiquidStakeResponse: {
            typeUrl: string;
            encode(message: _176.MsgLSMLiquidStakeResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgLSMLiquidStakeResponse;
            fromPartial(object: Partial<_176.MsgLSMLiquidStakeResponse>): _176.MsgLSMLiquidStakeResponse;
            fromAmino(object: _176.MsgLSMLiquidStakeResponseAmino): _176.MsgLSMLiquidStakeResponse;
            toAmino(message: _176.MsgLSMLiquidStakeResponse): _176.MsgLSMLiquidStakeResponseAmino;
            fromAminoMsg(object: _176.MsgLSMLiquidStakeResponseAminoMsg): _176.MsgLSMLiquidStakeResponse;
            fromProtoMsg(message: _176.MsgLSMLiquidStakeResponseProtoMsg): _176.MsgLSMLiquidStakeResponse;
            toProto(message: _176.MsgLSMLiquidStakeResponse): Uint8Array;
            toProtoMsg(message: _176.MsgLSMLiquidStakeResponse): _176.MsgLSMLiquidStakeResponseProtoMsg;
        };
        MsgClearBalance: {
            typeUrl: string;
            encode(message: _176.MsgClearBalance, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgClearBalance;
            fromPartial(object: Partial<_176.MsgClearBalance>): _176.MsgClearBalance;
            fromAmino(object: _176.MsgClearBalanceAmino): _176.MsgClearBalance;
            toAmino(message: _176.MsgClearBalance): _176.MsgClearBalanceAmino;
            fromAminoMsg(object: _176.MsgClearBalanceAminoMsg): _176.MsgClearBalance;
            toAminoMsg(message: _176.MsgClearBalance): _176.MsgClearBalanceAminoMsg;
            fromProtoMsg(message: _176.MsgClearBalanceProtoMsg): _176.MsgClearBalance;
            toProto(message: _176.MsgClearBalance): Uint8Array;
            toProtoMsg(message: _176.MsgClearBalance): _176.MsgClearBalanceProtoMsg;
        };
        MsgClearBalanceResponse: {
            typeUrl: string;
            encode(_: _176.MsgClearBalanceResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgClearBalanceResponse;
            fromPartial(_: Partial<_176.MsgClearBalanceResponse>): _176.MsgClearBalanceResponse;
            fromAmino(_: _176.MsgClearBalanceResponseAmino): _176.MsgClearBalanceResponse;
            toAmino(_: _176.MsgClearBalanceResponse): _176.MsgClearBalanceResponseAmino;
            fromAminoMsg(object: _176.MsgClearBalanceResponseAminoMsg): _176.MsgClearBalanceResponse;
            fromProtoMsg(message: _176.MsgClearBalanceResponseProtoMsg): _176.MsgClearBalanceResponse;
            toProto(message: _176.MsgClearBalanceResponse): Uint8Array;
            toProtoMsg(message: _176.MsgClearBalanceResponse): _176.MsgClearBalanceResponseProtoMsg;
        };
        MsgRedeemStake: {
            typeUrl: string;
            encode(message: _176.MsgRedeemStake, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRedeemStake;
            fromPartial(object: Partial<_176.MsgRedeemStake>): _176.MsgRedeemStake;
            fromAmino(object: _176.MsgRedeemStakeAmino): _176.MsgRedeemStake;
            toAmino(message: _176.MsgRedeemStake): _176.MsgRedeemStakeAmino;
            fromAminoMsg(object: _176.MsgRedeemStakeAminoMsg): _176.MsgRedeemStake;
            toAminoMsg(message: _176.MsgRedeemStake): _176.MsgRedeemStakeAminoMsg;
            fromProtoMsg(message: _176.MsgRedeemStakeProtoMsg): _176.MsgRedeemStake;
            toProto(message: _176.MsgRedeemStake): Uint8Array;
            toProtoMsg(message: _176.MsgRedeemStake): _176.MsgRedeemStakeProtoMsg;
        };
        MsgRedeemStakeResponse: {
            typeUrl: string;
            encode(_: _176.MsgRedeemStakeResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRedeemStakeResponse;
            fromPartial(_: Partial<_176.MsgRedeemStakeResponse>): _176.MsgRedeemStakeResponse;
            fromAmino(_: _176.MsgRedeemStakeResponseAmino): _176.MsgRedeemStakeResponse;
            toAmino(_: _176.MsgRedeemStakeResponse): _176.MsgRedeemStakeResponseAmino;
            fromAminoMsg(object: _176.MsgRedeemStakeResponseAminoMsg): _176.MsgRedeemStakeResponse;
            fromProtoMsg(message: _176.MsgRedeemStakeResponseProtoMsg): _176.MsgRedeemStakeResponse;
            toProto(message: _176.MsgRedeemStakeResponse): Uint8Array;
            toProtoMsg(message: _176.MsgRedeemStakeResponse): _176.MsgRedeemStakeResponseProtoMsg;
        };
        MsgRegisterHostZone: {
            typeUrl: string;
            encode(message: _176.MsgRegisterHostZone, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRegisterHostZone;
            fromPartial(object: Partial<_176.MsgRegisterHostZone>): _176.MsgRegisterHostZone;
            fromAmino(object: _176.MsgRegisterHostZoneAmino): _176.MsgRegisterHostZone;
            toAmino(message: _176.MsgRegisterHostZone): _176.MsgRegisterHostZoneAmino;
            fromAminoMsg(object: _176.MsgRegisterHostZoneAminoMsg): _176.MsgRegisterHostZone;
            toAminoMsg(message: _176.MsgRegisterHostZone): _176.MsgRegisterHostZoneAminoMsg;
            fromProtoMsg(message: _176.MsgRegisterHostZoneProtoMsg): _176.MsgRegisterHostZone;
            toProto(message: _176.MsgRegisterHostZone): Uint8Array;
            toProtoMsg(message: _176.MsgRegisterHostZone): _176.MsgRegisterHostZoneProtoMsg;
        };
        MsgRegisterHostZoneResponse: {
            typeUrl: string;
            encode(_: _176.MsgRegisterHostZoneResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRegisterHostZoneResponse;
            fromPartial(_: Partial<_176.MsgRegisterHostZoneResponse>): _176.MsgRegisterHostZoneResponse;
            fromAmino(_: _176.MsgRegisterHostZoneResponseAmino): _176.MsgRegisterHostZoneResponse;
            toAmino(_: _176.MsgRegisterHostZoneResponse): _176.MsgRegisterHostZoneResponseAmino;
            fromAminoMsg(object: _176.MsgRegisterHostZoneResponseAminoMsg): _176.MsgRegisterHostZoneResponse;
            fromProtoMsg(message: _176.MsgRegisterHostZoneResponseProtoMsg): _176.MsgRegisterHostZoneResponse;
            toProto(message: _176.MsgRegisterHostZoneResponse): Uint8Array;
            toProtoMsg(message: _176.MsgRegisterHostZoneResponse): _176.MsgRegisterHostZoneResponseProtoMsg;
        };
        MsgClaimUndelegatedTokens: {
            typeUrl: string;
            encode(message: _176.MsgClaimUndelegatedTokens, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgClaimUndelegatedTokens;
            fromPartial(object: Partial<_176.MsgClaimUndelegatedTokens>): _176.MsgClaimUndelegatedTokens;
            fromAmino(object: _176.MsgClaimUndelegatedTokensAmino): _176.MsgClaimUndelegatedTokens;
            toAmino(message: _176.MsgClaimUndelegatedTokens): _176.MsgClaimUndelegatedTokensAmino;
            fromAminoMsg(object: _176.MsgClaimUndelegatedTokensAminoMsg): _176.MsgClaimUndelegatedTokens;
            toAminoMsg(message: _176.MsgClaimUndelegatedTokens): _176.MsgClaimUndelegatedTokensAminoMsg;
            fromProtoMsg(message: _176.MsgClaimUndelegatedTokensProtoMsg): _176.MsgClaimUndelegatedTokens;
            toProto(message: _176.MsgClaimUndelegatedTokens): Uint8Array;
            toProtoMsg(message: _176.MsgClaimUndelegatedTokens): _176.MsgClaimUndelegatedTokensProtoMsg;
        };
        MsgClaimUndelegatedTokensResponse: {
            typeUrl: string;
            encode(_: _176.MsgClaimUndelegatedTokensResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgClaimUndelegatedTokensResponse;
            fromPartial(_: Partial<_176.MsgClaimUndelegatedTokensResponse>): _176.MsgClaimUndelegatedTokensResponse;
            fromAmino(_: _176.MsgClaimUndelegatedTokensResponseAmino): _176.MsgClaimUndelegatedTokensResponse;
            toAmino(_: _176.MsgClaimUndelegatedTokensResponse): _176.MsgClaimUndelegatedTokensResponseAmino;
            fromAminoMsg(object: _176.MsgClaimUndelegatedTokensResponseAminoMsg): _176.MsgClaimUndelegatedTokensResponse;
            fromProtoMsg(message: _176.MsgClaimUndelegatedTokensResponseProtoMsg): _176.MsgClaimUndelegatedTokensResponse;
            toProto(message: _176.MsgClaimUndelegatedTokensResponse): Uint8Array;
            toProtoMsg(message: _176.MsgClaimUndelegatedTokensResponse): _176.MsgClaimUndelegatedTokensResponseProtoMsg;
        };
        MsgRebalanceValidators: {
            typeUrl: string;
            encode(message: _176.MsgRebalanceValidators, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRebalanceValidators;
            fromPartial(object: Partial<_176.MsgRebalanceValidators>): _176.MsgRebalanceValidators;
            fromAmino(object: _176.MsgRebalanceValidatorsAmino): _176.MsgRebalanceValidators;
            toAmino(message: _176.MsgRebalanceValidators): _176.MsgRebalanceValidatorsAmino;
            fromAminoMsg(object: _176.MsgRebalanceValidatorsAminoMsg): _176.MsgRebalanceValidators;
            toAminoMsg(message: _176.MsgRebalanceValidators): _176.MsgRebalanceValidatorsAminoMsg;
            fromProtoMsg(message: _176.MsgRebalanceValidatorsProtoMsg): _176.MsgRebalanceValidators;
            toProto(message: _176.MsgRebalanceValidators): Uint8Array;
            toProtoMsg(message: _176.MsgRebalanceValidators): _176.MsgRebalanceValidatorsProtoMsg;
        };
        MsgRebalanceValidatorsResponse: {
            typeUrl: string;
            encode(_: _176.MsgRebalanceValidatorsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRebalanceValidatorsResponse;
            fromPartial(_: Partial<_176.MsgRebalanceValidatorsResponse>): _176.MsgRebalanceValidatorsResponse;
            fromAmino(_: _176.MsgRebalanceValidatorsResponseAmino): _176.MsgRebalanceValidatorsResponse;
            toAmino(_: _176.MsgRebalanceValidatorsResponse): _176.MsgRebalanceValidatorsResponseAmino;
            fromAminoMsg(object: _176.MsgRebalanceValidatorsResponseAminoMsg): _176.MsgRebalanceValidatorsResponse;
            fromProtoMsg(message: _176.MsgRebalanceValidatorsResponseProtoMsg): _176.MsgRebalanceValidatorsResponse;
            toProto(message: _176.MsgRebalanceValidatorsResponse): Uint8Array;
            toProtoMsg(message: _176.MsgRebalanceValidatorsResponse): _176.MsgRebalanceValidatorsResponseProtoMsg;
        };
        MsgAddValidators: {
            typeUrl: string;
            encode(message: _176.MsgAddValidators, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgAddValidators;
            fromPartial(object: Partial<_176.MsgAddValidators>): _176.MsgAddValidators;
            fromAmino(object: _176.MsgAddValidatorsAmino): _176.MsgAddValidators;
            toAmino(message: _176.MsgAddValidators): _176.MsgAddValidatorsAmino;
            fromAminoMsg(object: _176.MsgAddValidatorsAminoMsg): _176.MsgAddValidators;
            fromProtoMsg(message: _176.MsgAddValidatorsProtoMsg): _176.MsgAddValidators;
            toProto(message: _176.MsgAddValidators): Uint8Array;
            toProtoMsg(message: _176.MsgAddValidators): _176.MsgAddValidatorsProtoMsg;
        };
        MsgAddValidatorsResponse: {
            typeUrl: string;
            encode(_: _176.MsgAddValidatorsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgAddValidatorsResponse;
            fromPartial(_: Partial<_176.MsgAddValidatorsResponse>): _176.MsgAddValidatorsResponse;
            fromAmino(_: _176.MsgAddValidatorsResponseAmino): _176.MsgAddValidatorsResponse;
            toAmino(_: _176.MsgAddValidatorsResponse): _176.MsgAddValidatorsResponseAmino;
            fromAminoMsg(object: _176.MsgAddValidatorsResponseAminoMsg): _176.MsgAddValidatorsResponse;
            fromProtoMsg(message: _176.MsgAddValidatorsResponseProtoMsg): _176.MsgAddValidatorsResponse;
            toProto(message: _176.MsgAddValidatorsResponse): Uint8Array;
            toProtoMsg(message: _176.MsgAddValidatorsResponse): _176.MsgAddValidatorsResponseProtoMsg;
        };
        ValidatorWeight: {
            typeUrl: string;
            encode(message: _176.ValidatorWeight, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.ValidatorWeight;
            fromPartial(object: Partial<_176.ValidatorWeight>): _176.ValidatorWeight;
            fromAmino(object: _176.ValidatorWeightAmino): _176.ValidatorWeight;
            toAmino(message: _176.ValidatorWeight): _176.ValidatorWeightAmino;
            fromAminoMsg(object: _176.ValidatorWeightAminoMsg): _176.ValidatorWeight;
            fromProtoMsg(message: _176.ValidatorWeightProtoMsg): _176.ValidatorWeight;
            toProto(message: _176.ValidatorWeight): Uint8Array;
            toProtoMsg(message: _176.ValidatorWeight): _176.ValidatorWeightProtoMsg;
        };
        MsgChangeValidatorWeights: {
            typeUrl: string;
            encode(message: _176.MsgChangeValidatorWeights, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgChangeValidatorWeights;
            fromPartial(object: Partial<_176.MsgChangeValidatorWeights>): _176.MsgChangeValidatorWeights;
            fromAmino(object: _176.MsgChangeValidatorWeightsAmino): _176.MsgChangeValidatorWeights;
            toAmino(message: _176.MsgChangeValidatorWeights): _176.MsgChangeValidatorWeightsAmino;
            fromAminoMsg(object: _176.MsgChangeValidatorWeightsAminoMsg): _176.MsgChangeValidatorWeights;
            fromProtoMsg(message: _176.MsgChangeValidatorWeightsProtoMsg): _176.MsgChangeValidatorWeights;
            toProto(message: _176.MsgChangeValidatorWeights): Uint8Array;
            toProtoMsg(message: _176.MsgChangeValidatorWeights): _176.MsgChangeValidatorWeightsProtoMsg;
        };
        MsgChangeValidatorWeightsResponse: {
            typeUrl: string;
            encode(_: _176.MsgChangeValidatorWeightsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgChangeValidatorWeightsResponse;
            fromPartial(_: Partial<_176.MsgChangeValidatorWeightsResponse>): _176.MsgChangeValidatorWeightsResponse;
            fromAmino(_: _176.MsgChangeValidatorWeightsResponseAmino): _176.MsgChangeValidatorWeightsResponse;
            toAmino(_: _176.MsgChangeValidatorWeightsResponse): _176.MsgChangeValidatorWeightsResponseAmino;
            fromAminoMsg(object: _176.MsgChangeValidatorWeightsResponseAminoMsg): _176.MsgChangeValidatorWeightsResponse;
            fromProtoMsg(message: _176.MsgChangeValidatorWeightsResponseProtoMsg): _176.MsgChangeValidatorWeightsResponse;
            toProto(message: _176.MsgChangeValidatorWeightsResponse): Uint8Array;
            toProtoMsg(message: _176.MsgChangeValidatorWeightsResponse): _176.MsgChangeValidatorWeightsResponseProtoMsg;
        };
        MsgDeleteValidator: {
            typeUrl: string;
            encode(message: _176.MsgDeleteValidator, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgDeleteValidator;
            fromPartial(object: Partial<_176.MsgDeleteValidator>): _176.MsgDeleteValidator;
            fromAmino(object: _176.MsgDeleteValidatorAmino): _176.MsgDeleteValidator;
            toAmino(message: _176.MsgDeleteValidator): _176.MsgDeleteValidatorAmino;
            fromAminoMsg(object: _176.MsgDeleteValidatorAminoMsg): _176.MsgDeleteValidator;
            toAminoMsg(message: _176.MsgDeleteValidator): _176.MsgDeleteValidatorAminoMsg;
            fromProtoMsg(message: _176.MsgDeleteValidatorProtoMsg): _176.MsgDeleteValidator;
            toProto(message: _176.MsgDeleteValidator): Uint8Array;
            toProtoMsg(message: _176.MsgDeleteValidator): _176.MsgDeleteValidatorProtoMsg;
        };
        MsgDeleteValidatorResponse: {
            typeUrl: string;
            encode(_: _176.MsgDeleteValidatorResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgDeleteValidatorResponse;
            fromPartial(_: Partial<_176.MsgDeleteValidatorResponse>): _176.MsgDeleteValidatorResponse;
            fromAmino(_: _176.MsgDeleteValidatorResponseAmino): _176.MsgDeleteValidatorResponse;
            toAmino(_: _176.MsgDeleteValidatorResponse): _176.MsgDeleteValidatorResponseAmino;
            fromAminoMsg(object: _176.MsgDeleteValidatorResponseAminoMsg): _176.MsgDeleteValidatorResponse;
            fromProtoMsg(message: _176.MsgDeleteValidatorResponseProtoMsg): _176.MsgDeleteValidatorResponse;
            toProto(message: _176.MsgDeleteValidatorResponse): Uint8Array;
            toProtoMsg(message: _176.MsgDeleteValidatorResponse): _176.MsgDeleteValidatorResponseProtoMsg;
        };
        MsgRestoreInterchainAccount: {
            typeUrl: string;
            encode(message: _176.MsgRestoreInterchainAccount, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRestoreInterchainAccount;
            fromPartial(object: Partial<_176.MsgRestoreInterchainAccount>): _176.MsgRestoreInterchainAccount;
            fromAmino(object: _176.MsgRestoreInterchainAccountAmino): _176.MsgRestoreInterchainAccount;
            toAmino(message: _176.MsgRestoreInterchainAccount): _176.MsgRestoreInterchainAccountAmino;
            fromAminoMsg(object: _176.MsgRestoreInterchainAccountAminoMsg): _176.MsgRestoreInterchainAccount;
            toAminoMsg(message: _176.MsgRestoreInterchainAccount): _176.MsgRestoreInterchainAccountAminoMsg;
            fromProtoMsg(message: _176.MsgRestoreInterchainAccountProtoMsg): _176.MsgRestoreInterchainAccount;
            toProto(message: _176.MsgRestoreInterchainAccount): Uint8Array;
            toProtoMsg(message: _176.MsgRestoreInterchainAccount): _176.MsgRestoreInterchainAccountProtoMsg;
        };
        MsgRestoreInterchainAccountResponse: {
            typeUrl: string;
            encode(_: _176.MsgRestoreInterchainAccountResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgRestoreInterchainAccountResponse;
            fromPartial(_: Partial<_176.MsgRestoreInterchainAccountResponse>): _176.MsgRestoreInterchainAccountResponse;
            fromAmino(_: _176.MsgRestoreInterchainAccountResponseAmino): _176.MsgRestoreInterchainAccountResponse;
            toAmino(_: _176.MsgRestoreInterchainAccountResponse): _176.MsgRestoreInterchainAccountResponseAmino;
            fromAminoMsg(object: _176.MsgRestoreInterchainAccountResponseAminoMsg): _176.MsgRestoreInterchainAccountResponse;
            fromProtoMsg(message: _176.MsgRestoreInterchainAccountResponseProtoMsg): _176.MsgRestoreInterchainAccountResponse;
            toProto(message: _176.MsgRestoreInterchainAccountResponse): Uint8Array;
            toProtoMsg(message: _176.MsgRestoreInterchainAccountResponse): _176.MsgRestoreInterchainAccountResponseProtoMsg;
        };
        MsgUpdateValidatorSharesExchRate: {
            typeUrl: string;
            encode(message: _176.MsgUpdateValidatorSharesExchRate, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateValidatorSharesExchRate;
            fromPartial(object: Partial<_176.MsgUpdateValidatorSharesExchRate>): _176.MsgUpdateValidatorSharesExchRate;
            fromAmino(object: _176.MsgUpdateValidatorSharesExchRateAmino): _176.MsgUpdateValidatorSharesExchRate;
            toAmino(message: _176.MsgUpdateValidatorSharesExchRate): _176.MsgUpdateValidatorSharesExchRateAmino;
            fromAminoMsg(object: _176.MsgUpdateValidatorSharesExchRateAminoMsg): _176.MsgUpdateValidatorSharesExchRate;
            toAminoMsg(message: _176.MsgUpdateValidatorSharesExchRate): _176.MsgUpdateValidatorSharesExchRateAminoMsg;
            fromProtoMsg(message: _176.MsgUpdateValidatorSharesExchRateProtoMsg): _176.MsgUpdateValidatorSharesExchRate;
            toProto(message: _176.MsgUpdateValidatorSharesExchRate): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateValidatorSharesExchRate): _176.MsgUpdateValidatorSharesExchRateProtoMsg;
        };
        MsgUpdateValidatorSharesExchRateResponse: {
            typeUrl: string;
            encode(_: _176.MsgUpdateValidatorSharesExchRateResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateValidatorSharesExchRateResponse;
            fromPartial(_: Partial<_176.MsgUpdateValidatorSharesExchRateResponse>): _176.MsgUpdateValidatorSharesExchRateResponse;
            fromAmino(_: _176.MsgUpdateValidatorSharesExchRateResponseAmino): _176.MsgUpdateValidatorSharesExchRateResponse;
            toAmino(_: _176.MsgUpdateValidatorSharesExchRateResponse): _176.MsgUpdateValidatorSharesExchRateResponseAmino;
            fromAminoMsg(object: _176.MsgUpdateValidatorSharesExchRateResponseAminoMsg): _176.MsgUpdateValidatorSharesExchRateResponse;
            fromProtoMsg(message: _176.MsgUpdateValidatorSharesExchRateResponseProtoMsg): _176.MsgUpdateValidatorSharesExchRateResponse;
            toProto(message: _176.MsgUpdateValidatorSharesExchRateResponse): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateValidatorSharesExchRateResponse): _176.MsgUpdateValidatorSharesExchRateResponseProtoMsg;
        };
        MsgCalibrateDelegation: {
            typeUrl: string;
            encode(message: _176.MsgCalibrateDelegation, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgCalibrateDelegation;
            fromPartial(object: Partial<_176.MsgCalibrateDelegation>): _176.MsgCalibrateDelegation;
            fromAmino(object: _176.MsgCalibrateDelegationAmino): _176.MsgCalibrateDelegation;
            toAmino(message: _176.MsgCalibrateDelegation): _176.MsgCalibrateDelegationAmino;
            fromAminoMsg(object: _176.MsgCalibrateDelegationAminoMsg): _176.MsgCalibrateDelegation;
            fromProtoMsg(message: _176.MsgCalibrateDelegationProtoMsg): _176.MsgCalibrateDelegation;
            toProto(message: _176.MsgCalibrateDelegation): Uint8Array;
            toProtoMsg(message: _176.MsgCalibrateDelegation): _176.MsgCalibrateDelegationProtoMsg;
        };
        MsgCalibrateDelegationResponse: {
            typeUrl: string;
            encode(_: _176.MsgCalibrateDelegationResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgCalibrateDelegationResponse;
            fromPartial(_: Partial<_176.MsgCalibrateDelegationResponse>): _176.MsgCalibrateDelegationResponse;
            fromAmino(_: _176.MsgCalibrateDelegationResponseAmino): _176.MsgCalibrateDelegationResponse;
            toAmino(_: _176.MsgCalibrateDelegationResponse): _176.MsgCalibrateDelegationResponseAmino;
            fromAminoMsg(object: _176.MsgCalibrateDelegationResponseAminoMsg): _176.MsgCalibrateDelegationResponse;
            fromProtoMsg(message: _176.MsgCalibrateDelegationResponseProtoMsg): _176.MsgCalibrateDelegationResponse;
            toProto(message: _176.MsgCalibrateDelegationResponse): Uint8Array;
            toProtoMsg(message: _176.MsgCalibrateDelegationResponse): _176.MsgCalibrateDelegationResponseProtoMsg;
        };
        MsgResumeHostZone: {
            typeUrl: string;
            encode(message: _176.MsgResumeHostZone, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgResumeHostZone;
            fromPartial(object: Partial<_176.MsgResumeHostZone>): _176.MsgResumeHostZone;
            fromAmino(object: _176.MsgResumeHostZoneAmino): _176.MsgResumeHostZone;
            toAmino(message: _176.MsgResumeHostZone): _176.MsgResumeHostZoneAmino;
            fromAminoMsg(object: _176.MsgResumeHostZoneAminoMsg): _176.MsgResumeHostZone;
            fromProtoMsg(message: _176.MsgResumeHostZoneProtoMsg): _176.MsgResumeHostZone;
            toProto(message: _176.MsgResumeHostZone): Uint8Array;
            toProtoMsg(message: _176.MsgResumeHostZone): _176.MsgResumeHostZoneProtoMsg;
        };
        MsgResumeHostZoneResponse: {
            typeUrl: string;
            encode(_: _176.MsgResumeHostZoneResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgResumeHostZoneResponse;
            fromPartial(_: Partial<_176.MsgResumeHostZoneResponse>): _176.MsgResumeHostZoneResponse;
            fromAmino(_: _176.MsgResumeHostZoneResponseAmino): _176.MsgResumeHostZoneResponse;
            toAmino(_: _176.MsgResumeHostZoneResponse): _176.MsgResumeHostZoneResponseAmino;
            fromAminoMsg(object: _176.MsgResumeHostZoneResponseAminoMsg): _176.MsgResumeHostZoneResponse;
            fromProtoMsg(message: _176.MsgResumeHostZoneResponseProtoMsg): _176.MsgResumeHostZoneResponse;
            toProto(message: _176.MsgResumeHostZoneResponse): Uint8Array;
            toProtoMsg(message: _176.MsgResumeHostZoneResponse): _176.MsgResumeHostZoneResponseProtoMsg;
        };
        MsgCreateTradeRoute: {
            typeUrl: string;
            encode(message: _176.MsgCreateTradeRoute, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgCreateTradeRoute;
            fromPartial(object: Partial<_176.MsgCreateTradeRoute>): _176.MsgCreateTradeRoute;
            fromAmino(object: _176.MsgCreateTradeRouteAmino): _176.MsgCreateTradeRoute;
            toAmino(message: _176.MsgCreateTradeRoute): _176.MsgCreateTradeRouteAmino;
            fromAminoMsg(object: _176.MsgCreateTradeRouteAminoMsg): _176.MsgCreateTradeRoute;
            toAminoMsg(message: _176.MsgCreateTradeRoute): _176.MsgCreateTradeRouteAminoMsg;
            fromProtoMsg(message: _176.MsgCreateTradeRouteProtoMsg): _176.MsgCreateTradeRoute;
            toProto(message: _176.MsgCreateTradeRoute): Uint8Array;
            toProtoMsg(message: _176.MsgCreateTradeRoute): _176.MsgCreateTradeRouteProtoMsg;
        };
        MsgCreateTradeRouteResponse: {
            typeUrl: string;
            encode(_: _176.MsgCreateTradeRouteResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgCreateTradeRouteResponse;
            fromPartial(_: Partial<_176.MsgCreateTradeRouteResponse>): _176.MsgCreateTradeRouteResponse;
            fromAmino(_: _176.MsgCreateTradeRouteResponseAmino): _176.MsgCreateTradeRouteResponse;
            toAmino(_: _176.MsgCreateTradeRouteResponse): _176.MsgCreateTradeRouteResponseAmino;
            fromAminoMsg(object: _176.MsgCreateTradeRouteResponseAminoMsg): _176.MsgCreateTradeRouteResponse;
            fromProtoMsg(message: _176.MsgCreateTradeRouteResponseProtoMsg): _176.MsgCreateTradeRouteResponse;
            toProto(message: _176.MsgCreateTradeRouteResponse): Uint8Array;
            toProtoMsg(message: _176.MsgCreateTradeRouteResponse): _176.MsgCreateTradeRouteResponseProtoMsg;
        };
        MsgDeleteTradeRoute: {
            typeUrl: string;
            encode(message: _176.MsgDeleteTradeRoute, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgDeleteTradeRoute;
            fromPartial(object: Partial<_176.MsgDeleteTradeRoute>): _176.MsgDeleteTradeRoute;
            fromAmino(object: _176.MsgDeleteTradeRouteAmino): _176.MsgDeleteTradeRoute;
            toAmino(message: _176.MsgDeleteTradeRoute): _176.MsgDeleteTradeRouteAmino;
            fromAminoMsg(object: _176.MsgDeleteTradeRouteAminoMsg): _176.MsgDeleteTradeRoute;
            toAminoMsg(message: _176.MsgDeleteTradeRoute): _176.MsgDeleteTradeRouteAminoMsg;
            fromProtoMsg(message: _176.MsgDeleteTradeRouteProtoMsg): _176.MsgDeleteTradeRoute;
            toProto(message: _176.MsgDeleteTradeRoute): Uint8Array;
            toProtoMsg(message: _176.MsgDeleteTradeRoute): _176.MsgDeleteTradeRouteProtoMsg;
        };
        MsgDeleteTradeRouteResponse: {
            typeUrl: string;
            encode(_: _176.MsgDeleteTradeRouteResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgDeleteTradeRouteResponse;
            fromPartial(_: Partial<_176.MsgDeleteTradeRouteResponse>): _176.MsgDeleteTradeRouteResponse;
            fromAmino(_: _176.MsgDeleteTradeRouteResponseAmino): _176.MsgDeleteTradeRouteResponse;
            toAmino(_: _176.MsgDeleteTradeRouteResponse): _176.MsgDeleteTradeRouteResponseAmino;
            fromAminoMsg(object: _176.MsgDeleteTradeRouteResponseAminoMsg): _176.MsgDeleteTradeRouteResponse;
            fromProtoMsg(message: _176.MsgDeleteTradeRouteResponseProtoMsg): _176.MsgDeleteTradeRouteResponse;
            toProto(message: _176.MsgDeleteTradeRouteResponse): Uint8Array;
            toProtoMsg(message: _176.MsgDeleteTradeRouteResponse): _176.MsgDeleteTradeRouteResponseProtoMsg;
        };
        MsgUpdateTradeRoute: {
            typeUrl: string;
            encode(message: _176.MsgUpdateTradeRoute, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateTradeRoute;
            fromPartial(object: Partial<_176.MsgUpdateTradeRoute>): _176.MsgUpdateTradeRoute;
            fromAmino(object: _176.MsgUpdateTradeRouteAmino): _176.MsgUpdateTradeRoute;
            toAmino(message: _176.MsgUpdateTradeRoute): _176.MsgUpdateTradeRouteAmino;
            fromAminoMsg(object: _176.MsgUpdateTradeRouteAminoMsg): _176.MsgUpdateTradeRoute;
            toAminoMsg(message: _176.MsgUpdateTradeRoute): _176.MsgUpdateTradeRouteAminoMsg;
            fromProtoMsg(message: _176.MsgUpdateTradeRouteProtoMsg): _176.MsgUpdateTradeRoute;
            toProto(message: _176.MsgUpdateTradeRoute): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateTradeRoute): _176.MsgUpdateTradeRouteProtoMsg;
        };
        MsgUpdateTradeRouteResponse: {
            typeUrl: string;
            encode(_: _176.MsgUpdateTradeRouteResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateTradeRouteResponse;
            fromPartial(_: Partial<_176.MsgUpdateTradeRouteResponse>): _176.MsgUpdateTradeRouteResponse;
            fromAmino(_: _176.MsgUpdateTradeRouteResponseAmino): _176.MsgUpdateTradeRouteResponse;
            toAmino(_: _176.MsgUpdateTradeRouteResponse): _176.MsgUpdateTradeRouteResponseAmino;
            fromAminoMsg(object: _176.MsgUpdateTradeRouteResponseAminoMsg): _176.MsgUpdateTradeRouteResponse;
            fromProtoMsg(message: _176.MsgUpdateTradeRouteResponseProtoMsg): _176.MsgUpdateTradeRouteResponse;
            toProto(message: _176.MsgUpdateTradeRouteResponse): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateTradeRouteResponse): _176.MsgUpdateTradeRouteResponseProtoMsg;
        };
        MsgSetCommunityPoolRebate: {
            typeUrl: string;
            encode(message: _176.MsgSetCommunityPoolRebate, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgSetCommunityPoolRebate;
            fromPartial(object: Partial<_176.MsgSetCommunityPoolRebate>): _176.MsgSetCommunityPoolRebate;
            fromAmino(object: _176.MsgSetCommunityPoolRebateAmino): _176.MsgSetCommunityPoolRebate;
            toAmino(message: _176.MsgSetCommunityPoolRebate): _176.MsgSetCommunityPoolRebateAmino;
            fromAminoMsg(object: _176.MsgSetCommunityPoolRebateAminoMsg): _176.MsgSetCommunityPoolRebate;
            toAminoMsg(message: _176.MsgSetCommunityPoolRebate): _176.MsgSetCommunityPoolRebateAminoMsg;
            fromProtoMsg(message: _176.MsgSetCommunityPoolRebateProtoMsg): _176.MsgSetCommunityPoolRebate;
            toProto(message: _176.MsgSetCommunityPoolRebate): Uint8Array;
            toProtoMsg(message: _176.MsgSetCommunityPoolRebate): _176.MsgSetCommunityPoolRebateProtoMsg;
        };
        MsgSetCommunityPoolRebateResponse: {
            typeUrl: string;
            encode(_: _176.MsgSetCommunityPoolRebateResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgSetCommunityPoolRebateResponse;
            fromPartial(_: Partial<_176.MsgSetCommunityPoolRebateResponse>): _176.MsgSetCommunityPoolRebateResponse;
            fromAmino(_: _176.MsgSetCommunityPoolRebateResponseAmino): _176.MsgSetCommunityPoolRebateResponse;
            toAmino(_: _176.MsgSetCommunityPoolRebateResponse): _176.MsgSetCommunityPoolRebateResponseAmino;
            fromAminoMsg(object: _176.MsgSetCommunityPoolRebateResponseAminoMsg): _176.MsgSetCommunityPoolRebateResponse;
            fromProtoMsg(message: _176.MsgSetCommunityPoolRebateResponseProtoMsg): _176.MsgSetCommunityPoolRebateResponse;
            toProto(message: _176.MsgSetCommunityPoolRebateResponse): Uint8Array;
            toProtoMsg(message: _176.MsgSetCommunityPoolRebateResponse): _176.MsgSetCommunityPoolRebateResponseProtoMsg;
        };
        MsgToggleTradeController: {
            typeUrl: string;
            encode(message: _176.MsgToggleTradeController, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgToggleTradeController;
            fromPartial(object: Partial<_176.MsgToggleTradeController>): _176.MsgToggleTradeController;
            fromAmino(object: _176.MsgToggleTradeControllerAmino): _176.MsgToggleTradeController;
            toAmino(message: _176.MsgToggleTradeController): _176.MsgToggleTradeControllerAmino;
            fromAminoMsg(object: _176.MsgToggleTradeControllerAminoMsg): _176.MsgToggleTradeController;
            toAminoMsg(message: _176.MsgToggleTradeController): _176.MsgToggleTradeControllerAminoMsg;
            fromProtoMsg(message: _176.MsgToggleTradeControllerProtoMsg): _176.MsgToggleTradeController;
            toProto(message: _176.MsgToggleTradeController): Uint8Array;
            toProtoMsg(message: _176.MsgToggleTradeController): _176.MsgToggleTradeControllerProtoMsg;
        };
        MsgToggleTradeControllerResponse: {
            typeUrl: string;
            encode(_: _176.MsgToggleTradeControllerResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgToggleTradeControllerResponse;
            fromPartial(_: Partial<_176.MsgToggleTradeControllerResponse>): _176.MsgToggleTradeControllerResponse;
            fromAmino(_: _176.MsgToggleTradeControllerResponseAmino): _176.MsgToggleTradeControllerResponse;
            toAmino(_: _176.MsgToggleTradeControllerResponse): _176.MsgToggleTradeControllerResponseAmino;
            fromAminoMsg(object: _176.MsgToggleTradeControllerResponseAminoMsg): _176.MsgToggleTradeControllerResponse;
            fromProtoMsg(message: _176.MsgToggleTradeControllerResponseProtoMsg): _176.MsgToggleTradeControllerResponse;
            toProto(message: _176.MsgToggleTradeControllerResponse): Uint8Array;
            toProtoMsg(message: _176.MsgToggleTradeControllerResponse): _176.MsgToggleTradeControllerResponseProtoMsg;
        };
        MsgUpdateHostZoneParams: {
            typeUrl: string;
            encode(message: _176.MsgUpdateHostZoneParams, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateHostZoneParams;
            fromPartial(object: Partial<_176.MsgUpdateHostZoneParams>): _176.MsgUpdateHostZoneParams;
            fromAmino(object: _176.MsgUpdateHostZoneParamsAmino): _176.MsgUpdateHostZoneParams;
            toAmino(message: _176.MsgUpdateHostZoneParams): _176.MsgUpdateHostZoneParamsAmino;
            fromAminoMsg(object: _176.MsgUpdateHostZoneParamsAminoMsg): _176.MsgUpdateHostZoneParams;
            toAminoMsg(message: _176.MsgUpdateHostZoneParams): _176.MsgUpdateHostZoneParamsAminoMsg;
            fromProtoMsg(message: _176.MsgUpdateHostZoneParamsProtoMsg): _176.MsgUpdateHostZoneParams;
            toProto(message: _176.MsgUpdateHostZoneParams): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateHostZoneParams): _176.MsgUpdateHostZoneParamsProtoMsg;
        };
        MsgUpdateHostZoneParamsResponse: {
            typeUrl: string;
            encode(_: _176.MsgUpdateHostZoneParamsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _176.MsgUpdateHostZoneParamsResponse;
            fromPartial(_: Partial<_176.MsgUpdateHostZoneParamsResponse>): _176.MsgUpdateHostZoneParamsResponse;
            fromAmino(_: _176.MsgUpdateHostZoneParamsResponseAmino): _176.MsgUpdateHostZoneParamsResponse;
            toAmino(_: _176.MsgUpdateHostZoneParamsResponse): _176.MsgUpdateHostZoneParamsResponseAmino;
            fromAminoMsg(object: _176.MsgUpdateHostZoneParamsResponseAminoMsg): _176.MsgUpdateHostZoneParamsResponse;
            fromProtoMsg(message: _176.MsgUpdateHostZoneParamsResponseProtoMsg): _176.MsgUpdateHostZoneParamsResponse;
            toProto(message: _176.MsgUpdateHostZoneParamsResponse): Uint8Array;
            toProtoMsg(message: _176.MsgUpdateHostZoneParamsResponse): _176.MsgUpdateHostZoneParamsResponseProtoMsg;
        };
    };
    const staketia: {
        registry: readonly [string, import("..").TelescopeGeneratedType<any, any, any>][];
        load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
        MessageComposer: {
            encoded: {
                liquidStake(value: _181.MsgLiquidStake): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                redeemStake(value: _181.MsgRedeemStake): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                confirmDelegation(value: _181.MsgConfirmDelegation): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                confirmUndelegation(value: _181.MsgConfirmUndelegation): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                confirmUnbondedTokenSweep(value: _181.MsgConfirmUnbondedTokenSweep): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                adjustDelegatedBalance(value: _181.MsgAdjustDelegatedBalance): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                updateInnerRedemptionRateBounds(value: _181.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                resumeHostZone(value: _181.MsgResumeHostZone): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                refreshRedemptionRate(value: _181.MsgRefreshRedemptionRate): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                overwriteDelegationRecord(value: _181.MsgOverwriteDelegationRecord): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                overwriteUnbondingRecord(value: _181.MsgOverwriteUnbondingRecord): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                overwriteRedemptionRecord(value: _181.MsgOverwriteRedemptionRecord): {
                    typeUrl: string;
                    value: Uint8Array;
                };
                setOperatorAddress(value: _181.MsgSetOperatorAddress): {
                    typeUrl: string;
                    value: Uint8Array;
                };
            };
            withTypeUrl: {
                liquidStake(value: _181.MsgLiquidStake): {
                    typeUrl: string;
                    value: _181.MsgLiquidStake;
                };
                redeemStake(value: _181.MsgRedeemStake): {
                    typeUrl: string;
                    value: _181.MsgRedeemStake;
                };
                confirmDelegation(value: _181.MsgConfirmDelegation): {
                    typeUrl: string;
                    value: _181.MsgConfirmDelegation;
                };
                confirmUndelegation(value: _181.MsgConfirmUndelegation): {
                    typeUrl: string;
                    value: _181.MsgConfirmUndelegation;
                };
                confirmUnbondedTokenSweep(value: _181.MsgConfirmUnbondedTokenSweep): {
                    typeUrl: string;
                    value: _181.MsgConfirmUnbondedTokenSweep;
                };
                adjustDelegatedBalance(value: _181.MsgAdjustDelegatedBalance): {
                    typeUrl: string;
                    value: _181.MsgAdjustDelegatedBalance;
                };
                updateInnerRedemptionRateBounds(value: _181.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: _181.MsgUpdateInnerRedemptionRateBounds;
                };
                resumeHostZone(value: _181.MsgResumeHostZone): {
                    typeUrl: string;
                    value: _181.MsgResumeHostZone;
                };
                refreshRedemptionRate(value: _181.MsgRefreshRedemptionRate): {
                    typeUrl: string;
                    value: _181.MsgRefreshRedemptionRate;
                };
                overwriteDelegationRecord(value: _181.MsgOverwriteDelegationRecord): {
                    typeUrl: string;
                    value: _181.MsgOverwriteDelegationRecord;
                };
                overwriteUnbondingRecord(value: _181.MsgOverwriteUnbondingRecord): {
                    typeUrl: string;
                    value: _181.MsgOverwriteUnbondingRecord;
                };
                overwriteRedemptionRecord(value: _181.MsgOverwriteRedemptionRecord): {
                    typeUrl: string;
                    value: _181.MsgOverwriteRedemptionRecord;
                };
                setOperatorAddress(value: _181.MsgSetOperatorAddress): {
                    typeUrl: string;
                    value: _181.MsgSetOperatorAddress;
                };
            };
            fromPartial: {
                liquidStake(value: _181.MsgLiquidStake): {
                    typeUrl: string;
                    value: _181.MsgLiquidStake;
                };
                redeemStake(value: _181.MsgRedeemStake): {
                    typeUrl: string;
                    value: _181.MsgRedeemStake;
                };
                confirmDelegation(value: _181.MsgConfirmDelegation): {
                    typeUrl: string;
                    value: _181.MsgConfirmDelegation;
                };
                confirmUndelegation(value: _181.MsgConfirmUndelegation): {
                    typeUrl: string;
                    value: _181.MsgConfirmUndelegation;
                };
                confirmUnbondedTokenSweep(value: _181.MsgConfirmUnbondedTokenSweep): {
                    typeUrl: string;
                    value: _181.MsgConfirmUnbondedTokenSweep;
                };
                adjustDelegatedBalance(value: _181.MsgAdjustDelegatedBalance): {
                    typeUrl: string;
                    value: _181.MsgAdjustDelegatedBalance;
                };
                updateInnerRedemptionRateBounds(value: _181.MsgUpdateInnerRedemptionRateBounds): {
                    typeUrl: string;
                    value: _181.MsgUpdateInnerRedemptionRateBounds;
                };
                resumeHostZone(value: _181.MsgResumeHostZone): {
                    typeUrl: string;
                    value: _181.MsgResumeHostZone;
                };
                refreshRedemptionRate(value: _181.MsgRefreshRedemptionRate): {
                    typeUrl: string;
                    value: _181.MsgRefreshRedemptionRate;
                };
                overwriteDelegationRecord(value: _181.MsgOverwriteDelegationRecord): {
                    typeUrl: string;
                    value: _181.MsgOverwriteDelegationRecord;
                };
                overwriteUnbondingRecord(value: _181.MsgOverwriteUnbondingRecord): {
                    typeUrl: string;
                    value: _181.MsgOverwriteUnbondingRecord;
                };
                overwriteRedemptionRecord(value: _181.MsgOverwriteRedemptionRecord): {
                    typeUrl: string;
                    value: _181.MsgOverwriteRedemptionRecord;
                };
                setOperatorAddress(value: _181.MsgSetOperatorAddress): {
                    typeUrl: string;
                    value: _181.MsgSetOperatorAddress;
                };
            };
        };
        AminoConverter: {
            '/stride.staketia.MsgLiquidStake': {
                aminoType: string;
                toAmino: (message: _181.MsgLiquidStake) => _181.MsgLiquidStakeAmino;
                fromAmino: (object: _181.MsgLiquidStakeAmino) => _181.MsgLiquidStake;
            };
            '/stride.staketia.MsgRedeemStake': {
                aminoType: string;
                toAmino: (message: _181.MsgRedeemStake) => _181.MsgRedeemStakeAmino;
                fromAmino: (object: _181.MsgRedeemStakeAmino) => _181.MsgRedeemStake;
            };
            '/stride.staketia.MsgConfirmDelegation': {
                aminoType: string;
                toAmino: (message: _181.MsgConfirmDelegation) => _181.MsgConfirmDelegationAmino;
                fromAmino: (object: _181.MsgConfirmDelegationAmino) => _181.MsgConfirmDelegation;
            };
            '/stride.staketia.MsgConfirmUndelegation': {
                aminoType: string;
                toAmino: (message: _181.MsgConfirmUndelegation) => _181.MsgConfirmUndelegationAmino;
                fromAmino: (object: _181.MsgConfirmUndelegationAmino) => _181.MsgConfirmUndelegation;
            };
            '/stride.staketia.MsgConfirmUnbondedTokenSweep': {
                aminoType: string;
                toAmino: (message: _181.MsgConfirmUnbondedTokenSweep) => _181.MsgConfirmUnbondedTokenSweepAmino;
                fromAmino: (object: _181.MsgConfirmUnbondedTokenSweepAmino) => _181.MsgConfirmUnbondedTokenSweep;
            };
            '/stride.staketia.MsgAdjustDelegatedBalance': {
                aminoType: string;
                toAmino: (message: _181.MsgAdjustDelegatedBalance) => _181.MsgAdjustDelegatedBalanceAmino;
                fromAmino: (object: _181.MsgAdjustDelegatedBalanceAmino) => _181.MsgAdjustDelegatedBalance;
            };
            '/stride.staketia.MsgUpdateInnerRedemptionRateBounds': {
                aminoType: string;
                toAmino: (message: _181.MsgUpdateInnerRedemptionRateBounds) => _181.MsgUpdateInnerRedemptionRateBoundsAmino;
                fromAmino: (object: _181.MsgUpdateInnerRedemptionRateBoundsAmino) => _181.MsgUpdateInnerRedemptionRateBounds;
            };
            '/stride.staketia.MsgResumeHostZone': {
                aminoType: string;
                toAmino: (message: _181.MsgResumeHostZone) => _181.MsgResumeHostZoneAmino;
                fromAmino: (object: _181.MsgResumeHostZoneAmino) => _181.MsgResumeHostZone;
            };
            '/stride.staketia.MsgRefreshRedemptionRate': {
                aminoType: string;
                toAmino: (message: _181.MsgRefreshRedemptionRate) => _181.MsgRefreshRedemptionRateAmino;
                fromAmino: (object: _181.MsgRefreshRedemptionRateAmino) => _181.MsgRefreshRedemptionRate;
            };
            '/stride.staketia.MsgOverwriteDelegationRecord': {
                aminoType: string;
                toAmino: (message: _181.MsgOverwriteDelegationRecord) => _181.MsgOverwriteDelegationRecordAmino;
                fromAmino: (object: _181.MsgOverwriteDelegationRecordAmino) => _181.MsgOverwriteDelegationRecord;
            };
            '/stride.staketia.MsgOverwriteUnbondingRecord': {
                aminoType: string;
                toAmino: (message: _181.MsgOverwriteUnbondingRecord) => _181.MsgOverwriteUnbondingRecordAmino;
                fromAmino: (object: _181.MsgOverwriteUnbondingRecordAmino) => _181.MsgOverwriteUnbondingRecord;
            };
            '/stride.staketia.MsgOverwriteRedemptionRecord': {
                aminoType: string;
                toAmino: (message: _181.MsgOverwriteRedemptionRecord) => _181.MsgOverwriteRedemptionRecordAmino;
                fromAmino: (object: _181.MsgOverwriteRedemptionRecordAmino) => _181.MsgOverwriteRedemptionRecord;
            };
            '/stride.staketia.MsgSetOperatorAddress': {
                aminoType: string;
                toAmino: (message: _181.MsgSetOperatorAddress) => _181.MsgSetOperatorAddressAmino;
                fromAmino: (object: _181.MsgSetOperatorAddressAmino) => _181.MsgSetOperatorAddress;
            };
        };
        overwritableRecordTypeFromJSON(object: any): _181.OverwritableRecordType;
        overwritableRecordTypeToJSON(object: _181.OverwritableRecordType): string;
        OverwritableRecordType: typeof _181.OverwritableRecordType;
        OverwritableRecordTypeSDKType: typeof _181.OverwritableRecordType;
        OverwritableRecordTypeAmino: typeof _181.OverwritableRecordType;
        MsgLiquidStake: {
            typeUrl: string;
            encode(message: _181.MsgLiquidStake, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgLiquidStake;
            fromPartial(object: Partial<_181.MsgLiquidStake>): _181.MsgLiquidStake;
            fromAmino(object: _181.MsgLiquidStakeAmino): _181.MsgLiquidStake;
            toAmino(message: _181.MsgLiquidStake): _181.MsgLiquidStakeAmino;
            fromAminoMsg(object: _181.MsgLiquidStakeAminoMsg): _181.MsgLiquidStake;
            toAminoMsg(message: _181.MsgLiquidStake): _181.MsgLiquidStakeAminoMsg;
            fromProtoMsg(message: _181.MsgLiquidStakeProtoMsg): _181.MsgLiquidStake;
            toProto(message: _181.MsgLiquidStake): Uint8Array;
            toProtoMsg(message: _181.MsgLiquidStake): _181.MsgLiquidStakeProtoMsg;
        };
        MsgLiquidStakeResponse: {
            typeUrl: string;
            encode(message: _181.MsgLiquidStakeResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgLiquidStakeResponse;
            fromPartial(object: Partial<_181.MsgLiquidStakeResponse>): _181.MsgLiquidStakeResponse;
            fromAmino(object: _181.MsgLiquidStakeResponseAmino): _181.MsgLiquidStakeResponse;
            toAmino(message: _181.MsgLiquidStakeResponse): _181.MsgLiquidStakeResponseAmino;
            fromAminoMsg(object: _181.MsgLiquidStakeResponseAminoMsg): _181.MsgLiquidStakeResponse;
            fromProtoMsg(message: _181.MsgLiquidStakeResponseProtoMsg): _181.MsgLiquidStakeResponse;
            toProto(message: _181.MsgLiquidStakeResponse): Uint8Array;
            toProtoMsg(message: _181.MsgLiquidStakeResponse): _181.MsgLiquidStakeResponseProtoMsg;
        };
        MsgRedeemStake: {
            typeUrl: string;
            encode(message: _181.MsgRedeemStake, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgRedeemStake;
            fromPartial(object: Partial<_181.MsgRedeemStake>): _181.MsgRedeemStake;
            fromAmino(object: _181.MsgRedeemStakeAmino): _181.MsgRedeemStake;
            toAmino(message: _181.MsgRedeemStake): _181.MsgRedeemStakeAmino;
            fromAminoMsg(object: _181.MsgRedeemStakeAminoMsg): _181.MsgRedeemStake;
            toAminoMsg(message: _181.MsgRedeemStake): _181.MsgRedeemStakeAminoMsg;
            fromProtoMsg(message: _181.MsgRedeemStakeProtoMsg): _181.MsgRedeemStake;
            toProto(message: _181.MsgRedeemStake): Uint8Array;
            toProtoMsg(message: _181.MsgRedeemStake): _181.MsgRedeemStakeProtoMsg;
        };
        MsgRedeemStakeResponse: {
            typeUrl: string;
            encode(message: _181.MsgRedeemStakeResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgRedeemStakeResponse;
            fromPartial(object: Partial<_181.MsgRedeemStakeResponse>): _181.MsgRedeemStakeResponse;
            fromAmino(object: _181.MsgRedeemStakeResponseAmino): _181.MsgRedeemStakeResponse;
            toAmino(message: _181.MsgRedeemStakeResponse): _181.MsgRedeemStakeResponseAmino;
            fromAminoMsg(object: _181.MsgRedeemStakeResponseAminoMsg): _181.MsgRedeemStakeResponse;
            fromProtoMsg(message: _181.MsgRedeemStakeResponseProtoMsg): _181.MsgRedeemStakeResponse;
            toProto(message: _181.MsgRedeemStakeResponse): Uint8Array;
            toProtoMsg(message: _181.MsgRedeemStakeResponse): _181.MsgRedeemStakeResponseProtoMsg;
        };
        MsgConfirmDelegation: {
            typeUrl: string;
            encode(message: _181.MsgConfirmDelegation, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgConfirmDelegation;
            fromPartial(object: Partial<_181.MsgConfirmDelegation>): _181.MsgConfirmDelegation;
            fromAmino(object: _181.MsgConfirmDelegationAmino): _181.MsgConfirmDelegation;
            toAmino(message: _181.MsgConfirmDelegation): _181.MsgConfirmDelegationAmino;
            fromAminoMsg(object: _181.MsgConfirmDelegationAminoMsg): _181.MsgConfirmDelegation;
            toAminoMsg(message: _181.MsgConfirmDelegation): _181.MsgConfirmDelegationAminoMsg;
            fromProtoMsg(message: _181.MsgConfirmDelegationProtoMsg): _181.MsgConfirmDelegation;
            toProto(message: _181.MsgConfirmDelegation): Uint8Array;
            toProtoMsg(message: _181.MsgConfirmDelegation): _181.MsgConfirmDelegationProtoMsg;
        };
        MsgConfirmDelegationResponse: {
            typeUrl: string;
            encode(_: _181.MsgConfirmDelegationResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgConfirmDelegationResponse;
            fromPartial(_: Partial<_181.MsgConfirmDelegationResponse>): _181.MsgConfirmDelegationResponse;
            fromAmino(_: _181.MsgConfirmDelegationResponseAmino): _181.MsgConfirmDelegationResponse;
            toAmino(_: _181.MsgConfirmDelegationResponse): _181.MsgConfirmDelegationResponseAmino;
            fromAminoMsg(object: _181.MsgConfirmDelegationResponseAminoMsg): _181.MsgConfirmDelegationResponse;
            fromProtoMsg(message: _181.MsgConfirmDelegationResponseProtoMsg): _181.MsgConfirmDelegationResponse;
            toProto(message: _181.MsgConfirmDelegationResponse): Uint8Array;
            toProtoMsg(message: _181.MsgConfirmDelegationResponse): _181.MsgConfirmDelegationResponseProtoMsg;
        };
        MsgConfirmUndelegation: {
            typeUrl: string;
            encode(message: _181.MsgConfirmUndelegation, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgConfirmUndelegation;
            fromPartial(object: Partial<_181.MsgConfirmUndelegation>): _181.MsgConfirmUndelegation;
            fromAmino(object: _181.MsgConfirmUndelegationAmino): _181.MsgConfirmUndelegation;
            toAmino(message: _181.MsgConfirmUndelegation): _181.MsgConfirmUndelegationAmino;
            fromAminoMsg(object: _181.MsgConfirmUndelegationAminoMsg): _181.MsgConfirmUndelegation;
            toAminoMsg(message: _181.MsgConfirmUndelegation): _181.MsgConfirmUndelegationAminoMsg;
            fromProtoMsg(message: _181.MsgConfirmUndelegationProtoMsg): _181.MsgConfirmUndelegation;
            toProto(message: _181.MsgConfirmUndelegation): Uint8Array;
            toProtoMsg(message: _181.MsgConfirmUndelegation): _181.MsgConfirmUndelegationProtoMsg;
        };
        MsgConfirmUndelegationResponse: {
            typeUrl: string;
            encode(_: _181.MsgConfirmUndelegationResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgConfirmUndelegationResponse;
            fromPartial(_: Partial<_181.MsgConfirmUndelegationResponse>): _181.MsgConfirmUndelegationResponse;
            fromAmino(_: _181.MsgConfirmUndelegationResponseAmino): _181.MsgConfirmUndelegationResponse;
            toAmino(_: _181.MsgConfirmUndelegationResponse): _181.MsgConfirmUndelegationResponseAmino;
            fromAminoMsg(object: _181.MsgConfirmUndelegationResponseAminoMsg): _181.MsgConfirmUndelegationResponse;
            fromProtoMsg(message: _181.MsgConfirmUndelegationResponseProtoMsg): _181.MsgConfirmUndelegationResponse;
            toProto(message: _181.MsgConfirmUndelegationResponse): Uint8Array;
            toProtoMsg(message: _181.MsgConfirmUndelegationResponse): _181.MsgConfirmUndelegationResponseProtoMsg;
        };
        MsgConfirmUnbondedTokenSweep: {
            typeUrl: string;
            encode(message: _181.MsgConfirmUnbondedTokenSweep, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgConfirmUnbondedTokenSweep;
            fromPartial(object: Partial<_181.MsgConfirmUnbondedTokenSweep>): _181.MsgConfirmUnbondedTokenSweep;
            fromAmino(object: _181.MsgConfirmUnbondedTokenSweepAmino): _181.MsgConfirmUnbondedTokenSweep;
            toAmino(message: _181.MsgConfirmUnbondedTokenSweep): _181.MsgConfirmUnbondedTokenSweepAmino;
            fromAminoMsg(object: _181.MsgConfirmUnbondedTokenSweepAminoMsg): _181.MsgConfirmUnbondedTokenSweep;
            toAminoMsg(message: _181.MsgConfirmUnbondedTokenSweep): _181.MsgConfirmUnbondedTokenSweepAminoMsg;
            fromProtoMsg(message: _181.MsgConfirmUnbondedTokenSweepProtoMsg): _181.MsgConfirmUnbondedTokenSweep;
            toProto(message: _181.MsgConfirmUnbondedTokenSweep): Uint8Array;
            toProtoMsg(message: _181.MsgConfirmUnbondedTokenSweep): _181.MsgConfirmUnbondedTokenSweepProtoMsg;
        };
        MsgConfirmUnbondedTokenSweepResponse: {
            typeUrl: string;
            encode(_: _181.MsgConfirmUnbondedTokenSweepResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgConfirmUnbondedTokenSweepResponse;
            fromPartial(_: Partial<_181.MsgConfirmUnbondedTokenSweepResponse>): _181.MsgConfirmUnbondedTokenSweepResponse;
            fromAmino(_: _181.MsgConfirmUnbondedTokenSweepResponseAmino): _181.MsgConfirmUnbondedTokenSweepResponse;
            toAmino(_: _181.MsgConfirmUnbondedTokenSweepResponse): _181.MsgConfirmUnbondedTokenSweepResponseAmino;
            fromAminoMsg(object: _181.MsgConfirmUnbondedTokenSweepResponseAminoMsg): _181.MsgConfirmUnbondedTokenSweepResponse;
            fromProtoMsg(message: _181.MsgConfirmUnbondedTokenSweepResponseProtoMsg): _181.MsgConfirmUnbondedTokenSweepResponse;
            toProto(message: _181.MsgConfirmUnbondedTokenSweepResponse): Uint8Array;
            toProtoMsg(message: _181.MsgConfirmUnbondedTokenSweepResponse): _181.MsgConfirmUnbondedTokenSweepResponseProtoMsg;
        };
        MsgAdjustDelegatedBalance: {
            typeUrl: string;
            encode(message: _181.MsgAdjustDelegatedBalance, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgAdjustDelegatedBalance;
            fromPartial(object: Partial<_181.MsgAdjustDelegatedBalance>): _181.MsgAdjustDelegatedBalance;
            fromAmino(object: _181.MsgAdjustDelegatedBalanceAmino): _181.MsgAdjustDelegatedBalance;
            toAmino(message: _181.MsgAdjustDelegatedBalance): _181.MsgAdjustDelegatedBalanceAmino;
            fromAminoMsg(object: _181.MsgAdjustDelegatedBalanceAminoMsg): _181.MsgAdjustDelegatedBalance;
            toAminoMsg(message: _181.MsgAdjustDelegatedBalance): _181.MsgAdjustDelegatedBalanceAminoMsg;
            fromProtoMsg(message: _181.MsgAdjustDelegatedBalanceProtoMsg): _181.MsgAdjustDelegatedBalance;
            toProto(message: _181.MsgAdjustDelegatedBalance): Uint8Array;
            toProtoMsg(message: _181.MsgAdjustDelegatedBalance): _181.MsgAdjustDelegatedBalanceProtoMsg;
        };
        MsgAdjustDelegatedBalanceResponse: {
            typeUrl: string;
            encode(_: _181.MsgAdjustDelegatedBalanceResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgAdjustDelegatedBalanceResponse;
            fromPartial(_: Partial<_181.MsgAdjustDelegatedBalanceResponse>): _181.MsgAdjustDelegatedBalanceResponse;
            fromAmino(_: _181.MsgAdjustDelegatedBalanceResponseAmino): _181.MsgAdjustDelegatedBalanceResponse;
            toAmino(_: _181.MsgAdjustDelegatedBalanceResponse): _181.MsgAdjustDelegatedBalanceResponseAmino;
            fromAminoMsg(object: _181.MsgAdjustDelegatedBalanceResponseAminoMsg): _181.MsgAdjustDelegatedBalanceResponse;
            fromProtoMsg(message: _181.MsgAdjustDelegatedBalanceResponseProtoMsg): _181.MsgAdjustDelegatedBalanceResponse;
            toProto(message: _181.MsgAdjustDelegatedBalanceResponse): Uint8Array;
            toProtoMsg(message: _181.MsgAdjustDelegatedBalanceResponse): _181.MsgAdjustDelegatedBalanceResponseProtoMsg;
        };
        MsgUpdateInnerRedemptionRateBounds: {
            typeUrl: string;
            encode(message: _181.MsgUpdateInnerRedemptionRateBounds, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgUpdateInnerRedemptionRateBounds;
            fromPartial(object: Partial<_181.MsgUpdateInnerRedemptionRateBounds>): _181.MsgUpdateInnerRedemptionRateBounds;
            fromAmino(object: _181.MsgUpdateInnerRedemptionRateBoundsAmino): _181.MsgUpdateInnerRedemptionRateBounds;
            toAmino(message: _181.MsgUpdateInnerRedemptionRateBounds): _181.MsgUpdateInnerRedemptionRateBoundsAmino;
            fromAminoMsg(object: _181.MsgUpdateInnerRedemptionRateBoundsAminoMsg): _181.MsgUpdateInnerRedemptionRateBounds;
            toAminoMsg(message: _181.MsgUpdateInnerRedemptionRateBounds): _181.MsgUpdateInnerRedemptionRateBoundsAminoMsg;
            fromProtoMsg(message: _181.MsgUpdateInnerRedemptionRateBoundsProtoMsg): _181.MsgUpdateInnerRedemptionRateBounds;
            toProto(message: _181.MsgUpdateInnerRedemptionRateBounds): Uint8Array;
            toProtoMsg(message: _181.MsgUpdateInnerRedemptionRateBounds): _181.MsgUpdateInnerRedemptionRateBoundsProtoMsg;
        };
        MsgUpdateInnerRedemptionRateBoundsResponse: {
            typeUrl: string;
            encode(_: _181.MsgUpdateInnerRedemptionRateBoundsResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromPartial(_: Partial<_181.MsgUpdateInnerRedemptionRateBoundsResponse>): _181.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromAmino(_: _181.MsgUpdateInnerRedemptionRateBoundsResponseAmino): _181.MsgUpdateInnerRedemptionRateBoundsResponse;
            toAmino(_: _181.MsgUpdateInnerRedemptionRateBoundsResponse): _181.MsgUpdateInnerRedemptionRateBoundsResponseAmino;
            fromAminoMsg(object: _181.MsgUpdateInnerRedemptionRateBoundsResponseAminoMsg): _181.MsgUpdateInnerRedemptionRateBoundsResponse;
            fromProtoMsg(message: _181.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg): _181.MsgUpdateInnerRedemptionRateBoundsResponse;
            toProto(message: _181.MsgUpdateInnerRedemptionRateBoundsResponse): Uint8Array;
            toProtoMsg(message: _181.MsgUpdateInnerRedemptionRateBoundsResponse): _181.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg;
        };
        MsgResumeHostZone: {
            typeUrl: string;
            encode(message: _181.MsgResumeHostZone, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgResumeHostZone;
            fromPartial(object: Partial<_181.MsgResumeHostZone>): _181.MsgResumeHostZone;
            fromAmino(object: _181.MsgResumeHostZoneAmino): _181.MsgResumeHostZone;
            toAmino(message: _181.MsgResumeHostZone): _181.MsgResumeHostZoneAmino;
            fromAminoMsg(object: _181.MsgResumeHostZoneAminoMsg): _181.MsgResumeHostZone;
            toAminoMsg(message: _181.MsgResumeHostZone): _181.MsgResumeHostZoneAminoMsg;
            fromProtoMsg(message: _181.MsgResumeHostZoneProtoMsg): _181.MsgResumeHostZone;
            toProto(message: _181.MsgResumeHostZone): Uint8Array;
            toProtoMsg(message: _181.MsgResumeHostZone): _181.MsgResumeHostZoneProtoMsg;
        };
        MsgResumeHostZoneResponse: {
            typeUrl: string;
            encode(_: _181.MsgResumeHostZoneResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgResumeHostZoneResponse;
            fromPartial(_: Partial<_181.MsgResumeHostZoneResponse>): _181.MsgResumeHostZoneResponse;
            fromAmino(_: _181.MsgResumeHostZoneResponseAmino): _181.MsgResumeHostZoneResponse;
            toAmino(_: _181.MsgResumeHostZoneResponse): _181.MsgResumeHostZoneResponseAmino;
            fromAminoMsg(object: _181.MsgResumeHostZoneResponseAminoMsg): _181.MsgResumeHostZoneResponse;
            fromProtoMsg(message: _181.MsgResumeHostZoneResponseProtoMsg): _181.MsgResumeHostZoneResponse;
            toProto(message: _181.MsgResumeHostZoneResponse): Uint8Array;
            toProtoMsg(message: _181.MsgResumeHostZoneResponse): _181.MsgResumeHostZoneResponseProtoMsg;
        };
        MsgRefreshRedemptionRate: {
            typeUrl: string;
            encode(message: _181.MsgRefreshRedemptionRate, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgRefreshRedemptionRate;
            fromPartial(object: Partial<_181.MsgRefreshRedemptionRate>): _181.MsgRefreshRedemptionRate;
            fromAmino(object: _181.MsgRefreshRedemptionRateAmino): _181.MsgRefreshRedemptionRate;
            toAmino(message: _181.MsgRefreshRedemptionRate): _181.MsgRefreshRedemptionRateAmino;
            fromAminoMsg(object: _181.MsgRefreshRedemptionRateAminoMsg): _181.MsgRefreshRedemptionRate;
            toAminoMsg(message: _181.MsgRefreshRedemptionRate): _181.MsgRefreshRedemptionRateAminoMsg;
            fromProtoMsg(message: _181.MsgRefreshRedemptionRateProtoMsg): _181.MsgRefreshRedemptionRate;
            toProto(message: _181.MsgRefreshRedemptionRate): Uint8Array;
            toProtoMsg(message: _181.MsgRefreshRedemptionRate): _181.MsgRefreshRedemptionRateProtoMsg;
        };
        MsgRefreshRedemptionRateResponse: {
            typeUrl: string;
            encode(_: _181.MsgRefreshRedemptionRateResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgRefreshRedemptionRateResponse;
            fromPartial(_: Partial<_181.MsgRefreshRedemptionRateResponse>): _181.MsgRefreshRedemptionRateResponse;
            fromAmino(_: _181.MsgRefreshRedemptionRateResponseAmino): _181.MsgRefreshRedemptionRateResponse;
            toAmino(_: _181.MsgRefreshRedemptionRateResponse): _181.MsgRefreshRedemptionRateResponseAmino;
            fromAminoMsg(object: _181.MsgRefreshRedemptionRateResponseAminoMsg): _181.MsgRefreshRedemptionRateResponse;
            fromProtoMsg(message: _181.MsgRefreshRedemptionRateResponseProtoMsg): _181.MsgRefreshRedemptionRateResponse;
            toProto(message: _181.MsgRefreshRedemptionRateResponse): Uint8Array;
            toProtoMsg(message: _181.MsgRefreshRedemptionRateResponse): _181.MsgRefreshRedemptionRateResponseProtoMsg;
        };
        MsgOverwriteDelegationRecord: {
            typeUrl: string;
            encode(message: _181.MsgOverwriteDelegationRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgOverwriteDelegationRecord;
            fromPartial(object: Partial<_181.MsgOverwriteDelegationRecord>): _181.MsgOverwriteDelegationRecord;
            fromAmino(object: _181.MsgOverwriteDelegationRecordAmino): _181.MsgOverwriteDelegationRecord;
            toAmino(message: _181.MsgOverwriteDelegationRecord): _181.MsgOverwriteDelegationRecordAmino;
            fromAminoMsg(object: _181.MsgOverwriteDelegationRecordAminoMsg): _181.MsgOverwriteDelegationRecord;
            toAminoMsg(message: _181.MsgOverwriteDelegationRecord): _181.MsgOverwriteDelegationRecordAminoMsg;
            fromProtoMsg(message: _181.MsgOverwriteDelegationRecordProtoMsg): _181.MsgOverwriteDelegationRecord;
            toProto(message: _181.MsgOverwriteDelegationRecord): Uint8Array;
            toProtoMsg(message: _181.MsgOverwriteDelegationRecord): _181.MsgOverwriteDelegationRecordProtoMsg;
        };
        MsgOverwriteDelegationRecordResponse: {
            typeUrl: string;
            encode(_: _181.MsgOverwriteDelegationRecordResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgOverwriteDelegationRecordResponse;
            fromPartial(_: Partial<_181.MsgOverwriteDelegationRecordResponse>): _181.MsgOverwriteDelegationRecordResponse;
            fromAmino(_: _181.MsgOverwriteDelegationRecordResponseAmino): _181.MsgOverwriteDelegationRecordResponse;
            toAmino(_: _181.MsgOverwriteDelegationRecordResponse): _181.MsgOverwriteDelegationRecordResponseAmino;
            fromAminoMsg(object: _181.MsgOverwriteDelegationRecordResponseAminoMsg): _181.MsgOverwriteDelegationRecordResponse;
            fromProtoMsg(message: _181.MsgOverwriteDelegationRecordResponseProtoMsg): _181.MsgOverwriteDelegationRecordResponse;
            toProto(message: _181.MsgOverwriteDelegationRecordResponse): Uint8Array;
            toProtoMsg(message: _181.MsgOverwriteDelegationRecordResponse): _181.MsgOverwriteDelegationRecordResponseProtoMsg;
        };
        MsgOverwriteUnbondingRecord: {
            typeUrl: string;
            encode(message: _181.MsgOverwriteUnbondingRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgOverwriteUnbondingRecord;
            fromPartial(object: Partial<_181.MsgOverwriteUnbondingRecord>): _181.MsgOverwriteUnbondingRecord;
            fromAmino(object: _181.MsgOverwriteUnbondingRecordAmino): _181.MsgOverwriteUnbondingRecord;
            toAmino(message: _181.MsgOverwriteUnbondingRecord): _181.MsgOverwriteUnbondingRecordAmino;
            fromAminoMsg(object: _181.MsgOverwriteUnbondingRecordAminoMsg): _181.MsgOverwriteUnbondingRecord;
            toAminoMsg(message: _181.MsgOverwriteUnbondingRecord): _181.MsgOverwriteUnbondingRecordAminoMsg;
            fromProtoMsg(message: _181.MsgOverwriteUnbondingRecordProtoMsg): _181.MsgOverwriteUnbondingRecord;
            toProto(message: _181.MsgOverwriteUnbondingRecord): Uint8Array;
            toProtoMsg(message: _181.MsgOverwriteUnbondingRecord): _181.MsgOverwriteUnbondingRecordProtoMsg;
        };
        MsgOverwriteUnbondingRecordResponse: {
            typeUrl: string;
            encode(_: _181.MsgOverwriteUnbondingRecordResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgOverwriteUnbondingRecordResponse;
            fromPartial(_: Partial<_181.MsgOverwriteUnbondingRecordResponse>): _181.MsgOverwriteUnbondingRecordResponse;
            fromAmino(_: _181.MsgOverwriteUnbondingRecordResponseAmino): _181.MsgOverwriteUnbondingRecordResponse;
            toAmino(_: _181.MsgOverwriteUnbondingRecordResponse): _181.MsgOverwriteUnbondingRecordResponseAmino;
            fromAminoMsg(object: _181.MsgOverwriteUnbondingRecordResponseAminoMsg): _181.MsgOverwriteUnbondingRecordResponse;
            fromProtoMsg(message: _181.MsgOverwriteUnbondingRecordResponseProtoMsg): _181.MsgOverwriteUnbondingRecordResponse;
            toProto(message: _181.MsgOverwriteUnbondingRecordResponse): Uint8Array;
            toProtoMsg(message: _181.MsgOverwriteUnbondingRecordResponse): _181.MsgOverwriteUnbondingRecordResponseProtoMsg;
        };
        MsgOverwriteRedemptionRecord: {
            typeUrl: string;
            encode(message: _181.MsgOverwriteRedemptionRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgOverwriteRedemptionRecord;
            fromPartial(object: Partial<_181.MsgOverwriteRedemptionRecord>): _181.MsgOverwriteRedemptionRecord;
            fromAmino(object: _181.MsgOverwriteRedemptionRecordAmino): _181.MsgOverwriteRedemptionRecord;
            toAmino(message: _181.MsgOverwriteRedemptionRecord): _181.MsgOverwriteRedemptionRecordAmino;
            fromAminoMsg(object: _181.MsgOverwriteRedemptionRecordAminoMsg): _181.MsgOverwriteRedemptionRecord;
            toAminoMsg(message: _181.MsgOverwriteRedemptionRecord): _181.MsgOverwriteRedemptionRecordAminoMsg;
            fromProtoMsg(message: _181.MsgOverwriteRedemptionRecordProtoMsg): _181.MsgOverwriteRedemptionRecord;
            toProto(message: _181.MsgOverwriteRedemptionRecord): Uint8Array;
            toProtoMsg(message: _181.MsgOverwriteRedemptionRecord): _181.MsgOverwriteRedemptionRecordProtoMsg;
        };
        MsgOverwriteRedemptionRecordResponse: {
            typeUrl: string;
            encode(_: _181.MsgOverwriteRedemptionRecordResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgOverwriteRedemptionRecordResponse;
            fromPartial(_: Partial<_181.MsgOverwriteRedemptionRecordResponse>): _181.MsgOverwriteRedemptionRecordResponse;
            fromAmino(_: _181.MsgOverwriteRedemptionRecordResponseAmino): _181.MsgOverwriteRedemptionRecordResponse;
            toAmino(_: _181.MsgOverwriteRedemptionRecordResponse): _181.MsgOverwriteRedemptionRecordResponseAmino;
            fromAminoMsg(object: _181.MsgOverwriteRedemptionRecordResponseAminoMsg): _181.MsgOverwriteRedemptionRecordResponse;
            fromProtoMsg(message: _181.MsgOverwriteRedemptionRecordResponseProtoMsg): _181.MsgOverwriteRedemptionRecordResponse;
            toProto(message: _181.MsgOverwriteRedemptionRecordResponse): Uint8Array;
            toProtoMsg(message: _181.MsgOverwriteRedemptionRecordResponse): _181.MsgOverwriteRedemptionRecordResponseProtoMsg;
        };
        MsgSetOperatorAddress: {
            typeUrl: string;
            encode(message: _181.MsgSetOperatorAddress, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgSetOperatorAddress;
            fromPartial(object: Partial<_181.MsgSetOperatorAddress>): _181.MsgSetOperatorAddress;
            fromAmino(object: _181.MsgSetOperatorAddressAmino): _181.MsgSetOperatorAddress;
            toAmino(message: _181.MsgSetOperatorAddress): _181.MsgSetOperatorAddressAmino;
            fromAminoMsg(object: _181.MsgSetOperatorAddressAminoMsg): _181.MsgSetOperatorAddress;
            toAminoMsg(message: _181.MsgSetOperatorAddress): _181.MsgSetOperatorAddressAminoMsg;
            fromProtoMsg(message: _181.MsgSetOperatorAddressProtoMsg): _181.MsgSetOperatorAddress;
            toProto(message: _181.MsgSetOperatorAddress): Uint8Array;
            toProtoMsg(message: _181.MsgSetOperatorAddress): _181.MsgSetOperatorAddressProtoMsg;
        };
        MsgSetOperatorAddressResponse: {
            typeUrl: string;
            encode(_: _181.MsgSetOperatorAddressResponse, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _181.MsgSetOperatorAddressResponse;
            fromPartial(_: Partial<_181.MsgSetOperatorAddressResponse>): _181.MsgSetOperatorAddressResponse;
            fromAmino(_: _181.MsgSetOperatorAddressResponseAmino): _181.MsgSetOperatorAddressResponse;
            toAmino(_: _181.MsgSetOperatorAddressResponse): _181.MsgSetOperatorAddressResponseAmino;
            fromAminoMsg(object: _181.MsgSetOperatorAddressResponseAminoMsg): _181.MsgSetOperatorAddressResponse;
            fromProtoMsg(message: _181.MsgSetOperatorAddressResponseProtoMsg): _181.MsgSetOperatorAddressResponse;
            toProto(message: _181.MsgSetOperatorAddressResponse): Uint8Array;
            toProtoMsg(message: _181.MsgSetOperatorAddressResponse): _181.MsgSetOperatorAddressResponseProtoMsg;
        };
        delegationRecordStatusFromJSON(object: any): _180.DelegationRecordStatus;
        delegationRecordStatusToJSON(object: _180.DelegationRecordStatus): string;
        unbondingRecordStatusFromJSON(object: any): _180.UnbondingRecordStatus;
        unbondingRecordStatusToJSON(object: _180.UnbondingRecordStatus): string;
        DelegationRecordStatus: typeof _180.DelegationRecordStatus;
        DelegationRecordStatusSDKType: typeof _180.DelegationRecordStatus;
        DelegationRecordStatusAmino: typeof _180.DelegationRecordStatus;
        UnbondingRecordStatus: typeof _180.UnbondingRecordStatus;
        UnbondingRecordStatusSDKType: typeof _180.UnbondingRecordStatus;
        UnbondingRecordStatusAmino: typeof _180.UnbondingRecordStatus;
        HostZone: {
            typeUrl: string;
            encode(message: _180.HostZone, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _180.HostZone;
            fromPartial(object: Partial<_180.HostZone>): _180.HostZone;
            fromAmino(object: _180.HostZoneAmino): _180.HostZone;
            toAmino(message: _180.HostZone): _180.HostZoneAmino;
            fromAminoMsg(object: _180.HostZoneAminoMsg): _180.HostZone;
            fromProtoMsg(message: _180.HostZoneProtoMsg): _180.HostZone;
            toProto(message: _180.HostZone): Uint8Array;
            toProtoMsg(message: _180.HostZone): _180.HostZoneProtoMsg;
        };
        DelegationRecord: {
            typeUrl: string;
            encode(message: _180.DelegationRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _180.DelegationRecord;
            fromPartial(object: Partial<_180.DelegationRecord>): _180.DelegationRecord;
            fromAmino(object: _180.DelegationRecordAmino): _180.DelegationRecord;
            toAmino(message: _180.DelegationRecord): _180.DelegationRecordAmino;
            fromAminoMsg(object: _180.DelegationRecordAminoMsg): _180.DelegationRecord;
            fromProtoMsg(message: _180.DelegationRecordProtoMsg): _180.DelegationRecord;
            toProto(message: _180.DelegationRecord): Uint8Array;
            toProtoMsg(message: _180.DelegationRecord): _180.DelegationRecordProtoMsg;
        };
        UnbondingRecord: {
            typeUrl: string;
            encode(message: _180.UnbondingRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _180.UnbondingRecord;
            fromPartial(object: Partial<_180.UnbondingRecord>): _180.UnbondingRecord;
            fromAmino(object: _180.UnbondingRecordAmino): _180.UnbondingRecord;
            toAmino(message: _180.UnbondingRecord): _180.UnbondingRecordAmino;
            fromAminoMsg(object: _180.UnbondingRecordAminoMsg): _180.UnbondingRecord;
            fromProtoMsg(message: _180.UnbondingRecordProtoMsg): _180.UnbondingRecord;
            toProto(message: _180.UnbondingRecord): Uint8Array;
            toProtoMsg(message: _180.UnbondingRecord): _180.UnbondingRecordProtoMsg;
        };
        RedemptionRecord: {
            typeUrl: string;
            encode(message: _180.RedemptionRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _180.RedemptionRecord;
            fromPartial(object: Partial<_180.RedemptionRecord>): _180.RedemptionRecord;
            fromAmino(object: _180.RedemptionRecordAmino): _180.RedemptionRecord;
            toAmino(message: _180.RedemptionRecord): _180.RedemptionRecordAmino;
            fromAminoMsg(object: _180.RedemptionRecordAminoMsg): _180.RedemptionRecord;
            fromProtoMsg(message: _180.RedemptionRecordProtoMsg): _180.RedemptionRecord;
            toProto(message: _180.RedemptionRecord): Uint8Array;
            toProtoMsg(message: _180.RedemptionRecord): _180.RedemptionRecordProtoMsg;
        };
        SlashRecord: {
            typeUrl: string;
            encode(message: _180.SlashRecord, writer?: import("../../../binary").BinaryWriter): import("../../../binary").BinaryWriter;
            decode(input: Uint8Array | import("../../../binary").BinaryReader, length?: number | undefined): _180.SlashRecord;
            fromPartial(object: Partial<_180.SlashRecord>): _180.SlashRecord;
            fromAmino(object: _180.SlashRecordAmino): _180.SlashRecord;
            toAmino(message: _180.SlashRecord): _180.SlashRecordAmino;
            fromAminoMsg(object: _180.SlashRecordAminoMsg): _180.SlashRecord;
            fromProtoMsg(message: _180.SlashRecordProtoMsg): _180.SlashRecord;
            toProto(message: _180.SlashRecord): Uint8Array;
            toProtoMsg(message: _180.SlashRecord): _180.SlashRecordProtoMsg;
        };
    };
}
