@agoric/cosmic-proto 0.4.1-orchestration-dev-096c4e8.0 → 0.4.1-other-dev-fbe72e7.0.fbe72e7

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

@@ -0,0 +1,2608 @@
+import * as _173 from './epochs/genesis.js';
+import * as _174 from './epochs/query.js';
+import * as _175 from './records/callbacks.js';
+import * as _176 from './records/genesis.js';
+import * as _177 from './records/params.js';
+import * as _178 from './records/query.js';
+import * as _179 from './records/records.js';
+import * as _180 from './stakedym/genesis.js';
+import * as _181 from './stakedym/query.js';
+import * as _182 from './stakedym/stakedym.js';
+import * as _183 from './stakedym/tx.js';
+import * as _184 from './stakeibc/address_unbonding.js';
+import * as _185 from './stakeibc/callbacks.js';
+import * as _186 from './stakeibc/epoch_tracker.js';
+import * as _187 from './stakeibc/genesis.js';
+import * as _188 from './stakeibc/gov.js';
+import * as _189 from './stakeibc/host_zone.js';
+import * as _190 from './stakeibc/ica_account.js';
+import * as _191 from './stakeibc/packet.js';
+import * as _192 from './stakeibc/params.js';
+import * as _193 from './stakeibc/query.js';
+import * as _194 from './stakeibc/trade_route.js';
+import * as _195 from './stakeibc/tx.js';
+import * as _196 from './stakeibc/validator.js';
+import * as _197 from './staketia/genesis.js';
+import * as _198 from './staketia/query.js';
+import * as _199 from './staketia/staketia.js';
+import * as _200 from './staketia/tx.js';
+export declare namespace stride {
+    const epochs: {
+        QueryEpochsInfoRequest: {
+            typeUrl: "/stride.epochs.QueryEpochsInfoRequest";
+            encode(message: _174.QueryEpochsInfoRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryEpochsInfoRequest;
+            fromJSON(object: any): _174.QueryEpochsInfoRequest;
+            toJSON(message: _174.QueryEpochsInfoRequest): import("../json-safe.ts").JsonSafe<_174.QueryEpochsInfoRequest>;
+            fromPartial(object: Partial<_174.QueryEpochsInfoRequest>): _174.QueryEpochsInfoRequest;
+            fromProtoMsg(message: _174.QueryEpochsInfoRequestProtoMsg): _174.QueryEpochsInfoRequest;
+            toProto(message: _174.QueryEpochsInfoRequest): Uint8Array;
+            toProtoMsg(message: _174.QueryEpochsInfoRequest): _174.QueryEpochsInfoRequestProtoMsg;
+        };
+        QueryEpochsInfoResponse: {
+            typeUrl: "/stride.epochs.QueryEpochsInfoResponse";
+            encode(message: _174.QueryEpochsInfoResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryEpochsInfoResponse;
+            fromJSON(object: any): _174.QueryEpochsInfoResponse;
+            toJSON(message: _174.QueryEpochsInfoResponse): import("../json-safe.ts").JsonSafe<_174.QueryEpochsInfoResponse>;
+            fromPartial(object: Partial<_174.QueryEpochsInfoResponse>): _174.QueryEpochsInfoResponse;
+            fromProtoMsg(message: _174.QueryEpochsInfoResponseProtoMsg): _174.QueryEpochsInfoResponse;
+            toProto(message: _174.QueryEpochsInfoResponse): Uint8Array;
+            toProtoMsg(message: _174.QueryEpochsInfoResponse): _174.QueryEpochsInfoResponseProtoMsg;
+        };
+        QueryCurrentEpochRequest: {
+            typeUrl: "/stride.epochs.QueryCurrentEpochRequest";
+            encode(message: _174.QueryCurrentEpochRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryCurrentEpochRequest;
+            fromJSON(object: any): _174.QueryCurrentEpochRequest;
+            toJSON(message: _174.QueryCurrentEpochRequest): import("../json-safe.ts").JsonSafe<_174.QueryCurrentEpochRequest>;
+            fromPartial(object: Partial<_174.QueryCurrentEpochRequest>): _174.QueryCurrentEpochRequest;
+            fromProtoMsg(message: _174.QueryCurrentEpochRequestProtoMsg): _174.QueryCurrentEpochRequest;
+            toProto(message: _174.QueryCurrentEpochRequest): Uint8Array;
+            toProtoMsg(message: _174.QueryCurrentEpochRequest): _174.QueryCurrentEpochRequestProtoMsg;
+        };
+        QueryCurrentEpochResponse: {
+            typeUrl: "/stride.epochs.QueryCurrentEpochResponse";
+            encode(message: _174.QueryCurrentEpochResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryCurrentEpochResponse;
+            fromJSON(object: any): _174.QueryCurrentEpochResponse;
+            toJSON(message: _174.QueryCurrentEpochResponse): import("../json-safe.ts").JsonSafe<_174.QueryCurrentEpochResponse>;
+            fromPartial(object: Partial<_174.QueryCurrentEpochResponse>): _174.QueryCurrentEpochResponse;
+            fromProtoMsg(message: _174.QueryCurrentEpochResponseProtoMsg): _174.QueryCurrentEpochResponse;
+            toProto(message: _174.QueryCurrentEpochResponse): Uint8Array;
+            toProtoMsg(message: _174.QueryCurrentEpochResponse): _174.QueryCurrentEpochResponseProtoMsg;
+        };
+        QueryEpochInfoRequest: {
+            typeUrl: "/stride.epochs.QueryEpochInfoRequest";
+            encode(message: _174.QueryEpochInfoRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryEpochInfoRequest;
+            fromJSON(object: any): _174.QueryEpochInfoRequest;
+            toJSON(message: _174.QueryEpochInfoRequest): import("../json-safe.ts").JsonSafe<_174.QueryEpochInfoRequest>;
+            fromPartial(object: Partial<_174.QueryEpochInfoRequest>): _174.QueryEpochInfoRequest;
+            fromProtoMsg(message: _174.QueryEpochInfoRequestProtoMsg): _174.QueryEpochInfoRequest;
+            toProto(message: _174.QueryEpochInfoRequest): Uint8Array;
+            toProtoMsg(message: _174.QueryEpochInfoRequest): _174.QueryEpochInfoRequestProtoMsg;
+        };
+        QueryEpochInfoResponse: {
+            typeUrl: "/stride.epochs.QueryEpochInfoResponse";
+            encode(message: _174.QueryEpochInfoResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryEpochInfoResponse;
+            fromJSON(object: any): _174.QueryEpochInfoResponse;
+            toJSON(message: _174.QueryEpochInfoResponse): import("../json-safe.ts").JsonSafe<_174.QueryEpochInfoResponse>;
+            fromPartial(object: Partial<_174.QueryEpochInfoResponse>): _174.QueryEpochInfoResponse;
+            fromProtoMsg(message: _174.QueryEpochInfoResponseProtoMsg): _174.QueryEpochInfoResponse;
+            toProto(message: _174.QueryEpochInfoResponse): Uint8Array;
+            toProtoMsg(message: _174.QueryEpochInfoResponse): _174.QueryEpochInfoResponseProtoMsg;
+        };
+        EpochInfo: {
+            typeUrl: "/stride.epochs.EpochInfo";
+            encode(message: _173.EpochInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _173.EpochInfo;
+            fromJSON(object: any): _173.EpochInfo;
+            toJSON(message: _173.EpochInfo): import("../json-safe.ts").JsonSafe<_173.EpochInfo>;
+            fromPartial(object: Partial<_173.EpochInfo>): _173.EpochInfo;
+            fromProtoMsg(message: _173.EpochInfoProtoMsg): _173.EpochInfo;
+            toProto(message: _173.EpochInfo): Uint8Array;
+            toProtoMsg(message: _173.EpochInfo): _173.EpochInfoProtoMsg;
+        };
+        GenesisState: {
+            typeUrl: "/stride.epochs.GenesisState";
+            encode(message: _173.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _173.GenesisState;
+            fromJSON(object: any): _173.GenesisState;
+            toJSON(message: _173.GenesisState): import("../json-safe.ts").JsonSafe<_173.GenesisState>;
+            fromPartial(object: Partial<_173.GenesisState>): _173.GenesisState;
+            fromProtoMsg(message: _173.GenesisStateProtoMsg): _173.GenesisState;
+            toProto(message: _173.GenesisState): Uint8Array;
+            toProtoMsg(message: _173.GenesisState): _173.GenesisStateProtoMsg;
+        };
+    };
+    const records: {
+        depositRecord_StatusFromJSON(object: any): _179.DepositRecord_Status;
+        depositRecord_StatusToJSON(object: _179.DepositRecord_Status): string;
+        depositRecord_SourceFromJSON(object: any): _179.DepositRecord_Source;
+        depositRecord_SourceToJSON(object: _179.DepositRecord_Source): string;
+        hostZoneUnbonding_StatusFromJSON(object: any): _179.HostZoneUnbonding_Status;
+        hostZoneUnbonding_StatusToJSON(object: _179.HostZoneUnbonding_Status): string;
+        lSMTokenDeposit_StatusFromJSON(object: any): _179.LSMTokenDeposit_Status;
+        lSMTokenDeposit_StatusToJSON(object: _179.LSMTokenDeposit_Status): string;
+        DepositRecord_Status: typeof _179.DepositRecord_Status;
+        DepositRecord_StatusSDKType: typeof _179.DepositRecord_Status;
+        DepositRecord_Source: typeof _179.DepositRecord_Source;
+        DepositRecord_SourceSDKType: typeof _179.DepositRecord_Source;
+        HostZoneUnbonding_Status: typeof _179.HostZoneUnbonding_Status;
+        HostZoneUnbonding_StatusSDKType: typeof _179.HostZoneUnbonding_Status;
+        LSMTokenDeposit_Status: typeof _179.LSMTokenDeposit_Status;
+        LSMTokenDeposit_StatusSDKType: typeof _179.LSMTokenDeposit_Status;
+        UserRedemptionRecord: {
+            typeUrl: "/stride.records.UserRedemptionRecord";
+            encode(message: _179.UserRedemptionRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _179.UserRedemptionRecord;
+            fromJSON(object: any): _179.UserRedemptionRecord;
+            toJSON(message: _179.UserRedemptionRecord): import("../json-safe.ts").JsonSafe<_179.UserRedemptionRecord>;
+            fromPartial(object: Partial<_179.UserRedemptionRecord>): _179.UserRedemptionRecord;
+            fromProtoMsg(message: _179.UserRedemptionRecordProtoMsg): _179.UserRedemptionRecord;
+            toProto(message: _179.UserRedemptionRecord): Uint8Array;
+            toProtoMsg(message: _179.UserRedemptionRecord): _179.UserRedemptionRecordProtoMsg;
+        };
+        DepositRecord: {
+            typeUrl: "/stride.records.DepositRecord";
+            encode(message: _179.DepositRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _179.DepositRecord;
+            fromJSON(object: any): _179.DepositRecord;
+            toJSON(message: _179.DepositRecord): import("../json-safe.ts").JsonSafe<_179.DepositRecord>;
+            fromPartial(object: Partial<_179.DepositRecord>): _179.DepositRecord;
+            fromProtoMsg(message: _179.DepositRecordProtoMsg): _179.DepositRecord;
+            toProto(message: _179.DepositRecord): Uint8Array;
+            toProtoMsg(message: _179.DepositRecord): _179.DepositRecordProtoMsg;
+        };
+        HostZoneUnbonding: {
+            typeUrl: "/stride.records.HostZoneUnbonding";
+            encode(message: _179.HostZoneUnbonding, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _179.HostZoneUnbonding;
+            fromJSON(object: any): _179.HostZoneUnbonding;
+            toJSON(message: _179.HostZoneUnbonding): import("../json-safe.ts").JsonSafe<_179.HostZoneUnbonding>;
+            fromPartial(object: Partial<_179.HostZoneUnbonding>): _179.HostZoneUnbonding;
+            fromProtoMsg(message: _179.HostZoneUnbondingProtoMsg): _179.HostZoneUnbonding;
+            toProto(message: _179.HostZoneUnbonding): Uint8Array;
+            toProtoMsg(message: _179.HostZoneUnbonding): _179.HostZoneUnbondingProtoMsg;
+        };
+        EpochUnbondingRecord: {
+            typeUrl: "/stride.records.EpochUnbondingRecord";
+            encode(message: _179.EpochUnbondingRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _179.EpochUnbondingRecord;
+            fromJSON(object: any): _179.EpochUnbondingRecord;
+            toJSON(message: _179.EpochUnbondingRecord): import("../json-safe.ts").JsonSafe<_179.EpochUnbondingRecord>;
+            fromPartial(object: Partial<_179.EpochUnbondingRecord>): _179.EpochUnbondingRecord;
+            fromProtoMsg(message: _179.EpochUnbondingRecordProtoMsg): _179.EpochUnbondingRecord;
+            toProto(message: _179.EpochUnbondingRecord): Uint8Array;
+            toProtoMsg(message: _179.EpochUnbondingRecord): _179.EpochUnbondingRecordProtoMsg;
+        };
+        LSMTokenDeposit: {
+            typeUrl: "/stride.records.LSMTokenDeposit";
+            encode(message: _179.LSMTokenDeposit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _179.LSMTokenDeposit;
+            fromJSON(object: any): _179.LSMTokenDeposit;
+            toJSON(message: _179.LSMTokenDeposit): import("../json-safe.ts").JsonSafe<_179.LSMTokenDeposit>;
+            fromPartial(object: Partial<_179.LSMTokenDeposit>): _179.LSMTokenDeposit;
+            fromProtoMsg(message: _179.LSMTokenDepositProtoMsg): _179.LSMTokenDeposit;
+            toProto(message: _179.LSMTokenDeposit): Uint8Array;
+            toProtoMsg(message: _179.LSMTokenDeposit): _179.LSMTokenDepositProtoMsg;
+        };
+        QueryParamsRequest: {
+            typeUrl: "/stride.records.QueryParamsRequest";
+            encode(_: _178.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryParamsRequest;
+            fromJSON(_: any): _178.QueryParamsRequest;
+            toJSON(_: _178.QueryParamsRequest): import("../json-safe.ts").JsonSafe<_178.QueryParamsRequest>;
+            fromPartial(_: Partial<_178.QueryParamsRequest>): _178.QueryParamsRequest;
+            fromProtoMsg(message: _178.QueryParamsRequestProtoMsg): _178.QueryParamsRequest;
+            toProto(message: _178.QueryParamsRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryParamsRequest): _178.QueryParamsRequestProtoMsg;
+        };
+        QueryParamsResponse: {
+            typeUrl: "/stride.records.QueryParamsResponse";
+            encode(message: _178.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryParamsResponse;
+            fromJSON(object: any): _178.QueryParamsResponse;
+            toJSON(message: _178.QueryParamsResponse): import("../json-safe.ts").JsonSafe<_178.QueryParamsResponse>;
+            fromPartial(object: Partial<_178.QueryParamsResponse>): _178.QueryParamsResponse;
+            fromProtoMsg(message: _178.QueryParamsResponseProtoMsg): _178.QueryParamsResponse;
+            toProto(message: _178.QueryParamsResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryParamsResponse): _178.QueryParamsResponseProtoMsg;
+        };
+        QueryGetDepositRecordRequest: {
+            typeUrl: "/stride.records.QueryGetDepositRecordRequest";
+            encode(message: _178.QueryGetDepositRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryGetDepositRecordRequest;
+            fromJSON(object: any): _178.QueryGetDepositRecordRequest;
+            toJSON(message: _178.QueryGetDepositRecordRequest): import("../json-safe.ts").JsonSafe<_178.QueryGetDepositRecordRequest>;
+            fromPartial(object: Partial<_178.QueryGetDepositRecordRequest>): _178.QueryGetDepositRecordRequest;
+            fromProtoMsg(message: _178.QueryGetDepositRecordRequestProtoMsg): _178.QueryGetDepositRecordRequest;
+            toProto(message: _178.QueryGetDepositRecordRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryGetDepositRecordRequest): _178.QueryGetDepositRecordRequestProtoMsg;
+        };
+        QueryGetDepositRecordResponse: {
+            typeUrl: "/stride.records.QueryGetDepositRecordResponse";
+            encode(message: _178.QueryGetDepositRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryGetDepositRecordResponse;
+            fromJSON(object: any): _178.QueryGetDepositRecordResponse;
+            toJSON(message: _178.QueryGetDepositRecordResponse): import("../json-safe.ts").JsonSafe<_178.QueryGetDepositRecordResponse>;
+            fromPartial(object: Partial<_178.QueryGetDepositRecordResponse>): _178.QueryGetDepositRecordResponse;
+            fromProtoMsg(message: _178.QueryGetDepositRecordResponseProtoMsg): _178.QueryGetDepositRecordResponse;
+            toProto(message: _178.QueryGetDepositRecordResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryGetDepositRecordResponse): _178.QueryGetDepositRecordResponseProtoMsg;
+        };
+        QueryAllDepositRecordRequest: {
+            typeUrl: "/stride.records.QueryAllDepositRecordRequest";
+            encode(message: _178.QueryAllDepositRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllDepositRecordRequest;
+            fromJSON(object: any): _178.QueryAllDepositRecordRequest;
+            toJSON(message: _178.QueryAllDepositRecordRequest): import("../json-safe.ts").JsonSafe<_178.QueryAllDepositRecordRequest>;
+            fromPartial(object: Partial<_178.QueryAllDepositRecordRequest>): _178.QueryAllDepositRecordRequest;
+            fromProtoMsg(message: _178.QueryAllDepositRecordRequestProtoMsg): _178.QueryAllDepositRecordRequest;
+            toProto(message: _178.QueryAllDepositRecordRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryAllDepositRecordRequest): _178.QueryAllDepositRecordRequestProtoMsg;
+        };
+        QueryAllDepositRecordResponse: {
+            typeUrl: "/stride.records.QueryAllDepositRecordResponse";
+            encode(message: _178.QueryAllDepositRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllDepositRecordResponse;
+            fromJSON(object: any): _178.QueryAllDepositRecordResponse;
+            toJSON(message: _178.QueryAllDepositRecordResponse): import("../json-safe.ts").JsonSafe<_178.QueryAllDepositRecordResponse>;
+            fromPartial(object: Partial<_178.QueryAllDepositRecordResponse>): _178.QueryAllDepositRecordResponse;
+            fromProtoMsg(message: _178.QueryAllDepositRecordResponseProtoMsg): _178.QueryAllDepositRecordResponse;
+            toProto(message: _178.QueryAllDepositRecordResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryAllDepositRecordResponse): _178.QueryAllDepositRecordResponseProtoMsg;
+        };
+        QueryDepositRecordByHostRequest: {
+            typeUrl: "/stride.records.QueryDepositRecordByHostRequest";
+            encode(message: _178.QueryDepositRecordByHostRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryDepositRecordByHostRequest;
+            fromJSON(object: any): _178.QueryDepositRecordByHostRequest;
+            toJSON(message: _178.QueryDepositRecordByHostRequest): import("../json-safe.ts").JsonSafe<_178.QueryDepositRecordByHostRequest>;
+            fromPartial(object: Partial<_178.QueryDepositRecordByHostRequest>): _178.QueryDepositRecordByHostRequest;
+            fromProtoMsg(message: _178.QueryDepositRecordByHostRequestProtoMsg): _178.QueryDepositRecordByHostRequest;
+            toProto(message: _178.QueryDepositRecordByHostRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryDepositRecordByHostRequest): _178.QueryDepositRecordByHostRequestProtoMsg;
+        };
+        QueryDepositRecordByHostResponse: {
+            typeUrl: "/stride.records.QueryDepositRecordByHostResponse";
+            encode(message: _178.QueryDepositRecordByHostResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryDepositRecordByHostResponse;
+            fromJSON(object: any): _178.QueryDepositRecordByHostResponse;
+            toJSON(message: _178.QueryDepositRecordByHostResponse): import("../json-safe.ts").JsonSafe<_178.QueryDepositRecordByHostResponse>;
+            fromPartial(object: Partial<_178.QueryDepositRecordByHostResponse>): _178.QueryDepositRecordByHostResponse;
+            fromProtoMsg(message: _178.QueryDepositRecordByHostResponseProtoMsg): _178.QueryDepositRecordByHostResponse;
+            toProto(message: _178.QueryDepositRecordByHostResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryDepositRecordByHostResponse): _178.QueryDepositRecordByHostResponseProtoMsg;
+        };
+        QueryGetUserRedemptionRecordRequest: {
+            typeUrl: "/stride.records.QueryGetUserRedemptionRecordRequest";
+            encode(message: _178.QueryGetUserRedemptionRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryGetUserRedemptionRecordRequest;
+            fromJSON(object: any): _178.QueryGetUserRedemptionRecordRequest;
+            toJSON(message: _178.QueryGetUserRedemptionRecordRequest): import("../json-safe.ts").JsonSafe<_178.QueryGetUserRedemptionRecordRequest>;
+            fromPartial(object: Partial<_178.QueryGetUserRedemptionRecordRequest>): _178.QueryGetUserRedemptionRecordRequest;
+            fromProtoMsg(message: _178.QueryGetUserRedemptionRecordRequestProtoMsg): _178.QueryGetUserRedemptionRecordRequest;
+            toProto(message: _178.QueryGetUserRedemptionRecordRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryGetUserRedemptionRecordRequest): _178.QueryGetUserRedemptionRecordRequestProtoMsg;
+        };
+        QueryGetUserRedemptionRecordResponse: {
+            typeUrl: "/stride.records.QueryGetUserRedemptionRecordResponse";
+            encode(message: _178.QueryGetUserRedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryGetUserRedemptionRecordResponse;
+            fromJSON(object: any): _178.QueryGetUserRedemptionRecordResponse;
+            toJSON(message: _178.QueryGetUserRedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_178.QueryGetUserRedemptionRecordResponse>;
+            fromPartial(object: Partial<_178.QueryGetUserRedemptionRecordResponse>): _178.QueryGetUserRedemptionRecordResponse;
+            fromProtoMsg(message: _178.QueryGetUserRedemptionRecordResponseProtoMsg): _178.QueryGetUserRedemptionRecordResponse;
+            toProto(message: _178.QueryGetUserRedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryGetUserRedemptionRecordResponse): _178.QueryGetUserRedemptionRecordResponseProtoMsg;
+        };
+        QueryAllUserRedemptionRecordRequest: {
+            typeUrl: "/stride.records.QueryAllUserRedemptionRecordRequest";
+            encode(message: _178.QueryAllUserRedemptionRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllUserRedemptionRecordRequest;
+            fromJSON(object: any): _178.QueryAllUserRedemptionRecordRequest;
+            toJSON(message: _178.QueryAllUserRedemptionRecordRequest): import("../json-safe.ts").JsonSafe<_178.QueryAllUserRedemptionRecordRequest>;
+            fromPartial(object: Partial<_178.QueryAllUserRedemptionRecordRequest>): _178.QueryAllUserRedemptionRecordRequest;
+            fromProtoMsg(message: _178.QueryAllUserRedemptionRecordRequestProtoMsg): _178.QueryAllUserRedemptionRecordRequest;
+            toProto(message: _178.QueryAllUserRedemptionRecordRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryAllUserRedemptionRecordRequest): _178.QueryAllUserRedemptionRecordRequestProtoMsg;
+        };
+        QueryAllUserRedemptionRecordResponse: {
+            typeUrl: "/stride.records.QueryAllUserRedemptionRecordResponse";
+            encode(message: _178.QueryAllUserRedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllUserRedemptionRecordResponse;
+            fromJSON(object: any): _178.QueryAllUserRedemptionRecordResponse;
+            toJSON(message: _178.QueryAllUserRedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_178.QueryAllUserRedemptionRecordResponse>;
+            fromPartial(object: Partial<_178.QueryAllUserRedemptionRecordResponse>): _178.QueryAllUserRedemptionRecordResponse;
+            fromProtoMsg(message: _178.QueryAllUserRedemptionRecordResponseProtoMsg): _178.QueryAllUserRedemptionRecordResponse;
+            toProto(message: _178.QueryAllUserRedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryAllUserRedemptionRecordResponse): _178.QueryAllUserRedemptionRecordResponseProtoMsg;
+        };
+        QueryAllUserRedemptionRecordForUserRequest: {
+            typeUrl: "/stride.records.QueryAllUserRedemptionRecordForUserRequest";
+            encode(message: _178.QueryAllUserRedemptionRecordForUserRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllUserRedemptionRecordForUserRequest;
+            fromJSON(object: any): _178.QueryAllUserRedemptionRecordForUserRequest;
+            toJSON(message: _178.QueryAllUserRedemptionRecordForUserRequest): import("../json-safe.ts").JsonSafe<_178.QueryAllUserRedemptionRecordForUserRequest>;
+            fromPartial(object: Partial<_178.QueryAllUserRedemptionRecordForUserRequest>): _178.QueryAllUserRedemptionRecordForUserRequest;
+            fromProtoMsg(message: _178.QueryAllUserRedemptionRecordForUserRequestProtoMsg): _178.QueryAllUserRedemptionRecordForUserRequest;
+            toProto(message: _178.QueryAllUserRedemptionRecordForUserRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryAllUserRedemptionRecordForUserRequest): _178.QueryAllUserRedemptionRecordForUserRequestProtoMsg;
+        };
+        QueryAllUserRedemptionRecordForUserResponse: {
+            typeUrl: "/stride.records.QueryAllUserRedemptionRecordForUserResponse";
+            encode(message: _178.QueryAllUserRedemptionRecordForUserResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllUserRedemptionRecordForUserResponse;
+            fromJSON(object: any): _178.QueryAllUserRedemptionRecordForUserResponse;
+            toJSON(message: _178.QueryAllUserRedemptionRecordForUserResponse): import("../json-safe.ts").JsonSafe<_178.QueryAllUserRedemptionRecordForUserResponse>;
+            fromPartial(object: Partial<_178.QueryAllUserRedemptionRecordForUserResponse>): _178.QueryAllUserRedemptionRecordForUserResponse;
+            fromProtoMsg(message: _178.QueryAllUserRedemptionRecordForUserResponseProtoMsg): _178.QueryAllUserRedemptionRecordForUserResponse;
+            toProto(message: _178.QueryAllUserRedemptionRecordForUserResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryAllUserRedemptionRecordForUserResponse): _178.QueryAllUserRedemptionRecordForUserResponseProtoMsg;
+        };
+        QueryGetEpochUnbondingRecordRequest: {
+            typeUrl: "/stride.records.QueryGetEpochUnbondingRecordRequest";
+            encode(message: _178.QueryGetEpochUnbondingRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryGetEpochUnbondingRecordRequest;
+            fromJSON(object: any): _178.QueryGetEpochUnbondingRecordRequest;
+            toJSON(message: _178.QueryGetEpochUnbondingRecordRequest): import("../json-safe.ts").JsonSafe<_178.QueryGetEpochUnbondingRecordRequest>;
+            fromPartial(object: Partial<_178.QueryGetEpochUnbondingRecordRequest>): _178.QueryGetEpochUnbondingRecordRequest;
+            fromProtoMsg(message: _178.QueryGetEpochUnbondingRecordRequestProtoMsg): _178.QueryGetEpochUnbondingRecordRequest;
+            toProto(message: _178.QueryGetEpochUnbondingRecordRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryGetEpochUnbondingRecordRequest): _178.QueryGetEpochUnbondingRecordRequestProtoMsg;
+        };
+        QueryGetEpochUnbondingRecordResponse: {
+            typeUrl: "/stride.records.QueryGetEpochUnbondingRecordResponse";
+            encode(message: _178.QueryGetEpochUnbondingRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryGetEpochUnbondingRecordResponse;
+            fromJSON(object: any): _178.QueryGetEpochUnbondingRecordResponse;
+            toJSON(message: _178.QueryGetEpochUnbondingRecordResponse): import("../json-safe.ts").JsonSafe<_178.QueryGetEpochUnbondingRecordResponse>;
+            fromPartial(object: Partial<_178.QueryGetEpochUnbondingRecordResponse>): _178.QueryGetEpochUnbondingRecordResponse;
+            fromProtoMsg(message: _178.QueryGetEpochUnbondingRecordResponseProtoMsg): _178.QueryGetEpochUnbondingRecordResponse;
+            toProto(message: _178.QueryGetEpochUnbondingRecordResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryGetEpochUnbondingRecordResponse): _178.QueryGetEpochUnbondingRecordResponseProtoMsg;
+        };
+        QueryAllEpochUnbondingRecordRequest: {
+            typeUrl: "/stride.records.QueryAllEpochUnbondingRecordRequest";
+            encode(message: _178.QueryAllEpochUnbondingRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllEpochUnbondingRecordRequest;
+            fromJSON(object: any): _178.QueryAllEpochUnbondingRecordRequest;
+            toJSON(message: _178.QueryAllEpochUnbondingRecordRequest): import("../json-safe.ts").JsonSafe<_178.QueryAllEpochUnbondingRecordRequest>;
+            fromPartial(object: Partial<_178.QueryAllEpochUnbondingRecordRequest>): _178.QueryAllEpochUnbondingRecordRequest;
+            fromProtoMsg(message: _178.QueryAllEpochUnbondingRecordRequestProtoMsg): _178.QueryAllEpochUnbondingRecordRequest;
+            toProto(message: _178.QueryAllEpochUnbondingRecordRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryAllEpochUnbondingRecordRequest): _178.QueryAllEpochUnbondingRecordRequestProtoMsg;
+        };
+        QueryAllEpochUnbondingRecordResponse: {
+            typeUrl: "/stride.records.QueryAllEpochUnbondingRecordResponse";
+            encode(message: _178.QueryAllEpochUnbondingRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryAllEpochUnbondingRecordResponse;
+            fromJSON(object: any): _178.QueryAllEpochUnbondingRecordResponse;
+            toJSON(message: _178.QueryAllEpochUnbondingRecordResponse): import("../json-safe.ts").JsonSafe<_178.QueryAllEpochUnbondingRecordResponse>;
+            fromPartial(object: Partial<_178.QueryAllEpochUnbondingRecordResponse>): _178.QueryAllEpochUnbondingRecordResponse;
+            fromProtoMsg(message: _178.QueryAllEpochUnbondingRecordResponseProtoMsg): _178.QueryAllEpochUnbondingRecordResponse;
+            toProto(message: _178.QueryAllEpochUnbondingRecordResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryAllEpochUnbondingRecordResponse): _178.QueryAllEpochUnbondingRecordResponseProtoMsg;
+        };
+        QueryLSMDepositRequest: {
+            typeUrl: "/stride.records.QueryLSMDepositRequest";
+            encode(message: _178.QueryLSMDepositRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryLSMDepositRequest;
+            fromJSON(object: any): _178.QueryLSMDepositRequest;
+            toJSON(message: _178.QueryLSMDepositRequest): import("../json-safe.ts").JsonSafe<_178.QueryLSMDepositRequest>;
+            fromPartial(object: Partial<_178.QueryLSMDepositRequest>): _178.QueryLSMDepositRequest;
+            fromProtoMsg(message: _178.QueryLSMDepositRequestProtoMsg): _178.QueryLSMDepositRequest;
+            toProto(message: _178.QueryLSMDepositRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryLSMDepositRequest): _178.QueryLSMDepositRequestProtoMsg;
+        };
+        QueryLSMDepositResponse: {
+            typeUrl: "/stride.records.QueryLSMDepositResponse";
+            encode(message: _178.QueryLSMDepositResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryLSMDepositResponse;
+            fromJSON(object: any): _178.QueryLSMDepositResponse;
+            toJSON(message: _178.QueryLSMDepositResponse): import("../json-safe.ts").JsonSafe<_178.QueryLSMDepositResponse>;
+            fromPartial(object: Partial<_178.QueryLSMDepositResponse>): _178.QueryLSMDepositResponse;
+            fromProtoMsg(message: _178.QueryLSMDepositResponseProtoMsg): _178.QueryLSMDepositResponse;
+            toProto(message: _178.QueryLSMDepositResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryLSMDepositResponse): _178.QueryLSMDepositResponseProtoMsg;
+        };
+        QueryLSMDepositsRequest: {
+            typeUrl: "/stride.records.QueryLSMDepositsRequest";
+            encode(message: _178.QueryLSMDepositsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryLSMDepositsRequest;
+            fromJSON(object: any): _178.QueryLSMDepositsRequest;
+            toJSON(message: _178.QueryLSMDepositsRequest): import("../json-safe.ts").JsonSafe<_178.QueryLSMDepositsRequest>;
+            fromPartial(object: Partial<_178.QueryLSMDepositsRequest>): _178.QueryLSMDepositsRequest;
+            fromProtoMsg(message: _178.QueryLSMDepositsRequestProtoMsg): _178.QueryLSMDepositsRequest;
+            toProto(message: _178.QueryLSMDepositsRequest): Uint8Array;
+            toProtoMsg(message: _178.QueryLSMDepositsRequest): _178.QueryLSMDepositsRequestProtoMsg;
+        };
+        QueryLSMDepositsResponse: {
+            typeUrl: "/stride.records.QueryLSMDepositsResponse";
+            encode(message: _178.QueryLSMDepositsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _178.QueryLSMDepositsResponse;
+            fromJSON(object: any): _178.QueryLSMDepositsResponse;
+            toJSON(message: _178.QueryLSMDepositsResponse): import("../json-safe.ts").JsonSafe<_178.QueryLSMDepositsResponse>;
+            fromPartial(object: Partial<_178.QueryLSMDepositsResponse>): _178.QueryLSMDepositsResponse;
+            fromProtoMsg(message: _178.QueryLSMDepositsResponseProtoMsg): _178.QueryLSMDepositsResponse;
+            toProto(message: _178.QueryLSMDepositsResponse): Uint8Array;
+            toProtoMsg(message: _178.QueryLSMDepositsResponse): _178.QueryLSMDepositsResponseProtoMsg;
+        };
+        Params: {
+            typeUrl: "/stride.records.Params";
+            encode(_: _177.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _177.Params;
+            fromJSON(_: any): _177.Params;
+            toJSON(_: _177.Params): import("../json-safe.ts").JsonSafe<_177.Params>;
+            fromPartial(_: Partial<_177.Params>): _177.Params;
+            fromProtoMsg(message: _177.ParamsProtoMsg): _177.Params;
+            toProto(message: _177.Params): Uint8Array;
+            toProtoMsg(message: _177.Params): _177.ParamsProtoMsg;
+        };
+        GenesisState: {
+            typeUrl: "/stride.records.GenesisState";
+            encode(message: _176.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.GenesisState;
+            fromJSON(object: any): _176.GenesisState;
+            toJSON(message: _176.GenesisState): import("../json-safe.ts").JsonSafe<_176.GenesisState>;
+            fromPartial(object: Partial<_176.GenesisState>): _176.GenesisState;
+            fromProtoMsg(message: _176.GenesisStateProtoMsg): _176.GenesisState;
+            toProto(message: _176.GenesisState): Uint8Array;
+            toProtoMsg(message: _176.GenesisState): _176.GenesisStateProtoMsg;
+        };
+        TransferCallback: {
+            typeUrl: "/stride.records.TransferCallback";
+            encode(message: _175.TransferCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.TransferCallback;
+            fromJSON(object: any): _175.TransferCallback;
+            toJSON(message: _175.TransferCallback): import("../json-safe.ts").JsonSafe<_175.TransferCallback>;
+            fromPartial(object: Partial<_175.TransferCallback>): _175.TransferCallback;
+            fromProtoMsg(message: _175.TransferCallbackProtoMsg): _175.TransferCallback;
+            toProto(message: _175.TransferCallback): Uint8Array;
+            toProtoMsg(message: _175.TransferCallback): _175.TransferCallbackProtoMsg;
+        };
+        TransferLSMTokenCallback: {
+            typeUrl: "/stride.records.TransferLSMTokenCallback";
+            encode(message: _175.TransferLSMTokenCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.TransferLSMTokenCallback;
+            fromJSON(object: any): _175.TransferLSMTokenCallback;
+            toJSON(message: _175.TransferLSMTokenCallback): import("../json-safe.ts").JsonSafe<_175.TransferLSMTokenCallback>;
+            fromPartial(object: Partial<_175.TransferLSMTokenCallback>): _175.TransferLSMTokenCallback;
+            fromProtoMsg(message: _175.TransferLSMTokenCallbackProtoMsg): _175.TransferLSMTokenCallback;
+            toProto(message: _175.TransferLSMTokenCallback): Uint8Array;
+            toProtoMsg(message: _175.TransferLSMTokenCallback): _175.TransferLSMTokenCallbackProtoMsg;
+        };
+    };
+    const stakedym: {
+        overwritableRecordTypeFromJSON(object: any): _183.OverwritableRecordType;
+        overwritableRecordTypeToJSON(object: _183.OverwritableRecordType): string;
+        OverwritableRecordType: typeof _183.OverwritableRecordType;
+        OverwritableRecordTypeSDKType: typeof _183.OverwritableRecordType;
+        MsgLiquidStake: {
+            typeUrl: "/stride.stakedym.MsgLiquidStake";
+            encode(message: _183.MsgLiquidStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgLiquidStake;
+            fromJSON(object: any): _183.MsgLiquidStake;
+            toJSON(message: _183.MsgLiquidStake): import("../json-safe.ts").JsonSafe<_183.MsgLiquidStake>;
+            fromPartial(object: Partial<_183.MsgLiquidStake>): _183.MsgLiquidStake;
+            fromProtoMsg(message: _183.MsgLiquidStakeProtoMsg): _183.MsgLiquidStake;
+            toProto(message: _183.MsgLiquidStake): Uint8Array;
+            toProtoMsg(message: _183.MsgLiquidStake): _183.MsgLiquidStakeProtoMsg;
+        };
+        MsgLiquidStakeResponse: {
+            typeUrl: "/stride.stakedym.MsgLiquidStakeResponse";
+            encode(message: _183.MsgLiquidStakeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgLiquidStakeResponse;
+            fromJSON(object: any): _183.MsgLiquidStakeResponse;
+            toJSON(message: _183.MsgLiquidStakeResponse): import("../json-safe.ts").JsonSafe<_183.MsgLiquidStakeResponse>;
+            fromPartial(object: Partial<_183.MsgLiquidStakeResponse>): _183.MsgLiquidStakeResponse;
+            fromProtoMsg(message: _183.MsgLiquidStakeResponseProtoMsg): _183.MsgLiquidStakeResponse;
+            toProto(message: _183.MsgLiquidStakeResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgLiquidStakeResponse): _183.MsgLiquidStakeResponseProtoMsg;
+        };
+        MsgRedeemStake: {
+            typeUrl: "/stride.stakedym.MsgRedeemStake";
+            encode(message: _183.MsgRedeemStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgRedeemStake;
+            fromJSON(object: any): _183.MsgRedeemStake;
+            toJSON(message: _183.MsgRedeemStake): import("../json-safe.ts").JsonSafe<_183.MsgRedeemStake>;
+            fromPartial(object: Partial<_183.MsgRedeemStake>): _183.MsgRedeemStake;
+            fromProtoMsg(message: _183.MsgRedeemStakeProtoMsg): _183.MsgRedeemStake;
+            toProto(message: _183.MsgRedeemStake): Uint8Array;
+            toProtoMsg(message: _183.MsgRedeemStake): _183.MsgRedeemStakeProtoMsg;
+        };
+        MsgRedeemStakeResponse: {
+            typeUrl: "/stride.stakedym.MsgRedeemStakeResponse";
+            encode(message: _183.MsgRedeemStakeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgRedeemStakeResponse;
+            fromJSON(object: any): _183.MsgRedeemStakeResponse;
+            toJSON(message: _183.MsgRedeemStakeResponse): import("../json-safe.ts").JsonSafe<_183.MsgRedeemStakeResponse>;
+            fromPartial(object: Partial<_183.MsgRedeemStakeResponse>): _183.MsgRedeemStakeResponse;
+            fromProtoMsg(message: _183.MsgRedeemStakeResponseProtoMsg): _183.MsgRedeemStakeResponse;
+            toProto(message: _183.MsgRedeemStakeResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgRedeemStakeResponse): _183.MsgRedeemStakeResponseProtoMsg;
+        };
+        MsgConfirmDelegation: {
+            typeUrl: "/stride.stakedym.MsgConfirmDelegation";
+            encode(message: _183.MsgConfirmDelegation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgConfirmDelegation;
+            fromJSON(object: any): _183.MsgConfirmDelegation;
+            toJSON(message: _183.MsgConfirmDelegation): import("../json-safe.ts").JsonSafe<_183.MsgConfirmDelegation>;
+            fromPartial(object: Partial<_183.MsgConfirmDelegation>): _183.MsgConfirmDelegation;
+            fromProtoMsg(message: _183.MsgConfirmDelegationProtoMsg): _183.MsgConfirmDelegation;
+            toProto(message: _183.MsgConfirmDelegation): Uint8Array;
+            toProtoMsg(message: _183.MsgConfirmDelegation): _183.MsgConfirmDelegationProtoMsg;
+        };
+        MsgConfirmDelegationResponse: {
+            typeUrl: "/stride.stakedym.MsgConfirmDelegationResponse";
+            encode(_: _183.MsgConfirmDelegationResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgConfirmDelegationResponse;
+            fromJSON(_: any): _183.MsgConfirmDelegationResponse;
+            toJSON(_: _183.MsgConfirmDelegationResponse): import("../json-safe.ts").JsonSafe<_183.MsgConfirmDelegationResponse>;
+            fromPartial(_: Partial<_183.MsgConfirmDelegationResponse>): _183.MsgConfirmDelegationResponse;
+            fromProtoMsg(message: _183.MsgConfirmDelegationResponseProtoMsg): _183.MsgConfirmDelegationResponse;
+            toProto(message: _183.MsgConfirmDelegationResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgConfirmDelegationResponse): _183.MsgConfirmDelegationResponseProtoMsg;
+        };
+        MsgConfirmUndelegation: {
+            typeUrl: "/stride.stakedym.MsgConfirmUndelegation";
+            encode(message: _183.MsgConfirmUndelegation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgConfirmUndelegation;
+            fromJSON(object: any): _183.MsgConfirmUndelegation;
+            toJSON(message: _183.MsgConfirmUndelegation): import("../json-safe.ts").JsonSafe<_183.MsgConfirmUndelegation>;
+            fromPartial(object: Partial<_183.MsgConfirmUndelegation>): _183.MsgConfirmUndelegation;
+            fromProtoMsg(message: _183.MsgConfirmUndelegationProtoMsg): _183.MsgConfirmUndelegation;
+            toProto(message: _183.MsgConfirmUndelegation): Uint8Array;
+            toProtoMsg(message: _183.MsgConfirmUndelegation): _183.MsgConfirmUndelegationProtoMsg;
+        };
+        MsgConfirmUndelegationResponse: {
+            typeUrl: "/stride.stakedym.MsgConfirmUndelegationResponse";
+            encode(_: _183.MsgConfirmUndelegationResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgConfirmUndelegationResponse;
+            fromJSON(_: any): _183.MsgConfirmUndelegationResponse;
+            toJSON(_: _183.MsgConfirmUndelegationResponse): import("../json-safe.ts").JsonSafe<_183.MsgConfirmUndelegationResponse>;
+            fromPartial(_: Partial<_183.MsgConfirmUndelegationResponse>): _183.MsgConfirmUndelegationResponse;
+            fromProtoMsg(message: _183.MsgConfirmUndelegationResponseProtoMsg): _183.MsgConfirmUndelegationResponse;
+            toProto(message: _183.MsgConfirmUndelegationResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgConfirmUndelegationResponse): _183.MsgConfirmUndelegationResponseProtoMsg;
+        };
+        MsgConfirmUnbondedTokenSweep: {
+            typeUrl: "/stride.stakedym.MsgConfirmUnbondedTokenSweep";
+            encode(message: _183.MsgConfirmUnbondedTokenSweep, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgConfirmUnbondedTokenSweep;
+            fromJSON(object: any): _183.MsgConfirmUnbondedTokenSweep;
+            toJSON(message: _183.MsgConfirmUnbondedTokenSweep): import("../json-safe.ts").JsonSafe<_183.MsgConfirmUnbondedTokenSweep>;
+            fromPartial(object: Partial<_183.MsgConfirmUnbondedTokenSweep>): _183.MsgConfirmUnbondedTokenSweep;
+            fromProtoMsg(message: _183.MsgConfirmUnbondedTokenSweepProtoMsg): _183.MsgConfirmUnbondedTokenSweep;
+            toProto(message: _183.MsgConfirmUnbondedTokenSweep): Uint8Array;
+            toProtoMsg(message: _183.MsgConfirmUnbondedTokenSweep): _183.MsgConfirmUnbondedTokenSweepProtoMsg;
+        };
+        MsgConfirmUnbondedTokenSweepResponse: {
+            typeUrl: "/stride.stakedym.MsgConfirmUnbondedTokenSweepResponse";
+            encode(_: _183.MsgConfirmUnbondedTokenSweepResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgConfirmUnbondedTokenSweepResponse;
+            fromJSON(_: any): _183.MsgConfirmUnbondedTokenSweepResponse;
+            toJSON(_: _183.MsgConfirmUnbondedTokenSweepResponse): import("../json-safe.ts").JsonSafe<_183.MsgConfirmUnbondedTokenSweepResponse>;
+            fromPartial(_: Partial<_183.MsgConfirmUnbondedTokenSweepResponse>): _183.MsgConfirmUnbondedTokenSweepResponse;
+            fromProtoMsg(message: _183.MsgConfirmUnbondedTokenSweepResponseProtoMsg): _183.MsgConfirmUnbondedTokenSweepResponse;
+            toProto(message: _183.MsgConfirmUnbondedTokenSweepResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgConfirmUnbondedTokenSweepResponse): _183.MsgConfirmUnbondedTokenSweepResponseProtoMsg;
+        };
+        MsgAdjustDelegatedBalance: {
+            typeUrl: "/stride.stakedym.MsgAdjustDelegatedBalance";
+            encode(message: _183.MsgAdjustDelegatedBalance, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgAdjustDelegatedBalance;
+            fromJSON(object: any): _183.MsgAdjustDelegatedBalance;
+            toJSON(message: _183.MsgAdjustDelegatedBalance): import("../json-safe.ts").JsonSafe<_183.MsgAdjustDelegatedBalance>;
+            fromPartial(object: Partial<_183.MsgAdjustDelegatedBalance>): _183.MsgAdjustDelegatedBalance;
+            fromProtoMsg(message: _183.MsgAdjustDelegatedBalanceProtoMsg): _183.MsgAdjustDelegatedBalance;
+            toProto(message: _183.MsgAdjustDelegatedBalance): Uint8Array;
+            toProtoMsg(message: _183.MsgAdjustDelegatedBalance): _183.MsgAdjustDelegatedBalanceProtoMsg;
+        };
+        MsgAdjustDelegatedBalanceResponse: {
+            typeUrl: "/stride.stakedym.MsgAdjustDelegatedBalanceResponse";
+            encode(_: _183.MsgAdjustDelegatedBalanceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgAdjustDelegatedBalanceResponse;
+            fromJSON(_: any): _183.MsgAdjustDelegatedBalanceResponse;
+            toJSON(_: _183.MsgAdjustDelegatedBalanceResponse): import("../json-safe.ts").JsonSafe<_183.MsgAdjustDelegatedBalanceResponse>;
+            fromPartial(_: Partial<_183.MsgAdjustDelegatedBalanceResponse>): _183.MsgAdjustDelegatedBalanceResponse;
+            fromProtoMsg(message: _183.MsgAdjustDelegatedBalanceResponseProtoMsg): _183.MsgAdjustDelegatedBalanceResponse;
+            toProto(message: _183.MsgAdjustDelegatedBalanceResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgAdjustDelegatedBalanceResponse): _183.MsgAdjustDelegatedBalanceResponseProtoMsg;
+        };
+        MsgUpdateInnerRedemptionRateBounds: {
+            typeUrl: "/stride.stakedym.MsgUpdateInnerRedemptionRateBounds";
+            encode(message: _183.MsgUpdateInnerRedemptionRateBounds, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgUpdateInnerRedemptionRateBounds;
+            fromJSON(object: any): _183.MsgUpdateInnerRedemptionRateBounds;
+            toJSON(message: _183.MsgUpdateInnerRedemptionRateBounds): import("../json-safe.ts").JsonSafe<_183.MsgUpdateInnerRedemptionRateBounds>;
+            fromPartial(object: Partial<_183.MsgUpdateInnerRedemptionRateBounds>): _183.MsgUpdateInnerRedemptionRateBounds;
+            fromProtoMsg(message: _183.MsgUpdateInnerRedemptionRateBoundsProtoMsg): _183.MsgUpdateInnerRedemptionRateBounds;
+            toProto(message: _183.MsgUpdateInnerRedemptionRateBounds): Uint8Array;
+            toProtoMsg(message: _183.MsgUpdateInnerRedemptionRateBounds): _183.MsgUpdateInnerRedemptionRateBoundsProtoMsg;
+        };
+        MsgUpdateInnerRedemptionRateBoundsResponse: {
+            typeUrl: "/stride.stakedym.MsgUpdateInnerRedemptionRateBoundsResponse";
+            encode(_: _183.MsgUpdateInnerRedemptionRateBoundsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgUpdateInnerRedemptionRateBoundsResponse;
+            fromJSON(_: any): _183.MsgUpdateInnerRedemptionRateBoundsResponse;
+            toJSON(_: _183.MsgUpdateInnerRedemptionRateBoundsResponse): import("../json-safe.ts").JsonSafe<_183.MsgUpdateInnerRedemptionRateBoundsResponse>;
+            fromPartial(_: Partial<_183.MsgUpdateInnerRedemptionRateBoundsResponse>): _183.MsgUpdateInnerRedemptionRateBoundsResponse;
+            fromProtoMsg(message: _183.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg): _183.MsgUpdateInnerRedemptionRateBoundsResponse;
+            toProto(message: _183.MsgUpdateInnerRedemptionRateBoundsResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgUpdateInnerRedemptionRateBoundsResponse): _183.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg;
+        };
+        MsgResumeHostZone: {
+            typeUrl: "/stride.stakedym.MsgResumeHostZone";
+            encode(message: _183.MsgResumeHostZone, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgResumeHostZone;
+            fromJSON(object: any): _183.MsgResumeHostZone;
+            toJSON(message: _183.MsgResumeHostZone): import("../json-safe.ts").JsonSafe<_183.MsgResumeHostZone>;
+            fromPartial(object: Partial<_183.MsgResumeHostZone>): _183.MsgResumeHostZone;
+            fromProtoMsg(message: _183.MsgResumeHostZoneProtoMsg): _183.MsgResumeHostZone;
+            toProto(message: _183.MsgResumeHostZone): Uint8Array;
+            toProtoMsg(message: _183.MsgResumeHostZone): _183.MsgResumeHostZoneProtoMsg;
+        };
+        MsgResumeHostZoneResponse: {
+            typeUrl: "/stride.stakedym.MsgResumeHostZoneResponse";
+            encode(_: _183.MsgResumeHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgResumeHostZoneResponse;
+            fromJSON(_: any): _183.MsgResumeHostZoneResponse;
+            toJSON(_: _183.MsgResumeHostZoneResponse): import("../json-safe.ts").JsonSafe<_183.MsgResumeHostZoneResponse>;
+            fromPartial(_: Partial<_183.MsgResumeHostZoneResponse>): _183.MsgResumeHostZoneResponse;
+            fromProtoMsg(message: _183.MsgResumeHostZoneResponseProtoMsg): _183.MsgResumeHostZoneResponse;
+            toProto(message: _183.MsgResumeHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgResumeHostZoneResponse): _183.MsgResumeHostZoneResponseProtoMsg;
+        };
+        MsgRefreshRedemptionRate: {
+            typeUrl: "/stride.stakedym.MsgRefreshRedemptionRate";
+            encode(message: _183.MsgRefreshRedemptionRate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgRefreshRedemptionRate;
+            fromJSON(object: any): _183.MsgRefreshRedemptionRate;
+            toJSON(message: _183.MsgRefreshRedemptionRate): import("../json-safe.ts").JsonSafe<_183.MsgRefreshRedemptionRate>;
+            fromPartial(object: Partial<_183.MsgRefreshRedemptionRate>): _183.MsgRefreshRedemptionRate;
+            fromProtoMsg(message: _183.MsgRefreshRedemptionRateProtoMsg): _183.MsgRefreshRedemptionRate;
+            toProto(message: _183.MsgRefreshRedemptionRate): Uint8Array;
+            toProtoMsg(message: _183.MsgRefreshRedemptionRate): _183.MsgRefreshRedemptionRateProtoMsg;
+        };
+        MsgRefreshRedemptionRateResponse: {
+            typeUrl: "/stride.stakedym.MsgRefreshRedemptionRateResponse";
+            encode(_: _183.MsgRefreshRedemptionRateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgRefreshRedemptionRateResponse;
+            fromJSON(_: any): _183.MsgRefreshRedemptionRateResponse;
+            toJSON(_: _183.MsgRefreshRedemptionRateResponse): import("../json-safe.ts").JsonSafe<_183.MsgRefreshRedemptionRateResponse>;
+            fromPartial(_: Partial<_183.MsgRefreshRedemptionRateResponse>): _183.MsgRefreshRedemptionRateResponse;
+            fromProtoMsg(message: _183.MsgRefreshRedemptionRateResponseProtoMsg): _183.MsgRefreshRedemptionRateResponse;
+            toProto(message: _183.MsgRefreshRedemptionRateResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgRefreshRedemptionRateResponse): _183.MsgRefreshRedemptionRateResponseProtoMsg;
+        };
+        MsgOverwriteDelegationRecord: {
+            typeUrl: "/stride.stakedym.MsgOverwriteDelegationRecord";
+            encode(message: _183.MsgOverwriteDelegationRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgOverwriteDelegationRecord;
+            fromJSON(object: any): _183.MsgOverwriteDelegationRecord;
+            toJSON(message: _183.MsgOverwriteDelegationRecord): import("../json-safe.ts").JsonSafe<_183.MsgOverwriteDelegationRecord>;
+            fromPartial(object: Partial<_183.MsgOverwriteDelegationRecord>): _183.MsgOverwriteDelegationRecord;
+            fromProtoMsg(message: _183.MsgOverwriteDelegationRecordProtoMsg): _183.MsgOverwriteDelegationRecord;
+            toProto(message: _183.MsgOverwriteDelegationRecord): Uint8Array;
+            toProtoMsg(message: _183.MsgOverwriteDelegationRecord): _183.MsgOverwriteDelegationRecordProtoMsg;
+        };
+        MsgOverwriteDelegationRecordResponse: {
+            typeUrl: "/stride.stakedym.MsgOverwriteDelegationRecordResponse";
+            encode(_: _183.MsgOverwriteDelegationRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgOverwriteDelegationRecordResponse;
+            fromJSON(_: any): _183.MsgOverwriteDelegationRecordResponse;
+            toJSON(_: _183.MsgOverwriteDelegationRecordResponse): import("../json-safe.ts").JsonSafe<_183.MsgOverwriteDelegationRecordResponse>;
+            fromPartial(_: Partial<_183.MsgOverwriteDelegationRecordResponse>): _183.MsgOverwriteDelegationRecordResponse;
+            fromProtoMsg(message: _183.MsgOverwriteDelegationRecordResponseProtoMsg): _183.MsgOverwriteDelegationRecordResponse;
+            toProto(message: _183.MsgOverwriteDelegationRecordResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgOverwriteDelegationRecordResponse): _183.MsgOverwriteDelegationRecordResponseProtoMsg;
+        };
+        MsgOverwriteUnbondingRecord: {
+            typeUrl: "/stride.stakedym.MsgOverwriteUnbondingRecord";
+            encode(message: _183.MsgOverwriteUnbondingRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgOverwriteUnbondingRecord;
+            fromJSON(object: any): _183.MsgOverwriteUnbondingRecord;
+            toJSON(message: _183.MsgOverwriteUnbondingRecord): import("../json-safe.ts").JsonSafe<_183.MsgOverwriteUnbondingRecord>;
+            fromPartial(object: Partial<_183.MsgOverwriteUnbondingRecord>): _183.MsgOverwriteUnbondingRecord;
+            fromProtoMsg(message: _183.MsgOverwriteUnbondingRecordProtoMsg): _183.MsgOverwriteUnbondingRecord;
+            toProto(message: _183.MsgOverwriteUnbondingRecord): Uint8Array;
+            toProtoMsg(message: _183.MsgOverwriteUnbondingRecord): _183.MsgOverwriteUnbondingRecordProtoMsg;
+        };
+        MsgOverwriteUnbondingRecordResponse: {
+            typeUrl: "/stride.stakedym.MsgOverwriteUnbondingRecordResponse";
+            encode(_: _183.MsgOverwriteUnbondingRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgOverwriteUnbondingRecordResponse;
+            fromJSON(_: any): _183.MsgOverwriteUnbondingRecordResponse;
+            toJSON(_: _183.MsgOverwriteUnbondingRecordResponse): import("../json-safe.ts").JsonSafe<_183.MsgOverwriteUnbondingRecordResponse>;
+            fromPartial(_: Partial<_183.MsgOverwriteUnbondingRecordResponse>): _183.MsgOverwriteUnbondingRecordResponse;
+            fromProtoMsg(message: _183.MsgOverwriteUnbondingRecordResponseProtoMsg): _183.MsgOverwriteUnbondingRecordResponse;
+            toProto(message: _183.MsgOverwriteUnbondingRecordResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgOverwriteUnbondingRecordResponse): _183.MsgOverwriteUnbondingRecordResponseProtoMsg;
+        };
+        MsgOverwriteRedemptionRecord: {
+            typeUrl: "/stride.stakedym.MsgOverwriteRedemptionRecord";
+            encode(message: _183.MsgOverwriteRedemptionRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgOverwriteRedemptionRecord;
+            fromJSON(object: any): _183.MsgOverwriteRedemptionRecord;
+            toJSON(message: _183.MsgOverwriteRedemptionRecord): import("../json-safe.ts").JsonSafe<_183.MsgOverwriteRedemptionRecord>;
+            fromPartial(object: Partial<_183.MsgOverwriteRedemptionRecord>): _183.MsgOverwriteRedemptionRecord;
+            fromProtoMsg(message: _183.MsgOverwriteRedemptionRecordProtoMsg): _183.MsgOverwriteRedemptionRecord;
+            toProto(message: _183.MsgOverwriteRedemptionRecord): Uint8Array;
+            toProtoMsg(message: _183.MsgOverwriteRedemptionRecord): _183.MsgOverwriteRedemptionRecordProtoMsg;
+        };
+        MsgOverwriteRedemptionRecordResponse: {
+            typeUrl: "/stride.stakedym.MsgOverwriteRedemptionRecordResponse";
+            encode(_: _183.MsgOverwriteRedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgOverwriteRedemptionRecordResponse;
+            fromJSON(_: any): _183.MsgOverwriteRedemptionRecordResponse;
+            toJSON(_: _183.MsgOverwriteRedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_183.MsgOverwriteRedemptionRecordResponse>;
+            fromPartial(_: Partial<_183.MsgOverwriteRedemptionRecordResponse>): _183.MsgOverwriteRedemptionRecordResponse;
+            fromProtoMsg(message: _183.MsgOverwriteRedemptionRecordResponseProtoMsg): _183.MsgOverwriteRedemptionRecordResponse;
+            toProto(message: _183.MsgOverwriteRedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgOverwriteRedemptionRecordResponse): _183.MsgOverwriteRedemptionRecordResponseProtoMsg;
+        };
+        MsgSetOperatorAddress: {
+            typeUrl: "/stride.stakedym.MsgSetOperatorAddress";
+            encode(message: _183.MsgSetOperatorAddress, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgSetOperatorAddress;
+            fromJSON(object: any): _183.MsgSetOperatorAddress;
+            toJSON(message: _183.MsgSetOperatorAddress): import("../json-safe.ts").JsonSafe<_183.MsgSetOperatorAddress>;
+            fromPartial(object: Partial<_183.MsgSetOperatorAddress>): _183.MsgSetOperatorAddress;
+            fromProtoMsg(message: _183.MsgSetOperatorAddressProtoMsg): _183.MsgSetOperatorAddress;
+            toProto(message: _183.MsgSetOperatorAddress): Uint8Array;
+            toProtoMsg(message: _183.MsgSetOperatorAddress): _183.MsgSetOperatorAddressProtoMsg;
+        };
+        MsgSetOperatorAddressResponse: {
+            typeUrl: "/stride.stakedym.MsgSetOperatorAddressResponse";
+            encode(_: _183.MsgSetOperatorAddressResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _183.MsgSetOperatorAddressResponse;
+            fromJSON(_: any): _183.MsgSetOperatorAddressResponse;
+            toJSON(_: _183.MsgSetOperatorAddressResponse): import("../json-safe.ts").JsonSafe<_183.MsgSetOperatorAddressResponse>;
+            fromPartial(_: Partial<_183.MsgSetOperatorAddressResponse>): _183.MsgSetOperatorAddressResponse;
+            fromProtoMsg(message: _183.MsgSetOperatorAddressResponseProtoMsg): _183.MsgSetOperatorAddressResponse;
+            toProto(message: _183.MsgSetOperatorAddressResponse): Uint8Array;
+            toProtoMsg(message: _183.MsgSetOperatorAddressResponse): _183.MsgSetOperatorAddressResponseProtoMsg;
+        };
+        delegationRecordStatusFromJSON(object: any): _182.DelegationRecordStatus;
+        delegationRecordStatusToJSON(object: _182.DelegationRecordStatus): string;
+        unbondingRecordStatusFromJSON(object: any): _182.UnbondingRecordStatus;
+        unbondingRecordStatusToJSON(object: _182.UnbondingRecordStatus): string;
+        DelegationRecordStatus: typeof _182.DelegationRecordStatus;
+        DelegationRecordStatusSDKType: typeof _182.DelegationRecordStatus;
+        UnbondingRecordStatus: typeof _182.UnbondingRecordStatus;
+        UnbondingRecordStatusSDKType: typeof _182.UnbondingRecordStatus;
+        HostZone: {
+            typeUrl: "/stride.stakedym.HostZone";
+            encode(message: _182.HostZone, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _182.HostZone;
+            fromJSON(object: any): _182.HostZone;
+            toJSON(message: _182.HostZone): import("../json-safe.ts").JsonSafe<_182.HostZone>;
+            fromPartial(object: Partial<_182.HostZone>): _182.HostZone;
+            fromProtoMsg(message: _182.HostZoneProtoMsg): _182.HostZone;
+            toProto(message: _182.HostZone): Uint8Array;
+            toProtoMsg(message: _182.HostZone): _182.HostZoneProtoMsg;
+        };
+        DelegationRecord: {
+            typeUrl: "/stride.stakedym.DelegationRecord";
+            encode(message: _182.DelegationRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _182.DelegationRecord;
+            fromJSON(object: any): _182.DelegationRecord;
+            toJSON(message: _182.DelegationRecord): import("../json-safe.ts").JsonSafe<_182.DelegationRecord>;
+            fromPartial(object: Partial<_182.DelegationRecord>): _182.DelegationRecord;
+            fromProtoMsg(message: _182.DelegationRecordProtoMsg): _182.DelegationRecord;
+            toProto(message: _182.DelegationRecord): Uint8Array;
+            toProtoMsg(message: _182.DelegationRecord): _182.DelegationRecordProtoMsg;
+        };
+        UnbondingRecord: {
+            typeUrl: "/stride.stakedym.UnbondingRecord";
+            encode(message: _182.UnbondingRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _182.UnbondingRecord;
+            fromJSON(object: any): _182.UnbondingRecord;
+            toJSON(message: _182.UnbondingRecord): import("../json-safe.ts").JsonSafe<_182.UnbondingRecord>;
+            fromPartial(object: Partial<_182.UnbondingRecord>): _182.UnbondingRecord;
+            fromProtoMsg(message: _182.UnbondingRecordProtoMsg): _182.UnbondingRecord;
+            toProto(message: _182.UnbondingRecord): Uint8Array;
+            toProtoMsg(message: _182.UnbondingRecord): _182.UnbondingRecordProtoMsg;
+        };
+        RedemptionRecord: {
+            typeUrl: "/stride.stakedym.RedemptionRecord";
+            encode(message: _182.RedemptionRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _182.RedemptionRecord;
+            fromJSON(object: any): _182.RedemptionRecord;
+            toJSON(message: _182.RedemptionRecord): import("../json-safe.ts").JsonSafe<_182.RedemptionRecord>;
+            fromPartial(object: Partial<_182.RedemptionRecord>): _182.RedemptionRecord;
+            fromProtoMsg(message: _182.RedemptionRecordProtoMsg): _182.RedemptionRecord;
+            toProto(message: _182.RedemptionRecord): Uint8Array;
+            toProtoMsg(message: _182.RedemptionRecord): _182.RedemptionRecordProtoMsg;
+        };
+        SlashRecord: {
+            typeUrl: "/stride.stakedym.SlashRecord";
+            encode(message: _182.SlashRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _182.SlashRecord;
+            fromJSON(object: any): _182.SlashRecord;
+            toJSON(message: _182.SlashRecord): import("../json-safe.ts").JsonSafe<_182.SlashRecord>;
+            fromPartial(object: Partial<_182.SlashRecord>): _182.SlashRecord;
+            fromProtoMsg(message: _182.SlashRecordProtoMsg): _182.SlashRecord;
+            toProto(message: _182.SlashRecord): Uint8Array;
+            toProtoMsg(message: _182.SlashRecord): _182.SlashRecordProtoMsg;
+        };
+        QueryHostZoneRequest: {
+            typeUrl: "/stride.stakedym.QueryHostZoneRequest";
+            encode(_: _181.QueryHostZoneRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryHostZoneRequest;
+            fromJSON(_: any): _181.QueryHostZoneRequest;
+            toJSON(_: _181.QueryHostZoneRequest): import("../json-safe.ts").JsonSafe<_181.QueryHostZoneRequest>;
+            fromPartial(_: Partial<_181.QueryHostZoneRequest>): _181.QueryHostZoneRequest;
+            fromProtoMsg(message: _181.QueryHostZoneRequestProtoMsg): _181.QueryHostZoneRequest;
+            toProto(message: _181.QueryHostZoneRequest): Uint8Array;
+            toProtoMsg(message: _181.QueryHostZoneRequest): _181.QueryHostZoneRequestProtoMsg;
+        };
+        QueryHostZoneResponse: {
+            typeUrl: "/stride.stakedym.QueryHostZoneResponse";
+            encode(message: _181.QueryHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryHostZoneResponse;
+            fromJSON(object: any): _181.QueryHostZoneResponse;
+            toJSON(message: _181.QueryHostZoneResponse): import("../json-safe.ts").JsonSafe<_181.QueryHostZoneResponse>;
+            fromPartial(object: Partial<_181.QueryHostZoneResponse>): _181.QueryHostZoneResponse;
+            fromProtoMsg(message: _181.QueryHostZoneResponseProtoMsg): _181.QueryHostZoneResponse;
+            toProto(message: _181.QueryHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _181.QueryHostZoneResponse): _181.QueryHostZoneResponseProtoMsg;
+        };
+        QueryDelegationRecordsRequest: {
+            typeUrl: "/stride.stakedym.QueryDelegationRecordsRequest";
+            encode(message: _181.QueryDelegationRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryDelegationRecordsRequest;
+            fromJSON(object: any): _181.QueryDelegationRecordsRequest;
+            toJSON(message: _181.QueryDelegationRecordsRequest): import("../json-safe.ts").JsonSafe<_181.QueryDelegationRecordsRequest>;
+            fromPartial(object: Partial<_181.QueryDelegationRecordsRequest>): _181.QueryDelegationRecordsRequest;
+            fromProtoMsg(message: _181.QueryDelegationRecordsRequestProtoMsg): _181.QueryDelegationRecordsRequest;
+            toProto(message: _181.QueryDelegationRecordsRequest): Uint8Array;
+            toProtoMsg(message: _181.QueryDelegationRecordsRequest): _181.QueryDelegationRecordsRequestProtoMsg;
+        };
+        QueryDelegationRecordsResponse: {
+            typeUrl: "/stride.stakedym.QueryDelegationRecordsResponse";
+            encode(message: _181.QueryDelegationRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryDelegationRecordsResponse;
+            fromJSON(object: any): _181.QueryDelegationRecordsResponse;
+            toJSON(message: _181.QueryDelegationRecordsResponse): import("../json-safe.ts").JsonSafe<_181.QueryDelegationRecordsResponse>;
+            fromPartial(object: Partial<_181.QueryDelegationRecordsResponse>): _181.QueryDelegationRecordsResponse;
+            fromProtoMsg(message: _181.QueryDelegationRecordsResponseProtoMsg): _181.QueryDelegationRecordsResponse;
+            toProto(message: _181.QueryDelegationRecordsResponse): Uint8Array;
+            toProtoMsg(message: _181.QueryDelegationRecordsResponse): _181.QueryDelegationRecordsResponseProtoMsg;
+        };
+        QueryUnbondingRecordsRequest: {
+            typeUrl: "/stride.stakedym.QueryUnbondingRecordsRequest";
+            encode(message: _181.QueryUnbondingRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryUnbondingRecordsRequest;
+            fromJSON(object: any): _181.QueryUnbondingRecordsRequest;
+            toJSON(message: _181.QueryUnbondingRecordsRequest): import("../json-safe.ts").JsonSafe<_181.QueryUnbondingRecordsRequest>;
+            fromPartial(object: Partial<_181.QueryUnbondingRecordsRequest>): _181.QueryUnbondingRecordsRequest;
+            fromProtoMsg(message: _181.QueryUnbondingRecordsRequestProtoMsg): _181.QueryUnbondingRecordsRequest;
+            toProto(message: _181.QueryUnbondingRecordsRequest): Uint8Array;
+            toProtoMsg(message: _181.QueryUnbondingRecordsRequest): _181.QueryUnbondingRecordsRequestProtoMsg;
+        };
+        QueryUnbondingRecordsResponse: {
+            typeUrl: "/stride.stakedym.QueryUnbondingRecordsResponse";
+            encode(message: _181.QueryUnbondingRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryUnbondingRecordsResponse;
+            fromJSON(object: any): _181.QueryUnbondingRecordsResponse;
+            toJSON(message: _181.QueryUnbondingRecordsResponse): import("../json-safe.ts").JsonSafe<_181.QueryUnbondingRecordsResponse>;
+            fromPartial(object: Partial<_181.QueryUnbondingRecordsResponse>): _181.QueryUnbondingRecordsResponse;
+            fromProtoMsg(message: _181.QueryUnbondingRecordsResponseProtoMsg): _181.QueryUnbondingRecordsResponse;
+            toProto(message: _181.QueryUnbondingRecordsResponse): Uint8Array;
+            toProtoMsg(message: _181.QueryUnbondingRecordsResponse): _181.QueryUnbondingRecordsResponseProtoMsg;
+        };
+        QueryRedemptionRecordRequest: {
+            typeUrl: "/stride.stakedym.QueryRedemptionRecordRequest";
+            encode(message: _181.QueryRedemptionRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryRedemptionRecordRequest;
+            fromJSON(object: any): _181.QueryRedemptionRecordRequest;
+            toJSON(message: _181.QueryRedemptionRecordRequest): import("../json-safe.ts").JsonSafe<_181.QueryRedemptionRecordRequest>;
+            fromPartial(object: Partial<_181.QueryRedemptionRecordRequest>): _181.QueryRedemptionRecordRequest;
+            fromProtoMsg(message: _181.QueryRedemptionRecordRequestProtoMsg): _181.QueryRedemptionRecordRequest;
+            toProto(message: _181.QueryRedemptionRecordRequest): Uint8Array;
+            toProtoMsg(message: _181.QueryRedemptionRecordRequest): _181.QueryRedemptionRecordRequestProtoMsg;
+        };
+        QueryRedemptionRecordResponse: {
+            typeUrl: "/stride.stakedym.QueryRedemptionRecordResponse";
+            encode(message: _181.QueryRedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryRedemptionRecordResponse;
+            fromJSON(object: any): _181.QueryRedemptionRecordResponse;
+            toJSON(message: _181.QueryRedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_181.QueryRedemptionRecordResponse>;
+            fromPartial(object: Partial<_181.QueryRedemptionRecordResponse>): _181.QueryRedemptionRecordResponse;
+            fromProtoMsg(message: _181.QueryRedemptionRecordResponseProtoMsg): _181.QueryRedemptionRecordResponse;
+            toProto(message: _181.QueryRedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _181.QueryRedemptionRecordResponse): _181.QueryRedemptionRecordResponseProtoMsg;
+        };
+        QueryRedemptionRecordsRequest: {
+            typeUrl: "/stride.stakedym.QueryRedemptionRecordsRequest";
+            encode(message: _181.QueryRedemptionRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryRedemptionRecordsRequest;
+            fromJSON(object: any): _181.QueryRedemptionRecordsRequest;
+            toJSON(message: _181.QueryRedemptionRecordsRequest): import("../json-safe.ts").JsonSafe<_181.QueryRedemptionRecordsRequest>;
+            fromPartial(object: Partial<_181.QueryRedemptionRecordsRequest>): _181.QueryRedemptionRecordsRequest;
+            fromProtoMsg(message: _181.QueryRedemptionRecordsRequestProtoMsg): _181.QueryRedemptionRecordsRequest;
+            toProto(message: _181.QueryRedemptionRecordsRequest): Uint8Array;
+            toProtoMsg(message: _181.QueryRedemptionRecordsRequest): _181.QueryRedemptionRecordsRequestProtoMsg;
+        };
+        QueryRedemptionRecordsResponse: {
+            typeUrl: "/stride.stakedym.QueryRedemptionRecordsResponse";
+            encode(message: _181.QueryRedemptionRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QueryRedemptionRecordsResponse;
+            fromJSON(object: any): _181.QueryRedemptionRecordsResponse;
+            toJSON(message: _181.QueryRedemptionRecordsResponse): import("../json-safe.ts").JsonSafe<_181.QueryRedemptionRecordsResponse>;
+            fromPartial(object: Partial<_181.QueryRedemptionRecordsResponse>): _181.QueryRedemptionRecordsResponse;
+            fromProtoMsg(message: _181.QueryRedemptionRecordsResponseProtoMsg): _181.QueryRedemptionRecordsResponse;
+            toProto(message: _181.QueryRedemptionRecordsResponse): Uint8Array;
+            toProtoMsg(message: _181.QueryRedemptionRecordsResponse): _181.QueryRedemptionRecordsResponseProtoMsg;
+        };
+        QuerySlashRecordsRequest: {
+            typeUrl: "/stride.stakedym.QuerySlashRecordsRequest";
+            encode(_: _181.QuerySlashRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QuerySlashRecordsRequest;
+            fromJSON(_: any): _181.QuerySlashRecordsRequest;
+            toJSON(_: _181.QuerySlashRecordsRequest): import("../json-safe.ts").JsonSafe<_181.QuerySlashRecordsRequest>;
+            fromPartial(_: Partial<_181.QuerySlashRecordsRequest>): _181.QuerySlashRecordsRequest;
+            fromProtoMsg(message: _181.QuerySlashRecordsRequestProtoMsg): _181.QuerySlashRecordsRequest;
+            toProto(message: _181.QuerySlashRecordsRequest): Uint8Array;
+            toProtoMsg(message: _181.QuerySlashRecordsRequest): _181.QuerySlashRecordsRequestProtoMsg;
+        };
+        QuerySlashRecordsResponse: {
+            typeUrl: "/stride.stakedym.QuerySlashRecordsResponse";
+            encode(message: _181.QuerySlashRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.QuerySlashRecordsResponse;
+            fromJSON(object: any): _181.QuerySlashRecordsResponse;
+            toJSON(message: _181.QuerySlashRecordsResponse): import("../json-safe.ts").JsonSafe<_181.QuerySlashRecordsResponse>;
+            fromPartial(object: Partial<_181.QuerySlashRecordsResponse>): _181.QuerySlashRecordsResponse;
+            fromProtoMsg(message: _181.QuerySlashRecordsResponseProtoMsg): _181.QuerySlashRecordsResponse;
+            toProto(message: _181.QuerySlashRecordsResponse): Uint8Array;
+            toProtoMsg(message: _181.QuerySlashRecordsResponse): _181.QuerySlashRecordsResponseProtoMsg;
+        };
+        RedemptionRecordResponse: {
+            typeUrl: "/stride.stakedym.RedemptionRecordResponse";
+            encode(message: _181.RedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _181.RedemptionRecordResponse;
+            fromJSON(object: any): _181.RedemptionRecordResponse;
+            toJSON(message: _181.RedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_181.RedemptionRecordResponse>;
+            fromPartial(object: Partial<_181.RedemptionRecordResponse>): _181.RedemptionRecordResponse;
+            fromProtoMsg(message: _181.RedemptionRecordResponseProtoMsg): _181.RedemptionRecordResponse;
+            toProto(message: _181.RedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _181.RedemptionRecordResponse): _181.RedemptionRecordResponseProtoMsg;
+        };
+        Params: {
+            typeUrl: "/stride.stakedym.Params";
+            encode(_: _180.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _180.Params;
+            fromJSON(_: any): _180.Params;
+            toJSON(_: _180.Params): import("../json-safe.ts").JsonSafe<_180.Params>;
+            fromPartial(_: Partial<_180.Params>): _180.Params;
+            fromProtoMsg(message: _180.ParamsProtoMsg): _180.Params;
+            toProto(message: _180.Params): Uint8Array;
+            toProtoMsg(message: _180.Params): _180.ParamsProtoMsg;
+        };
+        TransferInProgressRecordIds: {
+            typeUrl: "/stride.stakedym.TransferInProgressRecordIds";
+            encode(message: _180.TransferInProgressRecordIds, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _180.TransferInProgressRecordIds;
+            fromJSON(object: any): _180.TransferInProgressRecordIds;
+            toJSON(message: _180.TransferInProgressRecordIds): import("../json-safe.ts").JsonSafe<_180.TransferInProgressRecordIds>;
+            fromPartial(object: Partial<_180.TransferInProgressRecordIds>): _180.TransferInProgressRecordIds;
+            fromProtoMsg(message: _180.TransferInProgressRecordIdsProtoMsg): _180.TransferInProgressRecordIds;
+            toProto(message: _180.TransferInProgressRecordIds): Uint8Array;
+            toProtoMsg(message: _180.TransferInProgressRecordIds): _180.TransferInProgressRecordIdsProtoMsg;
+        };
+        GenesisState: {
+            typeUrl: "/stride.stakedym.GenesisState";
+            encode(message: _180.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _180.GenesisState;
+            fromJSON(object: any): _180.GenesisState;
+            toJSON(message: _180.GenesisState): import("../json-safe.ts").JsonSafe<_180.GenesisState>;
+            fromPartial(object: Partial<_180.GenesisState>): _180.GenesisState;
+            fromProtoMsg(message: _180.GenesisStateProtoMsg): _180.GenesisState;
+            toProto(message: _180.GenesisState): Uint8Array;
+            toProtoMsg(message: _180.GenesisState): _180.GenesisStateProtoMsg;
+        };
+    };
+    const stakeibc: {
+        Validator: {
+            typeUrl: "/stride.stakeibc.Validator";
+            encode(message: _196.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _196.Validator;
+            fromJSON(object: any): _196.Validator;
+            toJSON(message: _196.Validator): import("../json-safe.ts").JsonSafe<_196.Validator>;
+            fromPartial(object: Partial<_196.Validator>): _196.Validator;
+            fromProtoMsg(message: _196.ValidatorProtoMsg): _196.Validator;
+            toProto(message: _196.Validator): Uint8Array;
+            toProtoMsg(message: _196.Validator): _196.ValidatorProtoMsg;
+        };
+        authzPermissionChangeFromJSON(object: any): _195.AuthzPermissionChange;
+        authzPermissionChangeToJSON(object: _195.AuthzPermissionChange): string;
+        AuthzPermissionChange: typeof _195.AuthzPermissionChange;
+        AuthzPermissionChangeSDKType: typeof _195.AuthzPermissionChange;
+        MsgUpdateInnerRedemptionRateBounds: {
+            typeUrl: "/stride.stakeibc.MsgUpdateInnerRedemptionRateBounds";
+            encode(message: _195.MsgUpdateInnerRedemptionRateBounds, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateInnerRedemptionRateBounds;
+            fromJSON(object: any): _195.MsgUpdateInnerRedemptionRateBounds;
+            toJSON(message: _195.MsgUpdateInnerRedemptionRateBounds): import("../json-safe.ts").JsonSafe<_195.MsgUpdateInnerRedemptionRateBounds>;
+            fromPartial(object: Partial<_195.MsgUpdateInnerRedemptionRateBounds>): _195.MsgUpdateInnerRedemptionRateBounds;
+            fromProtoMsg(message: _195.MsgUpdateInnerRedemptionRateBoundsProtoMsg): _195.MsgUpdateInnerRedemptionRateBounds;
+            toProto(message: _195.MsgUpdateInnerRedemptionRateBounds): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateInnerRedemptionRateBounds): _195.MsgUpdateInnerRedemptionRateBoundsProtoMsg;
+        };
+        MsgUpdateInnerRedemptionRateBoundsResponse: {
+            typeUrl: "/stride.stakeibc.MsgUpdateInnerRedemptionRateBoundsResponse";
+            encode(_: _195.MsgUpdateInnerRedemptionRateBoundsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateInnerRedemptionRateBoundsResponse;
+            fromJSON(_: any): _195.MsgUpdateInnerRedemptionRateBoundsResponse;
+            toJSON(_: _195.MsgUpdateInnerRedemptionRateBoundsResponse): import("../json-safe.ts").JsonSafe<_195.MsgUpdateInnerRedemptionRateBoundsResponse>;
+            fromPartial(_: Partial<_195.MsgUpdateInnerRedemptionRateBoundsResponse>): _195.MsgUpdateInnerRedemptionRateBoundsResponse;
+            fromProtoMsg(message: _195.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg): _195.MsgUpdateInnerRedemptionRateBoundsResponse;
+            toProto(message: _195.MsgUpdateInnerRedemptionRateBoundsResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateInnerRedemptionRateBoundsResponse): _195.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg;
+        };
+        MsgLiquidStake: {
+            typeUrl: "/stride.stakeibc.MsgLiquidStake";
+            encode(message: _195.MsgLiquidStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgLiquidStake;
+            fromJSON(object: any): _195.MsgLiquidStake;
+            toJSON(message: _195.MsgLiquidStake): import("../json-safe.ts").JsonSafe<_195.MsgLiquidStake>;
+            fromPartial(object: Partial<_195.MsgLiquidStake>): _195.MsgLiquidStake;
+            fromProtoMsg(message: _195.MsgLiquidStakeProtoMsg): _195.MsgLiquidStake;
+            toProto(message: _195.MsgLiquidStake): Uint8Array;
+            toProtoMsg(message: _195.MsgLiquidStake): _195.MsgLiquidStakeProtoMsg;
+        };
+        MsgLiquidStakeResponse: {
+            typeUrl: "/stride.stakeibc.MsgLiquidStakeResponse";
+            encode(message: _195.MsgLiquidStakeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgLiquidStakeResponse;
+            fromJSON(object: any): _195.MsgLiquidStakeResponse;
+            toJSON(message: _195.MsgLiquidStakeResponse): import("../json-safe.ts").JsonSafe<_195.MsgLiquidStakeResponse>;
+            fromPartial(object: Partial<_195.MsgLiquidStakeResponse>): _195.MsgLiquidStakeResponse;
+            fromProtoMsg(message: _195.MsgLiquidStakeResponseProtoMsg): _195.MsgLiquidStakeResponse;
+            toProto(message: _195.MsgLiquidStakeResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgLiquidStakeResponse): _195.MsgLiquidStakeResponseProtoMsg;
+        };
+        MsgLSMLiquidStake: {
+            typeUrl: "/stride.stakeibc.MsgLSMLiquidStake";
+            encode(message: _195.MsgLSMLiquidStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgLSMLiquidStake;
+            fromJSON(object: any): _195.MsgLSMLiquidStake;
+            toJSON(message: _195.MsgLSMLiquidStake): import("../json-safe.ts").JsonSafe<_195.MsgLSMLiquidStake>;
+            fromPartial(object: Partial<_195.MsgLSMLiquidStake>): _195.MsgLSMLiquidStake;
+            fromProtoMsg(message: _195.MsgLSMLiquidStakeProtoMsg): _195.MsgLSMLiquidStake;
+            toProto(message: _195.MsgLSMLiquidStake): Uint8Array;
+            toProtoMsg(message: _195.MsgLSMLiquidStake): _195.MsgLSMLiquidStakeProtoMsg;
+        };
+        MsgLSMLiquidStakeResponse: {
+            typeUrl: "/stride.stakeibc.MsgLSMLiquidStakeResponse";
+            encode(message: _195.MsgLSMLiquidStakeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgLSMLiquidStakeResponse;
+            fromJSON(object: any): _195.MsgLSMLiquidStakeResponse;
+            toJSON(message: _195.MsgLSMLiquidStakeResponse): import("../json-safe.ts").JsonSafe<_195.MsgLSMLiquidStakeResponse>;
+            fromPartial(object: Partial<_195.MsgLSMLiquidStakeResponse>): _195.MsgLSMLiquidStakeResponse;
+            fromProtoMsg(message: _195.MsgLSMLiquidStakeResponseProtoMsg): _195.MsgLSMLiquidStakeResponse;
+            toProto(message: _195.MsgLSMLiquidStakeResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgLSMLiquidStakeResponse): _195.MsgLSMLiquidStakeResponseProtoMsg;
+        };
+        MsgClearBalance: {
+            typeUrl: "/stride.stakeibc.MsgClearBalance";
+            encode(message: _195.MsgClearBalance, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgClearBalance;
+            fromJSON(object: any): _195.MsgClearBalance;
+            toJSON(message: _195.MsgClearBalance): import("../json-safe.ts").JsonSafe<_195.MsgClearBalance>;
+            fromPartial(object: Partial<_195.MsgClearBalance>): _195.MsgClearBalance;
+            fromProtoMsg(message: _195.MsgClearBalanceProtoMsg): _195.MsgClearBalance;
+            toProto(message: _195.MsgClearBalance): Uint8Array;
+            toProtoMsg(message: _195.MsgClearBalance): _195.MsgClearBalanceProtoMsg;
+        };
+        MsgClearBalanceResponse: {
+            typeUrl: "/stride.stakeibc.MsgClearBalanceResponse";
+            encode(_: _195.MsgClearBalanceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgClearBalanceResponse;
+            fromJSON(_: any): _195.MsgClearBalanceResponse;
+            toJSON(_: _195.MsgClearBalanceResponse): import("../json-safe.ts").JsonSafe<_195.MsgClearBalanceResponse>;
+            fromPartial(_: Partial<_195.MsgClearBalanceResponse>): _195.MsgClearBalanceResponse;
+            fromProtoMsg(message: _195.MsgClearBalanceResponseProtoMsg): _195.MsgClearBalanceResponse;
+            toProto(message: _195.MsgClearBalanceResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgClearBalanceResponse): _195.MsgClearBalanceResponseProtoMsg;
+        };
+        MsgRedeemStake: {
+            typeUrl: "/stride.stakeibc.MsgRedeemStake";
+            encode(message: _195.MsgRedeemStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRedeemStake;
+            fromJSON(object: any): _195.MsgRedeemStake;
+            toJSON(message: _195.MsgRedeemStake): import("../json-safe.ts").JsonSafe<_195.MsgRedeemStake>;
+            fromPartial(object: Partial<_195.MsgRedeemStake>): _195.MsgRedeemStake;
+            fromProtoMsg(message: _195.MsgRedeemStakeProtoMsg): _195.MsgRedeemStake;
+            toProto(message: _195.MsgRedeemStake): Uint8Array;
+            toProtoMsg(message: _195.MsgRedeemStake): _195.MsgRedeemStakeProtoMsg;
+        };
+        MsgRedeemStakeResponse: {
+            typeUrl: "/stride.stakeibc.MsgRedeemStakeResponse";
+            encode(_: _195.MsgRedeemStakeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRedeemStakeResponse;
+            fromJSON(_: any): _195.MsgRedeemStakeResponse;
+            toJSON(_: _195.MsgRedeemStakeResponse): import("../json-safe.ts").JsonSafe<_195.MsgRedeemStakeResponse>;
+            fromPartial(_: Partial<_195.MsgRedeemStakeResponse>): _195.MsgRedeemStakeResponse;
+            fromProtoMsg(message: _195.MsgRedeemStakeResponseProtoMsg): _195.MsgRedeemStakeResponse;
+            toProto(message: _195.MsgRedeemStakeResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgRedeemStakeResponse): _195.MsgRedeemStakeResponseProtoMsg;
+        };
+        MsgRegisterHostZone: {
+            typeUrl: "/stride.stakeibc.MsgRegisterHostZone";
+            encode(message: _195.MsgRegisterHostZone, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRegisterHostZone;
+            fromJSON(object: any): _195.MsgRegisterHostZone;
+            toJSON(message: _195.MsgRegisterHostZone): import("../json-safe.ts").JsonSafe<_195.MsgRegisterHostZone>;
+            fromPartial(object: Partial<_195.MsgRegisterHostZone>): _195.MsgRegisterHostZone;
+            fromProtoMsg(message: _195.MsgRegisterHostZoneProtoMsg): _195.MsgRegisterHostZone;
+            toProto(message: _195.MsgRegisterHostZone): Uint8Array;
+            toProtoMsg(message: _195.MsgRegisterHostZone): _195.MsgRegisterHostZoneProtoMsg;
+        };
+        MsgRegisterHostZoneResponse: {
+            typeUrl: "/stride.stakeibc.MsgRegisterHostZoneResponse";
+            encode(_: _195.MsgRegisterHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRegisterHostZoneResponse;
+            fromJSON(_: any): _195.MsgRegisterHostZoneResponse;
+            toJSON(_: _195.MsgRegisterHostZoneResponse): import("../json-safe.ts").JsonSafe<_195.MsgRegisterHostZoneResponse>;
+            fromPartial(_: Partial<_195.MsgRegisterHostZoneResponse>): _195.MsgRegisterHostZoneResponse;
+            fromProtoMsg(message: _195.MsgRegisterHostZoneResponseProtoMsg): _195.MsgRegisterHostZoneResponse;
+            toProto(message: _195.MsgRegisterHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgRegisterHostZoneResponse): _195.MsgRegisterHostZoneResponseProtoMsg;
+        };
+        MsgClaimUndelegatedTokens: {
+            typeUrl: "/stride.stakeibc.MsgClaimUndelegatedTokens";
+            encode(message: _195.MsgClaimUndelegatedTokens, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgClaimUndelegatedTokens;
+            fromJSON(object: any): _195.MsgClaimUndelegatedTokens;
+            toJSON(message: _195.MsgClaimUndelegatedTokens): import("../json-safe.ts").JsonSafe<_195.MsgClaimUndelegatedTokens>;
+            fromPartial(object: Partial<_195.MsgClaimUndelegatedTokens>): _195.MsgClaimUndelegatedTokens;
+            fromProtoMsg(message: _195.MsgClaimUndelegatedTokensProtoMsg): _195.MsgClaimUndelegatedTokens;
+            toProto(message: _195.MsgClaimUndelegatedTokens): Uint8Array;
+            toProtoMsg(message: _195.MsgClaimUndelegatedTokens): _195.MsgClaimUndelegatedTokensProtoMsg;
+        };
+        MsgClaimUndelegatedTokensResponse: {
+            typeUrl: "/stride.stakeibc.MsgClaimUndelegatedTokensResponse";
+            encode(_: _195.MsgClaimUndelegatedTokensResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgClaimUndelegatedTokensResponse;
+            fromJSON(_: any): _195.MsgClaimUndelegatedTokensResponse;
+            toJSON(_: _195.MsgClaimUndelegatedTokensResponse): import("../json-safe.ts").JsonSafe<_195.MsgClaimUndelegatedTokensResponse>;
+            fromPartial(_: Partial<_195.MsgClaimUndelegatedTokensResponse>): _195.MsgClaimUndelegatedTokensResponse;
+            fromProtoMsg(message: _195.MsgClaimUndelegatedTokensResponseProtoMsg): _195.MsgClaimUndelegatedTokensResponse;
+            toProto(message: _195.MsgClaimUndelegatedTokensResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgClaimUndelegatedTokensResponse): _195.MsgClaimUndelegatedTokensResponseProtoMsg;
+        };
+        MsgRebalanceValidators: {
+            typeUrl: "/stride.stakeibc.MsgRebalanceValidators";
+            encode(message: _195.MsgRebalanceValidators, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRebalanceValidators;
+            fromJSON(object: any): _195.MsgRebalanceValidators;
+            toJSON(message: _195.MsgRebalanceValidators): import("../json-safe.ts").JsonSafe<_195.MsgRebalanceValidators>;
+            fromPartial(object: Partial<_195.MsgRebalanceValidators>): _195.MsgRebalanceValidators;
+            fromProtoMsg(message: _195.MsgRebalanceValidatorsProtoMsg): _195.MsgRebalanceValidators;
+            toProto(message: _195.MsgRebalanceValidators): Uint8Array;
+            toProtoMsg(message: _195.MsgRebalanceValidators): _195.MsgRebalanceValidatorsProtoMsg;
+        };
+        MsgRebalanceValidatorsResponse: {
+            typeUrl: "/stride.stakeibc.MsgRebalanceValidatorsResponse";
+            encode(_: _195.MsgRebalanceValidatorsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRebalanceValidatorsResponse;
+            fromJSON(_: any): _195.MsgRebalanceValidatorsResponse;
+            toJSON(_: _195.MsgRebalanceValidatorsResponse): import("../json-safe.ts").JsonSafe<_195.MsgRebalanceValidatorsResponse>;
+            fromPartial(_: Partial<_195.MsgRebalanceValidatorsResponse>): _195.MsgRebalanceValidatorsResponse;
+            fromProtoMsg(message: _195.MsgRebalanceValidatorsResponseProtoMsg): _195.MsgRebalanceValidatorsResponse;
+            toProto(message: _195.MsgRebalanceValidatorsResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgRebalanceValidatorsResponse): _195.MsgRebalanceValidatorsResponseProtoMsg;
+        };
+        MsgAddValidators: {
+            typeUrl: "/stride.stakeibc.MsgAddValidators";
+            encode(message: _195.MsgAddValidators, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgAddValidators;
+            fromJSON(object: any): _195.MsgAddValidators;
+            toJSON(message: _195.MsgAddValidators): import("../json-safe.ts").JsonSafe<_195.MsgAddValidators>;
+            fromPartial(object: Partial<_195.MsgAddValidators>): _195.MsgAddValidators;
+            fromProtoMsg(message: _195.MsgAddValidatorsProtoMsg): _195.MsgAddValidators;
+            toProto(message: _195.MsgAddValidators): Uint8Array;
+            toProtoMsg(message: _195.MsgAddValidators): _195.MsgAddValidatorsProtoMsg;
+        };
+        MsgAddValidatorsResponse: {
+            typeUrl: "/stride.stakeibc.MsgAddValidatorsResponse";
+            encode(_: _195.MsgAddValidatorsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgAddValidatorsResponse;
+            fromJSON(_: any): _195.MsgAddValidatorsResponse;
+            toJSON(_: _195.MsgAddValidatorsResponse): import("../json-safe.ts").JsonSafe<_195.MsgAddValidatorsResponse>;
+            fromPartial(_: Partial<_195.MsgAddValidatorsResponse>): _195.MsgAddValidatorsResponse;
+            fromProtoMsg(message: _195.MsgAddValidatorsResponseProtoMsg): _195.MsgAddValidatorsResponse;
+            toProto(message: _195.MsgAddValidatorsResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgAddValidatorsResponse): _195.MsgAddValidatorsResponseProtoMsg;
+        };
+        ValidatorWeight: {
+            typeUrl: "/stride.stakeibc.ValidatorWeight";
+            encode(message: _195.ValidatorWeight, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.ValidatorWeight;
+            fromJSON(object: any): _195.ValidatorWeight;
+            toJSON(message: _195.ValidatorWeight): import("../json-safe.ts").JsonSafe<_195.ValidatorWeight>;
+            fromPartial(object: Partial<_195.ValidatorWeight>): _195.ValidatorWeight;
+            fromProtoMsg(message: _195.ValidatorWeightProtoMsg): _195.ValidatorWeight;
+            toProto(message: _195.ValidatorWeight): Uint8Array;
+            toProtoMsg(message: _195.ValidatorWeight): _195.ValidatorWeightProtoMsg;
+        };
+        MsgChangeValidatorWeights: {
+            typeUrl: "/stride.stakeibc.MsgChangeValidatorWeights";
+            encode(message: _195.MsgChangeValidatorWeights, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgChangeValidatorWeights;
+            fromJSON(object: any): _195.MsgChangeValidatorWeights;
+            toJSON(message: _195.MsgChangeValidatorWeights): import("../json-safe.ts").JsonSafe<_195.MsgChangeValidatorWeights>;
+            fromPartial(object: Partial<_195.MsgChangeValidatorWeights>): _195.MsgChangeValidatorWeights;
+            fromProtoMsg(message: _195.MsgChangeValidatorWeightsProtoMsg): _195.MsgChangeValidatorWeights;
+            toProto(message: _195.MsgChangeValidatorWeights): Uint8Array;
+            toProtoMsg(message: _195.MsgChangeValidatorWeights): _195.MsgChangeValidatorWeightsProtoMsg;
+        };
+        MsgChangeValidatorWeightsResponse: {
+            typeUrl: "/stride.stakeibc.MsgChangeValidatorWeightsResponse";
+            encode(_: _195.MsgChangeValidatorWeightsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgChangeValidatorWeightsResponse;
+            fromJSON(_: any): _195.MsgChangeValidatorWeightsResponse;
+            toJSON(_: _195.MsgChangeValidatorWeightsResponse): import("../json-safe.ts").JsonSafe<_195.MsgChangeValidatorWeightsResponse>;
+            fromPartial(_: Partial<_195.MsgChangeValidatorWeightsResponse>): _195.MsgChangeValidatorWeightsResponse;
+            fromProtoMsg(message: _195.MsgChangeValidatorWeightsResponseProtoMsg): _195.MsgChangeValidatorWeightsResponse;
+            toProto(message: _195.MsgChangeValidatorWeightsResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgChangeValidatorWeightsResponse): _195.MsgChangeValidatorWeightsResponseProtoMsg;
+        };
+        MsgDeleteValidator: {
+            typeUrl: "/stride.stakeibc.MsgDeleteValidator";
+            encode(message: _195.MsgDeleteValidator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgDeleteValidator;
+            fromJSON(object: any): _195.MsgDeleteValidator;
+            toJSON(message: _195.MsgDeleteValidator): import("../json-safe.ts").JsonSafe<_195.MsgDeleteValidator>;
+            fromPartial(object: Partial<_195.MsgDeleteValidator>): _195.MsgDeleteValidator;
+            fromProtoMsg(message: _195.MsgDeleteValidatorProtoMsg): _195.MsgDeleteValidator;
+            toProto(message: _195.MsgDeleteValidator): Uint8Array;
+            toProtoMsg(message: _195.MsgDeleteValidator): _195.MsgDeleteValidatorProtoMsg;
+        };
+        MsgDeleteValidatorResponse: {
+            typeUrl: "/stride.stakeibc.MsgDeleteValidatorResponse";
+            encode(_: _195.MsgDeleteValidatorResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgDeleteValidatorResponse;
+            fromJSON(_: any): _195.MsgDeleteValidatorResponse;
+            toJSON(_: _195.MsgDeleteValidatorResponse): import("../json-safe.ts").JsonSafe<_195.MsgDeleteValidatorResponse>;
+            fromPartial(_: Partial<_195.MsgDeleteValidatorResponse>): _195.MsgDeleteValidatorResponse;
+            fromProtoMsg(message: _195.MsgDeleteValidatorResponseProtoMsg): _195.MsgDeleteValidatorResponse;
+            toProto(message: _195.MsgDeleteValidatorResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgDeleteValidatorResponse): _195.MsgDeleteValidatorResponseProtoMsg;
+        };
+        MsgRestoreInterchainAccount: {
+            typeUrl: "/stride.stakeibc.MsgRestoreInterchainAccount";
+            encode(message: _195.MsgRestoreInterchainAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRestoreInterchainAccount;
+            fromJSON(object: any): _195.MsgRestoreInterchainAccount;
+            toJSON(message: _195.MsgRestoreInterchainAccount): import("../json-safe.ts").JsonSafe<_195.MsgRestoreInterchainAccount>;
+            fromPartial(object: Partial<_195.MsgRestoreInterchainAccount>): _195.MsgRestoreInterchainAccount;
+            fromProtoMsg(message: _195.MsgRestoreInterchainAccountProtoMsg): _195.MsgRestoreInterchainAccount;
+            toProto(message: _195.MsgRestoreInterchainAccount): Uint8Array;
+            toProtoMsg(message: _195.MsgRestoreInterchainAccount): _195.MsgRestoreInterchainAccountProtoMsg;
+        };
+        MsgRestoreInterchainAccountResponse: {
+            typeUrl: "/stride.stakeibc.MsgRestoreInterchainAccountResponse";
+            encode(_: _195.MsgRestoreInterchainAccountResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgRestoreInterchainAccountResponse;
+            fromJSON(_: any): _195.MsgRestoreInterchainAccountResponse;
+            toJSON(_: _195.MsgRestoreInterchainAccountResponse): import("../json-safe.ts").JsonSafe<_195.MsgRestoreInterchainAccountResponse>;
+            fromPartial(_: Partial<_195.MsgRestoreInterchainAccountResponse>): _195.MsgRestoreInterchainAccountResponse;
+            fromProtoMsg(message: _195.MsgRestoreInterchainAccountResponseProtoMsg): _195.MsgRestoreInterchainAccountResponse;
+            toProto(message: _195.MsgRestoreInterchainAccountResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgRestoreInterchainAccountResponse): _195.MsgRestoreInterchainAccountResponseProtoMsg;
+        };
+        MsgCloseDelegationChannel: {
+            typeUrl: "/stride.stakeibc.MsgCloseDelegationChannel";
+            encode(message: _195.MsgCloseDelegationChannel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgCloseDelegationChannel;
+            fromJSON(object: any): _195.MsgCloseDelegationChannel;
+            toJSON(message: _195.MsgCloseDelegationChannel): import("../json-safe.ts").JsonSafe<_195.MsgCloseDelegationChannel>;
+            fromPartial(object: Partial<_195.MsgCloseDelegationChannel>): _195.MsgCloseDelegationChannel;
+            fromProtoMsg(message: _195.MsgCloseDelegationChannelProtoMsg): _195.MsgCloseDelegationChannel;
+            toProto(message: _195.MsgCloseDelegationChannel): Uint8Array;
+            toProtoMsg(message: _195.MsgCloseDelegationChannel): _195.MsgCloseDelegationChannelProtoMsg;
+        };
+        MsgCloseDelegationChannelResponse: {
+            typeUrl: "/stride.stakeibc.MsgCloseDelegationChannelResponse";
+            encode(_: _195.MsgCloseDelegationChannelResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgCloseDelegationChannelResponse;
+            fromJSON(_: any): _195.MsgCloseDelegationChannelResponse;
+            toJSON(_: _195.MsgCloseDelegationChannelResponse): import("../json-safe.ts").JsonSafe<_195.MsgCloseDelegationChannelResponse>;
+            fromPartial(_: Partial<_195.MsgCloseDelegationChannelResponse>): _195.MsgCloseDelegationChannelResponse;
+            fromProtoMsg(message: _195.MsgCloseDelegationChannelResponseProtoMsg): _195.MsgCloseDelegationChannelResponse;
+            toProto(message: _195.MsgCloseDelegationChannelResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgCloseDelegationChannelResponse): _195.MsgCloseDelegationChannelResponseProtoMsg;
+        };
+        MsgUpdateValidatorSharesExchRate: {
+            typeUrl: "/stride.stakeibc.MsgUpdateValidatorSharesExchRate";
+            encode(message: _195.MsgUpdateValidatorSharesExchRate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateValidatorSharesExchRate;
+            fromJSON(object: any): _195.MsgUpdateValidatorSharesExchRate;
+            toJSON(message: _195.MsgUpdateValidatorSharesExchRate): import("../json-safe.ts").JsonSafe<_195.MsgUpdateValidatorSharesExchRate>;
+            fromPartial(object: Partial<_195.MsgUpdateValidatorSharesExchRate>): _195.MsgUpdateValidatorSharesExchRate;
+            fromProtoMsg(message: _195.MsgUpdateValidatorSharesExchRateProtoMsg): _195.MsgUpdateValidatorSharesExchRate;
+            toProto(message: _195.MsgUpdateValidatorSharesExchRate): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateValidatorSharesExchRate): _195.MsgUpdateValidatorSharesExchRateProtoMsg;
+        };
+        MsgUpdateValidatorSharesExchRateResponse: {
+            typeUrl: "/stride.stakeibc.MsgUpdateValidatorSharesExchRateResponse";
+            encode(_: _195.MsgUpdateValidatorSharesExchRateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateValidatorSharesExchRateResponse;
+            fromJSON(_: any): _195.MsgUpdateValidatorSharesExchRateResponse;
+            toJSON(_: _195.MsgUpdateValidatorSharesExchRateResponse): import("../json-safe.ts").JsonSafe<_195.MsgUpdateValidatorSharesExchRateResponse>;
+            fromPartial(_: Partial<_195.MsgUpdateValidatorSharesExchRateResponse>): _195.MsgUpdateValidatorSharesExchRateResponse;
+            fromProtoMsg(message: _195.MsgUpdateValidatorSharesExchRateResponseProtoMsg): _195.MsgUpdateValidatorSharesExchRateResponse;
+            toProto(message: _195.MsgUpdateValidatorSharesExchRateResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateValidatorSharesExchRateResponse): _195.MsgUpdateValidatorSharesExchRateResponseProtoMsg;
+        };
+        MsgCalibrateDelegation: {
+            typeUrl: "/stride.stakeibc.MsgCalibrateDelegation";
+            encode(message: _195.MsgCalibrateDelegation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgCalibrateDelegation;
+            fromJSON(object: any): _195.MsgCalibrateDelegation;
+            toJSON(message: _195.MsgCalibrateDelegation): import("../json-safe.ts").JsonSafe<_195.MsgCalibrateDelegation>;
+            fromPartial(object: Partial<_195.MsgCalibrateDelegation>): _195.MsgCalibrateDelegation;
+            fromProtoMsg(message: _195.MsgCalibrateDelegationProtoMsg): _195.MsgCalibrateDelegation;
+            toProto(message: _195.MsgCalibrateDelegation): Uint8Array;
+            toProtoMsg(message: _195.MsgCalibrateDelegation): _195.MsgCalibrateDelegationProtoMsg;
+        };
+        MsgCalibrateDelegationResponse: {
+            typeUrl: "/stride.stakeibc.MsgCalibrateDelegationResponse";
+            encode(_: _195.MsgCalibrateDelegationResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgCalibrateDelegationResponse;
+            fromJSON(_: any): _195.MsgCalibrateDelegationResponse;
+            toJSON(_: _195.MsgCalibrateDelegationResponse): import("../json-safe.ts").JsonSafe<_195.MsgCalibrateDelegationResponse>;
+            fromPartial(_: Partial<_195.MsgCalibrateDelegationResponse>): _195.MsgCalibrateDelegationResponse;
+            fromProtoMsg(message: _195.MsgCalibrateDelegationResponseProtoMsg): _195.MsgCalibrateDelegationResponse;
+            toProto(message: _195.MsgCalibrateDelegationResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgCalibrateDelegationResponse): _195.MsgCalibrateDelegationResponseProtoMsg;
+        };
+        MsgResumeHostZone: {
+            typeUrl: "/stride.stakeibc.MsgResumeHostZone";
+            encode(message: _195.MsgResumeHostZone, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgResumeHostZone;
+            fromJSON(object: any): _195.MsgResumeHostZone;
+            toJSON(message: _195.MsgResumeHostZone): import("../json-safe.ts").JsonSafe<_195.MsgResumeHostZone>;
+            fromPartial(object: Partial<_195.MsgResumeHostZone>): _195.MsgResumeHostZone;
+            fromProtoMsg(message: _195.MsgResumeHostZoneProtoMsg): _195.MsgResumeHostZone;
+            toProto(message: _195.MsgResumeHostZone): Uint8Array;
+            toProtoMsg(message: _195.MsgResumeHostZone): _195.MsgResumeHostZoneProtoMsg;
+        };
+        MsgResumeHostZoneResponse: {
+            typeUrl: "/stride.stakeibc.MsgResumeHostZoneResponse";
+            encode(_: _195.MsgResumeHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgResumeHostZoneResponse;
+            fromJSON(_: any): _195.MsgResumeHostZoneResponse;
+            toJSON(_: _195.MsgResumeHostZoneResponse): import("../json-safe.ts").JsonSafe<_195.MsgResumeHostZoneResponse>;
+            fromPartial(_: Partial<_195.MsgResumeHostZoneResponse>): _195.MsgResumeHostZoneResponse;
+            fromProtoMsg(message: _195.MsgResumeHostZoneResponseProtoMsg): _195.MsgResumeHostZoneResponse;
+            toProto(message: _195.MsgResumeHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgResumeHostZoneResponse): _195.MsgResumeHostZoneResponseProtoMsg;
+        };
+        MsgCreateTradeRoute: {
+            typeUrl: "/stride.stakeibc.MsgCreateTradeRoute";
+            encode(message: _195.MsgCreateTradeRoute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgCreateTradeRoute;
+            fromJSON(object: any): _195.MsgCreateTradeRoute;
+            toJSON(message: _195.MsgCreateTradeRoute): import("../json-safe.ts").JsonSafe<_195.MsgCreateTradeRoute>;
+            fromPartial(object: Partial<_195.MsgCreateTradeRoute>): _195.MsgCreateTradeRoute;
+            fromProtoMsg(message: _195.MsgCreateTradeRouteProtoMsg): _195.MsgCreateTradeRoute;
+            toProto(message: _195.MsgCreateTradeRoute): Uint8Array;
+            toProtoMsg(message: _195.MsgCreateTradeRoute): _195.MsgCreateTradeRouteProtoMsg;
+        };
+        MsgCreateTradeRouteResponse: {
+            typeUrl: "/stride.stakeibc.MsgCreateTradeRouteResponse";
+            encode(_: _195.MsgCreateTradeRouteResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgCreateTradeRouteResponse;
+            fromJSON(_: any): _195.MsgCreateTradeRouteResponse;
+            toJSON(_: _195.MsgCreateTradeRouteResponse): import("../json-safe.ts").JsonSafe<_195.MsgCreateTradeRouteResponse>;
+            fromPartial(_: Partial<_195.MsgCreateTradeRouteResponse>): _195.MsgCreateTradeRouteResponse;
+            fromProtoMsg(message: _195.MsgCreateTradeRouteResponseProtoMsg): _195.MsgCreateTradeRouteResponse;
+            toProto(message: _195.MsgCreateTradeRouteResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgCreateTradeRouteResponse): _195.MsgCreateTradeRouteResponseProtoMsg;
+        };
+        MsgDeleteTradeRoute: {
+            typeUrl: "/stride.stakeibc.MsgDeleteTradeRoute";
+            encode(message: _195.MsgDeleteTradeRoute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgDeleteTradeRoute;
+            fromJSON(object: any): _195.MsgDeleteTradeRoute;
+            toJSON(message: _195.MsgDeleteTradeRoute): import("../json-safe.ts").JsonSafe<_195.MsgDeleteTradeRoute>;
+            fromPartial(object: Partial<_195.MsgDeleteTradeRoute>): _195.MsgDeleteTradeRoute;
+            fromProtoMsg(message: _195.MsgDeleteTradeRouteProtoMsg): _195.MsgDeleteTradeRoute;
+            toProto(message: _195.MsgDeleteTradeRoute): Uint8Array;
+            toProtoMsg(message: _195.MsgDeleteTradeRoute): _195.MsgDeleteTradeRouteProtoMsg;
+        };
+        MsgDeleteTradeRouteResponse: {
+            typeUrl: "/stride.stakeibc.MsgDeleteTradeRouteResponse";
+            encode(_: _195.MsgDeleteTradeRouteResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgDeleteTradeRouteResponse;
+            fromJSON(_: any): _195.MsgDeleteTradeRouteResponse;
+            toJSON(_: _195.MsgDeleteTradeRouteResponse): import("../json-safe.ts").JsonSafe<_195.MsgDeleteTradeRouteResponse>;
+            fromPartial(_: Partial<_195.MsgDeleteTradeRouteResponse>): _195.MsgDeleteTradeRouteResponse;
+            fromProtoMsg(message: _195.MsgDeleteTradeRouteResponseProtoMsg): _195.MsgDeleteTradeRouteResponse;
+            toProto(message: _195.MsgDeleteTradeRouteResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgDeleteTradeRouteResponse): _195.MsgDeleteTradeRouteResponseProtoMsg;
+        };
+        MsgUpdateTradeRoute: {
+            typeUrl: "/stride.stakeibc.MsgUpdateTradeRoute";
+            encode(message: _195.MsgUpdateTradeRoute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateTradeRoute;
+            fromJSON(object: any): _195.MsgUpdateTradeRoute;
+            toJSON(message: _195.MsgUpdateTradeRoute): import("../json-safe.ts").JsonSafe<_195.MsgUpdateTradeRoute>;
+            fromPartial(object: Partial<_195.MsgUpdateTradeRoute>): _195.MsgUpdateTradeRoute;
+            fromProtoMsg(message: _195.MsgUpdateTradeRouteProtoMsg): _195.MsgUpdateTradeRoute;
+            toProto(message: _195.MsgUpdateTradeRoute): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateTradeRoute): _195.MsgUpdateTradeRouteProtoMsg;
+        };
+        MsgUpdateTradeRouteResponse: {
+            typeUrl: "/stride.stakeibc.MsgUpdateTradeRouteResponse";
+            encode(_: _195.MsgUpdateTradeRouteResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateTradeRouteResponse;
+            fromJSON(_: any): _195.MsgUpdateTradeRouteResponse;
+            toJSON(_: _195.MsgUpdateTradeRouteResponse): import("../json-safe.ts").JsonSafe<_195.MsgUpdateTradeRouteResponse>;
+            fromPartial(_: Partial<_195.MsgUpdateTradeRouteResponse>): _195.MsgUpdateTradeRouteResponse;
+            fromProtoMsg(message: _195.MsgUpdateTradeRouteResponseProtoMsg): _195.MsgUpdateTradeRouteResponse;
+            toProto(message: _195.MsgUpdateTradeRouteResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateTradeRouteResponse): _195.MsgUpdateTradeRouteResponseProtoMsg;
+        };
+        MsgSetCommunityPoolRebate: {
+            typeUrl: "/stride.stakeibc.MsgSetCommunityPoolRebate";
+            encode(message: _195.MsgSetCommunityPoolRebate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgSetCommunityPoolRebate;
+            fromJSON(object: any): _195.MsgSetCommunityPoolRebate;
+            toJSON(message: _195.MsgSetCommunityPoolRebate): import("../json-safe.ts").JsonSafe<_195.MsgSetCommunityPoolRebate>;
+            fromPartial(object: Partial<_195.MsgSetCommunityPoolRebate>): _195.MsgSetCommunityPoolRebate;
+            fromProtoMsg(message: _195.MsgSetCommunityPoolRebateProtoMsg): _195.MsgSetCommunityPoolRebate;
+            toProto(message: _195.MsgSetCommunityPoolRebate): Uint8Array;
+            toProtoMsg(message: _195.MsgSetCommunityPoolRebate): _195.MsgSetCommunityPoolRebateProtoMsg;
+        };
+        MsgSetCommunityPoolRebateResponse: {
+            typeUrl: "/stride.stakeibc.MsgSetCommunityPoolRebateResponse";
+            encode(_: _195.MsgSetCommunityPoolRebateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgSetCommunityPoolRebateResponse;
+            fromJSON(_: any): _195.MsgSetCommunityPoolRebateResponse;
+            toJSON(_: _195.MsgSetCommunityPoolRebateResponse): import("../json-safe.ts").JsonSafe<_195.MsgSetCommunityPoolRebateResponse>;
+            fromPartial(_: Partial<_195.MsgSetCommunityPoolRebateResponse>): _195.MsgSetCommunityPoolRebateResponse;
+            fromProtoMsg(message: _195.MsgSetCommunityPoolRebateResponseProtoMsg): _195.MsgSetCommunityPoolRebateResponse;
+            toProto(message: _195.MsgSetCommunityPoolRebateResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgSetCommunityPoolRebateResponse): _195.MsgSetCommunityPoolRebateResponseProtoMsg;
+        };
+        MsgToggleTradeController: {
+            typeUrl: "/stride.stakeibc.MsgToggleTradeController";
+            encode(message: _195.MsgToggleTradeController, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgToggleTradeController;
+            fromJSON(object: any): _195.MsgToggleTradeController;
+            toJSON(message: _195.MsgToggleTradeController): import("../json-safe.ts").JsonSafe<_195.MsgToggleTradeController>;
+            fromPartial(object: Partial<_195.MsgToggleTradeController>): _195.MsgToggleTradeController;
+            fromProtoMsg(message: _195.MsgToggleTradeControllerProtoMsg): _195.MsgToggleTradeController;
+            toProto(message: _195.MsgToggleTradeController): Uint8Array;
+            toProtoMsg(message: _195.MsgToggleTradeController): _195.MsgToggleTradeControllerProtoMsg;
+        };
+        MsgToggleTradeControllerResponse: {
+            typeUrl: "/stride.stakeibc.MsgToggleTradeControllerResponse";
+            encode(_: _195.MsgToggleTradeControllerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgToggleTradeControllerResponse;
+            fromJSON(_: any): _195.MsgToggleTradeControllerResponse;
+            toJSON(_: _195.MsgToggleTradeControllerResponse): import("../json-safe.ts").JsonSafe<_195.MsgToggleTradeControllerResponse>;
+            fromPartial(_: Partial<_195.MsgToggleTradeControllerResponse>): _195.MsgToggleTradeControllerResponse;
+            fromProtoMsg(message: _195.MsgToggleTradeControllerResponseProtoMsg): _195.MsgToggleTradeControllerResponse;
+            toProto(message: _195.MsgToggleTradeControllerResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgToggleTradeControllerResponse): _195.MsgToggleTradeControllerResponseProtoMsg;
+        };
+        MsgUpdateHostZoneParams: {
+            typeUrl: "/stride.stakeibc.MsgUpdateHostZoneParams";
+            encode(message: _195.MsgUpdateHostZoneParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateHostZoneParams;
+            fromJSON(object: any): _195.MsgUpdateHostZoneParams;
+            toJSON(message: _195.MsgUpdateHostZoneParams): import("../json-safe.ts").JsonSafe<_195.MsgUpdateHostZoneParams>;
+            fromPartial(object: Partial<_195.MsgUpdateHostZoneParams>): _195.MsgUpdateHostZoneParams;
+            fromProtoMsg(message: _195.MsgUpdateHostZoneParamsProtoMsg): _195.MsgUpdateHostZoneParams;
+            toProto(message: _195.MsgUpdateHostZoneParams): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateHostZoneParams): _195.MsgUpdateHostZoneParamsProtoMsg;
+        };
+        MsgUpdateHostZoneParamsResponse: {
+            typeUrl: "/stride.stakeibc.MsgUpdateHostZoneParamsResponse";
+            encode(_: _195.MsgUpdateHostZoneParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _195.MsgUpdateHostZoneParamsResponse;
+            fromJSON(_: any): _195.MsgUpdateHostZoneParamsResponse;
+            toJSON(_: _195.MsgUpdateHostZoneParamsResponse): import("../json-safe.ts").JsonSafe<_195.MsgUpdateHostZoneParamsResponse>;
+            fromPartial(_: Partial<_195.MsgUpdateHostZoneParamsResponse>): _195.MsgUpdateHostZoneParamsResponse;
+            fromProtoMsg(message: _195.MsgUpdateHostZoneParamsResponseProtoMsg): _195.MsgUpdateHostZoneParamsResponse;
+            toProto(message: _195.MsgUpdateHostZoneParamsResponse): Uint8Array;
+            toProtoMsg(message: _195.MsgUpdateHostZoneParamsResponse): _195.MsgUpdateHostZoneParamsResponseProtoMsg;
+        };
+        TradeConfig: {
+            typeUrl: "/stride.stakeibc.TradeConfig";
+            encode(message: _194.TradeConfig, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _194.TradeConfig;
+            fromJSON(object: any): _194.TradeConfig;
+            toJSON(message: _194.TradeConfig): import("../json-safe.ts").JsonSafe<_194.TradeConfig>;
+            fromPartial(object: Partial<_194.TradeConfig>): _194.TradeConfig;
+            fromProtoMsg(message: _194.TradeConfigProtoMsg): _194.TradeConfig;
+            toProto(message: _194.TradeConfig): Uint8Array;
+            toProtoMsg(message: _194.TradeConfig): _194.TradeConfigProtoMsg;
+        };
+        TradeRoute: {
+            typeUrl: "/stride.stakeibc.TradeRoute";
+            encode(message: _194.TradeRoute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _194.TradeRoute;
+            fromJSON(object: any): _194.TradeRoute;
+            toJSON(message: _194.TradeRoute): import("../json-safe.ts").JsonSafe<_194.TradeRoute>;
+            fromPartial(object: Partial<_194.TradeRoute>): _194.TradeRoute;
+            fromProtoMsg(message: _194.TradeRouteProtoMsg): _194.TradeRoute;
+            toProto(message: _194.TradeRoute): Uint8Array;
+            toProtoMsg(message: _194.TradeRoute): _194.TradeRouteProtoMsg;
+        };
+        QueryInterchainAccountFromAddressRequest: {
+            typeUrl: "/stride.stakeibc.QueryInterchainAccountFromAddressRequest";
+            encode(message: _193.QueryInterchainAccountFromAddressRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryInterchainAccountFromAddressRequest;
+            fromJSON(object: any): _193.QueryInterchainAccountFromAddressRequest;
+            toJSON(message: _193.QueryInterchainAccountFromAddressRequest): import("../json-safe.ts").JsonSafe<_193.QueryInterchainAccountFromAddressRequest>;
+            fromPartial(object: Partial<_193.QueryInterchainAccountFromAddressRequest>): _193.QueryInterchainAccountFromAddressRequest;
+            fromProtoMsg(message: _193.QueryInterchainAccountFromAddressRequestProtoMsg): _193.QueryInterchainAccountFromAddressRequest;
+            toProto(message: _193.QueryInterchainAccountFromAddressRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryInterchainAccountFromAddressRequest): _193.QueryInterchainAccountFromAddressRequestProtoMsg;
+        };
+        QueryInterchainAccountFromAddressResponse: {
+            typeUrl: "/stride.stakeibc.QueryInterchainAccountFromAddressResponse";
+            encode(message: _193.QueryInterchainAccountFromAddressResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryInterchainAccountFromAddressResponse;
+            fromJSON(object: any): _193.QueryInterchainAccountFromAddressResponse;
+            toJSON(message: _193.QueryInterchainAccountFromAddressResponse): import("../json-safe.ts").JsonSafe<_193.QueryInterchainAccountFromAddressResponse>;
+            fromPartial(object: Partial<_193.QueryInterchainAccountFromAddressResponse>): _193.QueryInterchainAccountFromAddressResponse;
+            fromProtoMsg(message: _193.QueryInterchainAccountFromAddressResponseProtoMsg): _193.QueryInterchainAccountFromAddressResponse;
+            toProto(message: _193.QueryInterchainAccountFromAddressResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryInterchainAccountFromAddressResponse): _193.QueryInterchainAccountFromAddressResponseProtoMsg;
+        };
+        QueryParamsRequest: {
+            typeUrl: "/stride.stakeibc.QueryParamsRequest";
+            encode(_: _193.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryParamsRequest;
+            fromJSON(_: any): _193.QueryParamsRequest;
+            toJSON(_: _193.QueryParamsRequest): import("../json-safe.ts").JsonSafe<_193.QueryParamsRequest>;
+            fromPartial(_: Partial<_193.QueryParamsRequest>): _193.QueryParamsRequest;
+            fromProtoMsg(message: _193.QueryParamsRequestProtoMsg): _193.QueryParamsRequest;
+            toProto(message: _193.QueryParamsRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryParamsRequest): _193.QueryParamsRequestProtoMsg;
+        };
+        QueryParamsResponse: {
+            typeUrl: "/stride.stakeibc.QueryParamsResponse";
+            encode(message: _193.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryParamsResponse;
+            fromJSON(object: any): _193.QueryParamsResponse;
+            toJSON(message: _193.QueryParamsResponse): import("../json-safe.ts").JsonSafe<_193.QueryParamsResponse>;
+            fromPartial(object: Partial<_193.QueryParamsResponse>): _193.QueryParamsResponse;
+            fromProtoMsg(message: _193.QueryParamsResponseProtoMsg): _193.QueryParamsResponse;
+            toProto(message: _193.QueryParamsResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryParamsResponse): _193.QueryParamsResponseProtoMsg;
+        };
+        QueryGetValidatorsRequest: {
+            typeUrl: "/stride.stakeibc.QueryGetValidatorsRequest";
+            encode(message: _193.QueryGetValidatorsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetValidatorsRequest;
+            fromJSON(object: any): _193.QueryGetValidatorsRequest;
+            toJSON(message: _193.QueryGetValidatorsRequest): import("../json-safe.ts").JsonSafe<_193.QueryGetValidatorsRequest>;
+            fromPartial(object: Partial<_193.QueryGetValidatorsRequest>): _193.QueryGetValidatorsRequest;
+            fromProtoMsg(message: _193.QueryGetValidatorsRequestProtoMsg): _193.QueryGetValidatorsRequest;
+            toProto(message: _193.QueryGetValidatorsRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryGetValidatorsRequest): _193.QueryGetValidatorsRequestProtoMsg;
+        };
+        QueryGetValidatorsResponse: {
+            typeUrl: "/stride.stakeibc.QueryGetValidatorsResponse";
+            encode(message: _193.QueryGetValidatorsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetValidatorsResponse;
+            fromJSON(object: any): _193.QueryGetValidatorsResponse;
+            toJSON(message: _193.QueryGetValidatorsResponse): import("../json-safe.ts").JsonSafe<_193.QueryGetValidatorsResponse>;
+            fromPartial(object: Partial<_193.QueryGetValidatorsResponse>): _193.QueryGetValidatorsResponse;
+            fromProtoMsg(message: _193.QueryGetValidatorsResponseProtoMsg): _193.QueryGetValidatorsResponse;
+            toProto(message: _193.QueryGetValidatorsResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryGetValidatorsResponse): _193.QueryGetValidatorsResponseProtoMsg;
+        };
+        QueryGetHostZoneRequest: {
+            typeUrl: "/stride.stakeibc.QueryGetHostZoneRequest";
+            encode(message: _193.QueryGetHostZoneRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetHostZoneRequest;
+            fromJSON(object: any): _193.QueryGetHostZoneRequest;
+            toJSON(message: _193.QueryGetHostZoneRequest): import("../json-safe.ts").JsonSafe<_193.QueryGetHostZoneRequest>;
+            fromPartial(object: Partial<_193.QueryGetHostZoneRequest>): _193.QueryGetHostZoneRequest;
+            fromProtoMsg(message: _193.QueryGetHostZoneRequestProtoMsg): _193.QueryGetHostZoneRequest;
+            toProto(message: _193.QueryGetHostZoneRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryGetHostZoneRequest): _193.QueryGetHostZoneRequestProtoMsg;
+        };
+        QueryGetHostZoneResponse: {
+            typeUrl: "/stride.stakeibc.QueryGetHostZoneResponse";
+            encode(message: _193.QueryGetHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetHostZoneResponse;
+            fromJSON(object: any): _193.QueryGetHostZoneResponse;
+            toJSON(message: _193.QueryGetHostZoneResponse): import("../json-safe.ts").JsonSafe<_193.QueryGetHostZoneResponse>;
+            fromPartial(object: Partial<_193.QueryGetHostZoneResponse>): _193.QueryGetHostZoneResponse;
+            fromProtoMsg(message: _193.QueryGetHostZoneResponseProtoMsg): _193.QueryGetHostZoneResponse;
+            toProto(message: _193.QueryGetHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryGetHostZoneResponse): _193.QueryGetHostZoneResponseProtoMsg;
+        };
+        QueryAllHostZoneRequest: {
+            typeUrl: "/stride.stakeibc.QueryAllHostZoneRequest";
+            encode(message: _193.QueryAllHostZoneRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAllHostZoneRequest;
+            fromJSON(object: any): _193.QueryAllHostZoneRequest;
+            toJSON(message: _193.QueryAllHostZoneRequest): import("../json-safe.ts").JsonSafe<_193.QueryAllHostZoneRequest>;
+            fromPartial(object: Partial<_193.QueryAllHostZoneRequest>): _193.QueryAllHostZoneRequest;
+            fromProtoMsg(message: _193.QueryAllHostZoneRequestProtoMsg): _193.QueryAllHostZoneRequest;
+            toProto(message: _193.QueryAllHostZoneRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryAllHostZoneRequest): _193.QueryAllHostZoneRequestProtoMsg;
+        };
+        QueryAllHostZoneResponse: {
+            typeUrl: "/stride.stakeibc.QueryAllHostZoneResponse";
+            encode(message: _193.QueryAllHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAllHostZoneResponse;
+            fromJSON(object: any): _193.QueryAllHostZoneResponse;
+            toJSON(message: _193.QueryAllHostZoneResponse): import("../json-safe.ts").JsonSafe<_193.QueryAllHostZoneResponse>;
+            fromPartial(object: Partial<_193.QueryAllHostZoneResponse>): _193.QueryAllHostZoneResponse;
+            fromProtoMsg(message: _193.QueryAllHostZoneResponseProtoMsg): _193.QueryAllHostZoneResponse;
+            toProto(message: _193.QueryAllHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryAllHostZoneResponse): _193.QueryAllHostZoneResponseProtoMsg;
+        };
+        QueryModuleAddressRequest: {
+            typeUrl: "/stride.stakeibc.QueryModuleAddressRequest";
+            encode(message: _193.QueryModuleAddressRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryModuleAddressRequest;
+            fromJSON(object: any): _193.QueryModuleAddressRequest;
+            toJSON(message: _193.QueryModuleAddressRequest): import("../json-safe.ts").JsonSafe<_193.QueryModuleAddressRequest>;
+            fromPartial(object: Partial<_193.QueryModuleAddressRequest>): _193.QueryModuleAddressRequest;
+            fromProtoMsg(message: _193.QueryModuleAddressRequestProtoMsg): _193.QueryModuleAddressRequest;
+            toProto(message: _193.QueryModuleAddressRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryModuleAddressRequest): _193.QueryModuleAddressRequestProtoMsg;
+        };
+        QueryModuleAddressResponse: {
+            typeUrl: "/stride.stakeibc.QueryModuleAddressResponse";
+            encode(message: _193.QueryModuleAddressResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryModuleAddressResponse;
+            fromJSON(object: any): _193.QueryModuleAddressResponse;
+            toJSON(message: _193.QueryModuleAddressResponse): import("../json-safe.ts").JsonSafe<_193.QueryModuleAddressResponse>;
+            fromPartial(object: Partial<_193.QueryModuleAddressResponse>): _193.QueryModuleAddressResponse;
+            fromProtoMsg(message: _193.QueryModuleAddressResponseProtoMsg): _193.QueryModuleAddressResponse;
+            toProto(message: _193.QueryModuleAddressResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryModuleAddressResponse): _193.QueryModuleAddressResponseProtoMsg;
+        };
+        QueryGetEpochTrackerRequest: {
+            typeUrl: "/stride.stakeibc.QueryGetEpochTrackerRequest";
+            encode(message: _193.QueryGetEpochTrackerRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetEpochTrackerRequest;
+            fromJSON(object: any): _193.QueryGetEpochTrackerRequest;
+            toJSON(message: _193.QueryGetEpochTrackerRequest): import("../json-safe.ts").JsonSafe<_193.QueryGetEpochTrackerRequest>;
+            fromPartial(object: Partial<_193.QueryGetEpochTrackerRequest>): _193.QueryGetEpochTrackerRequest;
+            fromProtoMsg(message: _193.QueryGetEpochTrackerRequestProtoMsg): _193.QueryGetEpochTrackerRequest;
+            toProto(message: _193.QueryGetEpochTrackerRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryGetEpochTrackerRequest): _193.QueryGetEpochTrackerRequestProtoMsg;
+        };
+        QueryGetEpochTrackerResponse: {
+            typeUrl: "/stride.stakeibc.QueryGetEpochTrackerResponse";
+            encode(message: _193.QueryGetEpochTrackerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetEpochTrackerResponse;
+            fromJSON(object: any): _193.QueryGetEpochTrackerResponse;
+            toJSON(message: _193.QueryGetEpochTrackerResponse): import("../json-safe.ts").JsonSafe<_193.QueryGetEpochTrackerResponse>;
+            fromPartial(object: Partial<_193.QueryGetEpochTrackerResponse>): _193.QueryGetEpochTrackerResponse;
+            fromProtoMsg(message: _193.QueryGetEpochTrackerResponseProtoMsg): _193.QueryGetEpochTrackerResponse;
+            toProto(message: _193.QueryGetEpochTrackerResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryGetEpochTrackerResponse): _193.QueryGetEpochTrackerResponseProtoMsg;
+        };
+        QueryAllEpochTrackerRequest: {
+            typeUrl: "/stride.stakeibc.QueryAllEpochTrackerRequest";
+            encode(_: _193.QueryAllEpochTrackerRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAllEpochTrackerRequest;
+            fromJSON(_: any): _193.QueryAllEpochTrackerRequest;
+            toJSON(_: _193.QueryAllEpochTrackerRequest): import("../json-safe.ts").JsonSafe<_193.QueryAllEpochTrackerRequest>;
+            fromPartial(_: Partial<_193.QueryAllEpochTrackerRequest>): _193.QueryAllEpochTrackerRequest;
+            fromProtoMsg(message: _193.QueryAllEpochTrackerRequestProtoMsg): _193.QueryAllEpochTrackerRequest;
+            toProto(message: _193.QueryAllEpochTrackerRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryAllEpochTrackerRequest): _193.QueryAllEpochTrackerRequestProtoMsg;
+        };
+        QueryAllEpochTrackerResponse: {
+            typeUrl: "/stride.stakeibc.QueryAllEpochTrackerResponse";
+            encode(message: _193.QueryAllEpochTrackerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAllEpochTrackerResponse;
+            fromJSON(object: any): _193.QueryAllEpochTrackerResponse;
+            toJSON(message: _193.QueryAllEpochTrackerResponse): import("../json-safe.ts").JsonSafe<_193.QueryAllEpochTrackerResponse>;
+            fromPartial(object: Partial<_193.QueryAllEpochTrackerResponse>): _193.QueryAllEpochTrackerResponse;
+            fromProtoMsg(message: _193.QueryAllEpochTrackerResponseProtoMsg): _193.QueryAllEpochTrackerResponse;
+            toProto(message: _193.QueryAllEpochTrackerResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryAllEpochTrackerResponse): _193.QueryAllEpochTrackerResponseProtoMsg;
+        };
+        QueryGetNextPacketSequenceRequest: {
+            typeUrl: "/stride.stakeibc.QueryGetNextPacketSequenceRequest";
+            encode(message: _193.QueryGetNextPacketSequenceRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetNextPacketSequenceRequest;
+            fromJSON(object: any): _193.QueryGetNextPacketSequenceRequest;
+            toJSON(message: _193.QueryGetNextPacketSequenceRequest): import("../json-safe.ts").JsonSafe<_193.QueryGetNextPacketSequenceRequest>;
+            fromPartial(object: Partial<_193.QueryGetNextPacketSequenceRequest>): _193.QueryGetNextPacketSequenceRequest;
+            fromProtoMsg(message: _193.QueryGetNextPacketSequenceRequestProtoMsg): _193.QueryGetNextPacketSequenceRequest;
+            toProto(message: _193.QueryGetNextPacketSequenceRequest): Uint8Array;
+            toProtoMsg(message: _193.QueryGetNextPacketSequenceRequest): _193.QueryGetNextPacketSequenceRequestProtoMsg;
+        };
+        QueryGetNextPacketSequenceResponse: {
+            typeUrl: "/stride.stakeibc.QueryGetNextPacketSequenceResponse";
+            encode(message: _193.QueryGetNextPacketSequenceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryGetNextPacketSequenceResponse;
+            fromJSON(object: any): _193.QueryGetNextPacketSequenceResponse;
+            toJSON(message: _193.QueryGetNextPacketSequenceResponse): import("../json-safe.ts").JsonSafe<_193.QueryGetNextPacketSequenceResponse>;
+            fromPartial(object: Partial<_193.QueryGetNextPacketSequenceResponse>): _193.QueryGetNextPacketSequenceResponse;
+            fromProtoMsg(message: _193.QueryGetNextPacketSequenceResponseProtoMsg): _193.QueryGetNextPacketSequenceResponse;
+            toProto(message: _193.QueryGetNextPacketSequenceResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryGetNextPacketSequenceResponse): _193.QueryGetNextPacketSequenceResponseProtoMsg;
+        };
+        QueryAddressUnbondings: {
+            typeUrl: "/stride.stakeibc.QueryAddressUnbondings";
+            encode(message: _193.QueryAddressUnbondings, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAddressUnbondings;
+            fromJSON(object: any): _193.QueryAddressUnbondings;
+            toJSON(message: _193.QueryAddressUnbondings): import("../json-safe.ts").JsonSafe<_193.QueryAddressUnbondings>;
+            fromPartial(object: Partial<_193.QueryAddressUnbondings>): _193.QueryAddressUnbondings;
+            fromProtoMsg(message: _193.QueryAddressUnbondingsProtoMsg): _193.QueryAddressUnbondings;
+            toProto(message: _193.QueryAddressUnbondings): Uint8Array;
+            toProtoMsg(message: _193.QueryAddressUnbondings): _193.QueryAddressUnbondingsProtoMsg;
+        };
+        QueryAddressUnbondingsResponse: {
+            typeUrl: "/stride.stakeibc.QueryAddressUnbondingsResponse";
+            encode(message: _193.QueryAddressUnbondingsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAddressUnbondingsResponse;
+            fromJSON(object: any): _193.QueryAddressUnbondingsResponse;
+            toJSON(message: _193.QueryAddressUnbondingsResponse): import("../json-safe.ts").JsonSafe<_193.QueryAddressUnbondingsResponse>;
+            fromPartial(object: Partial<_193.QueryAddressUnbondingsResponse>): _193.QueryAddressUnbondingsResponse;
+            fromProtoMsg(message: _193.QueryAddressUnbondingsResponseProtoMsg): _193.QueryAddressUnbondingsResponse;
+            toProto(message: _193.QueryAddressUnbondingsResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryAddressUnbondingsResponse): _193.QueryAddressUnbondingsResponseProtoMsg;
+        };
+        QueryAllTradeRoutes: {
+            typeUrl: "/stride.stakeibc.QueryAllTradeRoutes";
+            encode(_: _193.QueryAllTradeRoutes, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAllTradeRoutes;
+            fromJSON(_: any): _193.QueryAllTradeRoutes;
+            toJSON(_: _193.QueryAllTradeRoutes): import("../json-safe.ts").JsonSafe<_193.QueryAllTradeRoutes>;
+            fromPartial(_: Partial<_193.QueryAllTradeRoutes>): _193.QueryAllTradeRoutes;
+            fromProtoMsg(message: _193.QueryAllTradeRoutesProtoMsg): _193.QueryAllTradeRoutes;
+            toProto(message: _193.QueryAllTradeRoutes): Uint8Array;
+            toProtoMsg(message: _193.QueryAllTradeRoutes): _193.QueryAllTradeRoutesProtoMsg;
+        };
+        QueryAllTradeRoutesResponse: {
+            typeUrl: "/stride.stakeibc.QueryAllTradeRoutesResponse";
+            encode(message: _193.QueryAllTradeRoutesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _193.QueryAllTradeRoutesResponse;
+            fromJSON(object: any): _193.QueryAllTradeRoutesResponse;
+            toJSON(message: _193.QueryAllTradeRoutesResponse): import("../json-safe.ts").JsonSafe<_193.QueryAllTradeRoutesResponse>;
+            fromPartial(object: Partial<_193.QueryAllTradeRoutesResponse>): _193.QueryAllTradeRoutesResponse;
+            fromProtoMsg(message: _193.QueryAllTradeRoutesResponseProtoMsg): _193.QueryAllTradeRoutesResponse;
+            toProto(message: _193.QueryAllTradeRoutesResponse): Uint8Array;
+            toProtoMsg(message: _193.QueryAllTradeRoutesResponse): _193.QueryAllTradeRoutesResponseProtoMsg;
+        };
+        Params: {
+            typeUrl: "/stride.stakeibc.Params";
+            encode(message: _192.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _192.Params;
+            fromJSON(object: any): _192.Params;
+            toJSON(message: _192.Params): import("../json-safe.ts").JsonSafe<_192.Params>;
+            fromPartial(object: Partial<_192.Params>): _192.Params;
+            fromProtoMsg(message: _192.ParamsProtoMsg): _192.Params;
+            toProto(message: _192.Params): Uint8Array;
+            toProtoMsg(message: _192.Params): _192.ParamsProtoMsg;
+        };
+        StakeibcPacketData: {
+            typeUrl: "/stride.stakeibc.StakeibcPacketData";
+            encode(message: _191.StakeibcPacketData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _191.StakeibcPacketData;
+            fromJSON(object: any): _191.StakeibcPacketData;
+            toJSON(message: _191.StakeibcPacketData): import("../json-safe.ts").JsonSafe<_191.StakeibcPacketData>;
+            fromPartial(object: Partial<_191.StakeibcPacketData>): _191.StakeibcPacketData;
+            fromProtoMsg(message: _191.StakeibcPacketDataProtoMsg): _191.StakeibcPacketData;
+            toProto(message: _191.StakeibcPacketData): Uint8Array;
+            toProtoMsg(message: _191.StakeibcPacketData): _191.StakeibcPacketDataProtoMsg;
+        };
+        NoData: {
+            typeUrl: "/stride.stakeibc.NoData";
+            encode(_: _191.NoData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _191.NoData;
+            fromJSON(_: any): _191.NoData;
+            toJSON(_: _191.NoData): import("../json-safe.ts").JsonSafe<_191.NoData>;
+            fromPartial(_: Partial<_191.NoData>): _191.NoData;
+            fromProtoMsg(message: _191.NoDataProtoMsg): _191.NoData;
+            toProto(message: _191.NoData): Uint8Array;
+            toProtoMsg(message: _191.NoData): _191.NoDataProtoMsg;
+        };
+        iCAAccountTypeFromJSON(object: any): _190.ICAAccountType;
+        iCAAccountTypeToJSON(object: _190.ICAAccountType): string;
+        ICAAccountType: typeof _190.ICAAccountType;
+        ICAAccountTypeSDKType: typeof _190.ICAAccountType;
+        ICAAccount: {
+            typeUrl: "/stride.stakeibc.ICAAccount";
+            encode(message: _190.ICAAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _190.ICAAccount;
+            fromJSON(object: any): _190.ICAAccount;
+            toJSON(message: _190.ICAAccount): import("../json-safe.ts").JsonSafe<_190.ICAAccount>;
+            fromPartial(object: Partial<_190.ICAAccount>): _190.ICAAccount;
+            fromProtoMsg(message: _190.ICAAccountProtoMsg): _190.ICAAccount;
+            toProto(message: _190.ICAAccount): Uint8Array;
+            toProtoMsg(message: _190.ICAAccount): _190.ICAAccountProtoMsg;
+        };
+        CommunityPoolRebate: {
+            typeUrl: "/stride.stakeibc.CommunityPoolRebate";
+            encode(message: _189.CommunityPoolRebate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _189.CommunityPoolRebate;
+            fromJSON(object: any): _189.CommunityPoolRebate;
+            toJSON(message: _189.CommunityPoolRebate): import("../json-safe.ts").JsonSafe<_189.CommunityPoolRebate>;
+            fromPartial(object: Partial<_189.CommunityPoolRebate>): _189.CommunityPoolRebate;
+            fromProtoMsg(message: _189.CommunityPoolRebateProtoMsg): _189.CommunityPoolRebate;
+            toProto(message: _189.CommunityPoolRebate): Uint8Array;
+            toProtoMsg(message: _189.CommunityPoolRebate): _189.CommunityPoolRebateProtoMsg;
+        };
+        HostZone: {
+            typeUrl: "/stride.stakeibc.HostZone";
+            encode(message: _189.HostZone, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _189.HostZone;
+            fromJSON(object: any): _189.HostZone;
+            toJSON(message: _189.HostZone): import("../json-safe.ts").JsonSafe<_189.HostZone>;
+            fromPartial(object: Partial<_189.HostZone>): _189.HostZone;
+            fromProtoMsg(message: _189.HostZoneProtoMsg): _189.HostZone;
+            toProto(message: _189.HostZone): Uint8Array;
+            toProtoMsg(message: _189.HostZone): _189.HostZoneProtoMsg;
+        };
+        AddValidatorsProposal: {
+            typeUrl: "/stride.stakeibc.AddValidatorsProposal";
+            encode(message: _188.AddValidatorsProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _188.AddValidatorsProposal;
+            fromJSON(object: any): _188.AddValidatorsProposal;
+            toJSON(message: _188.AddValidatorsProposal): import("../json-safe.ts").JsonSafe<_188.AddValidatorsProposal>;
+            fromPartial(object: Partial<_188.AddValidatorsProposal>): _188.AddValidatorsProposal;
+            fromProtoMsg(message: _188.AddValidatorsProposalProtoMsg): _188.AddValidatorsProposal;
+            toProto(message: _188.AddValidatorsProposal): Uint8Array;
+            toProtoMsg(message: _188.AddValidatorsProposal): _188.AddValidatorsProposalProtoMsg;
+        };
+        ToggleLSMProposal: {
+            typeUrl: "/stride.stakeibc.ToggleLSMProposal";
+            encode(message: _188.ToggleLSMProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _188.ToggleLSMProposal;
+            fromJSON(object: any): _188.ToggleLSMProposal;
+            toJSON(message: _188.ToggleLSMProposal): import("../json-safe.ts").JsonSafe<_188.ToggleLSMProposal>;
+            fromPartial(object: Partial<_188.ToggleLSMProposal>): _188.ToggleLSMProposal;
+            fromProtoMsg(message: _188.ToggleLSMProposalProtoMsg): _188.ToggleLSMProposal;
+            toProto(message: _188.ToggleLSMProposal): Uint8Array;
+            toProtoMsg(message: _188.ToggleLSMProposal): _188.ToggleLSMProposalProtoMsg;
+        };
+        GenesisState: {
+            typeUrl: "/stride.stakeibc.GenesisState";
+            encode(message: _187.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _187.GenesisState;
+            fromJSON(object: any): _187.GenesisState;
+            toJSON(message: _187.GenesisState): import("../json-safe.ts").JsonSafe<_187.GenesisState>;
+            fromPartial(object: Partial<_187.GenesisState>): _187.GenesisState;
+            fromProtoMsg(message: _187.GenesisStateProtoMsg): _187.GenesisState;
+            toProto(message: _187.GenesisState): Uint8Array;
+            toProtoMsg(message: _187.GenesisState): _187.GenesisStateProtoMsg;
+        };
+        EpochTracker: {
+            typeUrl: "/stride.stakeibc.EpochTracker";
+            encode(message: _186.EpochTracker, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _186.EpochTracker;
+            fromJSON(object: any): _186.EpochTracker;
+            toJSON(message: _186.EpochTracker): import("../json-safe.ts").JsonSafe<_186.EpochTracker>;
+            fromPartial(object: Partial<_186.EpochTracker>): _186.EpochTracker;
+            fromProtoMsg(message: _186.EpochTrackerProtoMsg): _186.EpochTracker;
+            toProto(message: _186.EpochTracker): Uint8Array;
+            toProtoMsg(message: _186.EpochTracker): _186.EpochTrackerProtoMsg;
+        };
+        SplitDelegation: {
+            typeUrl: "/stride.stakeibc.SplitDelegation";
+            encode(message: _185.SplitDelegation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.SplitDelegation;
+            fromJSON(object: any): _185.SplitDelegation;
+            toJSON(message: _185.SplitDelegation): import("../json-safe.ts").JsonSafe<_185.SplitDelegation>;
+            fromPartial(object: Partial<_185.SplitDelegation>): _185.SplitDelegation;
+            fromProtoMsg(message: _185.SplitDelegationProtoMsg): _185.SplitDelegation;
+            toProto(message: _185.SplitDelegation): Uint8Array;
+            toProtoMsg(message: _185.SplitDelegation): _185.SplitDelegationProtoMsg;
+        };
+        SplitUndelegation: {
+            typeUrl: "/stride.stakeibc.SplitUndelegation";
+            encode(message: _185.SplitUndelegation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.SplitUndelegation;
+            fromJSON(object: any): _185.SplitUndelegation;
+            toJSON(message: _185.SplitUndelegation): import("../json-safe.ts").JsonSafe<_185.SplitUndelegation>;
+            fromPartial(object: Partial<_185.SplitUndelegation>): _185.SplitUndelegation;
+            fromProtoMsg(message: _185.SplitUndelegationProtoMsg): _185.SplitUndelegation;
+            toProto(message: _185.SplitUndelegation): Uint8Array;
+            toProtoMsg(message: _185.SplitUndelegation): _185.SplitUndelegationProtoMsg;
+        };
+        DelegateCallback: {
+            typeUrl: "/stride.stakeibc.DelegateCallback";
+            encode(message: _185.DelegateCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.DelegateCallback;
+            fromJSON(object: any): _185.DelegateCallback;
+            toJSON(message: _185.DelegateCallback): import("../json-safe.ts").JsonSafe<_185.DelegateCallback>;
+            fromPartial(object: Partial<_185.DelegateCallback>): _185.DelegateCallback;
+            fromProtoMsg(message: _185.DelegateCallbackProtoMsg): _185.DelegateCallback;
+            toProto(message: _185.DelegateCallback): Uint8Array;
+            toProtoMsg(message: _185.DelegateCallback): _185.DelegateCallbackProtoMsg;
+        };
+        ClaimCallback: {
+            typeUrl: "/stride.stakeibc.ClaimCallback";
+            encode(message: _185.ClaimCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.ClaimCallback;
+            fromJSON(object: any): _185.ClaimCallback;
+            toJSON(message: _185.ClaimCallback): import("../json-safe.ts").JsonSafe<_185.ClaimCallback>;
+            fromPartial(object: Partial<_185.ClaimCallback>): _185.ClaimCallback;
+            fromProtoMsg(message: _185.ClaimCallbackProtoMsg): _185.ClaimCallback;
+            toProto(message: _185.ClaimCallback): Uint8Array;
+            toProtoMsg(message: _185.ClaimCallback): _185.ClaimCallbackProtoMsg;
+        };
+        ReinvestCallback: {
+            typeUrl: "/stride.stakeibc.ReinvestCallback";
+            encode(message: _185.ReinvestCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.ReinvestCallback;
+            fromJSON(object: any): _185.ReinvestCallback;
+            toJSON(message: _185.ReinvestCallback): import("../json-safe.ts").JsonSafe<_185.ReinvestCallback>;
+            fromPartial(object: Partial<_185.ReinvestCallback>): _185.ReinvestCallback;
+            fromProtoMsg(message: _185.ReinvestCallbackProtoMsg): _185.ReinvestCallback;
+            toProto(message: _185.ReinvestCallback): Uint8Array;
+            toProtoMsg(message: _185.ReinvestCallback): _185.ReinvestCallbackProtoMsg;
+        };
+        UndelegateCallback: {
+            typeUrl: "/stride.stakeibc.UndelegateCallback";
+            encode(message: _185.UndelegateCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.UndelegateCallback;
+            fromJSON(object: any): _185.UndelegateCallback;
+            toJSON(message: _185.UndelegateCallback): import("../json-safe.ts").JsonSafe<_185.UndelegateCallback>;
+            fromPartial(object: Partial<_185.UndelegateCallback>): _185.UndelegateCallback;
+            fromProtoMsg(message: _185.UndelegateCallbackProtoMsg): _185.UndelegateCallback;
+            toProto(message: _185.UndelegateCallback): Uint8Array;
+            toProtoMsg(message: _185.UndelegateCallback): _185.UndelegateCallbackProtoMsg;
+        };
+        RedemptionCallback: {
+            typeUrl: "/stride.stakeibc.RedemptionCallback";
+            encode(message: _185.RedemptionCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.RedemptionCallback;
+            fromJSON(object: any): _185.RedemptionCallback;
+            toJSON(message: _185.RedemptionCallback): import("../json-safe.ts").JsonSafe<_185.RedemptionCallback>;
+            fromPartial(object: Partial<_185.RedemptionCallback>): _185.RedemptionCallback;
+            fromProtoMsg(message: _185.RedemptionCallbackProtoMsg): _185.RedemptionCallback;
+            toProto(message: _185.RedemptionCallback): Uint8Array;
+            toProtoMsg(message: _185.RedemptionCallback): _185.RedemptionCallbackProtoMsg;
+        };
+        Rebalancing: {
+            typeUrl: "/stride.stakeibc.Rebalancing";
+            encode(message: _185.Rebalancing, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.Rebalancing;
+            fromJSON(object: any): _185.Rebalancing;
+            toJSON(message: _185.Rebalancing): import("../json-safe.ts").JsonSafe<_185.Rebalancing>;
+            fromPartial(object: Partial<_185.Rebalancing>): _185.Rebalancing;
+            fromProtoMsg(message: _185.RebalancingProtoMsg): _185.Rebalancing;
+            toProto(message: _185.Rebalancing): Uint8Array;
+            toProtoMsg(message: _185.Rebalancing): _185.RebalancingProtoMsg;
+        };
+        RebalanceCallback: {
+            typeUrl: "/stride.stakeibc.RebalanceCallback";
+            encode(message: _185.RebalanceCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.RebalanceCallback;
+            fromJSON(object: any): _185.RebalanceCallback;
+            toJSON(message: _185.RebalanceCallback): import("../json-safe.ts").JsonSafe<_185.RebalanceCallback>;
+            fromPartial(object: Partial<_185.RebalanceCallback>): _185.RebalanceCallback;
+            fromProtoMsg(message: _185.RebalanceCallbackProtoMsg): _185.RebalanceCallback;
+            toProto(message: _185.RebalanceCallback): Uint8Array;
+            toProtoMsg(message: _185.RebalanceCallback): _185.RebalanceCallbackProtoMsg;
+        };
+        DetokenizeSharesCallback: {
+            typeUrl: "/stride.stakeibc.DetokenizeSharesCallback";
+            encode(message: _185.DetokenizeSharesCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.DetokenizeSharesCallback;
+            fromJSON(object: any): _185.DetokenizeSharesCallback;
+            toJSON(message: _185.DetokenizeSharesCallback): import("../json-safe.ts").JsonSafe<_185.DetokenizeSharesCallback>;
+            fromPartial(object: Partial<_185.DetokenizeSharesCallback>): _185.DetokenizeSharesCallback;
+            fromProtoMsg(message: _185.DetokenizeSharesCallbackProtoMsg): _185.DetokenizeSharesCallback;
+            toProto(message: _185.DetokenizeSharesCallback): Uint8Array;
+            toProtoMsg(message: _185.DetokenizeSharesCallback): _185.DetokenizeSharesCallbackProtoMsg;
+        };
+        LSMLiquidStake: {
+            typeUrl: "/stride.stakeibc.LSMLiquidStake";
+            encode(message: _185.LSMLiquidStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.LSMLiquidStake;
+            fromJSON(object: any): _185.LSMLiquidStake;
+            toJSON(message: _185.LSMLiquidStake): import("../json-safe.ts").JsonSafe<_185.LSMLiquidStake>;
+            fromPartial(object: Partial<_185.LSMLiquidStake>): _185.LSMLiquidStake;
+            fromProtoMsg(message: _185.LSMLiquidStakeProtoMsg): _185.LSMLiquidStake;
+            toProto(message: _185.LSMLiquidStake): Uint8Array;
+            toProtoMsg(message: _185.LSMLiquidStake): _185.LSMLiquidStakeProtoMsg;
+        };
+        ValidatorSharesToTokensQueryCallback: {
+            typeUrl: "/stride.stakeibc.ValidatorSharesToTokensQueryCallback";
+            encode(message: _185.ValidatorSharesToTokensQueryCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.ValidatorSharesToTokensQueryCallback;
+            fromJSON(object: any): _185.ValidatorSharesToTokensQueryCallback;
+            toJSON(message: _185.ValidatorSharesToTokensQueryCallback): import("../json-safe.ts").JsonSafe<_185.ValidatorSharesToTokensQueryCallback>;
+            fromPartial(object: Partial<_185.ValidatorSharesToTokensQueryCallback>): _185.ValidatorSharesToTokensQueryCallback;
+            fromProtoMsg(message: _185.ValidatorSharesToTokensQueryCallbackProtoMsg): _185.ValidatorSharesToTokensQueryCallback;
+            toProto(message: _185.ValidatorSharesToTokensQueryCallback): Uint8Array;
+            toProtoMsg(message: _185.ValidatorSharesToTokensQueryCallback): _185.ValidatorSharesToTokensQueryCallbackProtoMsg;
+        };
+        DelegatorSharesQueryCallback: {
+            typeUrl: "/stride.stakeibc.DelegatorSharesQueryCallback";
+            encode(message: _185.DelegatorSharesQueryCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.DelegatorSharesQueryCallback;
+            fromJSON(object: any): _185.DelegatorSharesQueryCallback;
+            toJSON(message: _185.DelegatorSharesQueryCallback): import("../json-safe.ts").JsonSafe<_185.DelegatorSharesQueryCallback>;
+            fromPartial(object: Partial<_185.DelegatorSharesQueryCallback>): _185.DelegatorSharesQueryCallback;
+            fromProtoMsg(message: _185.DelegatorSharesQueryCallbackProtoMsg): _185.DelegatorSharesQueryCallback;
+            toProto(message: _185.DelegatorSharesQueryCallback): Uint8Array;
+            toProtoMsg(message: _185.DelegatorSharesQueryCallback): _185.DelegatorSharesQueryCallbackProtoMsg;
+        };
+        CommunityPoolBalanceQueryCallback: {
+            typeUrl: "/stride.stakeibc.CommunityPoolBalanceQueryCallback";
+            encode(message: _185.CommunityPoolBalanceQueryCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.CommunityPoolBalanceQueryCallback;
+            fromJSON(object: any): _185.CommunityPoolBalanceQueryCallback;
+            toJSON(message: _185.CommunityPoolBalanceQueryCallback): import("../json-safe.ts").JsonSafe<_185.CommunityPoolBalanceQueryCallback>;
+            fromPartial(object: Partial<_185.CommunityPoolBalanceQueryCallback>): _185.CommunityPoolBalanceQueryCallback;
+            fromProtoMsg(message: _185.CommunityPoolBalanceQueryCallbackProtoMsg): _185.CommunityPoolBalanceQueryCallback;
+            toProto(message: _185.CommunityPoolBalanceQueryCallback): Uint8Array;
+            toProtoMsg(message: _185.CommunityPoolBalanceQueryCallback): _185.CommunityPoolBalanceQueryCallbackProtoMsg;
+        };
+        TradeRouteCallback: {
+            typeUrl: "/stride.stakeibc.TradeRouteCallback";
+            encode(message: _185.TradeRouteCallback, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _185.TradeRouteCallback;
+            fromJSON(object: any): _185.TradeRouteCallback;
+            toJSON(message: _185.TradeRouteCallback): import("../json-safe.ts").JsonSafe<_185.TradeRouteCallback>;
+            fromPartial(object: Partial<_185.TradeRouteCallback>): _185.TradeRouteCallback;
+            fromProtoMsg(message: _185.TradeRouteCallbackProtoMsg): _185.TradeRouteCallback;
+            toProto(message: _185.TradeRouteCallback): Uint8Array;
+            toProtoMsg(message: _185.TradeRouteCallback): _185.TradeRouteCallbackProtoMsg;
+        };
+        AddressUnbonding: {
+            typeUrl: "/stride.stakeibc.AddressUnbonding";
+            encode(message: _184.AddressUnbonding, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _184.AddressUnbonding;
+            fromJSON(object: any): _184.AddressUnbonding;
+            toJSON(message: _184.AddressUnbonding): import("../json-safe.ts").JsonSafe<_184.AddressUnbonding>;
+            fromPartial(object: Partial<_184.AddressUnbonding>): _184.AddressUnbonding;
+            fromProtoMsg(message: _184.AddressUnbondingProtoMsg): _184.AddressUnbonding;
+            toProto(message: _184.AddressUnbonding): Uint8Array;
+            toProtoMsg(message: _184.AddressUnbonding): _184.AddressUnbondingProtoMsg;
+        };
+    };
+    const staketia: {
+        overwritableRecordTypeFromJSON(object: any): _200.OverwritableRecordType;
+        overwritableRecordTypeToJSON(object: _200.OverwritableRecordType): string;
+        OverwritableRecordType: typeof _200.OverwritableRecordType;
+        OverwritableRecordTypeSDKType: typeof _200.OverwritableRecordType;
+        MsgLiquidStake: {
+            typeUrl: "/stride.staketia.MsgLiquidStake";
+            encode(message: _200.MsgLiquidStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgLiquidStake;
+            fromJSON(object: any): _200.MsgLiquidStake;
+            toJSON(message: _200.MsgLiquidStake): import("../json-safe.ts").JsonSafe<_200.MsgLiquidStake>;
+            fromPartial(object: Partial<_200.MsgLiquidStake>): _200.MsgLiquidStake;
+            fromProtoMsg(message: _200.MsgLiquidStakeProtoMsg): _200.MsgLiquidStake;
+            toProto(message: _200.MsgLiquidStake): Uint8Array;
+            toProtoMsg(message: _200.MsgLiquidStake): _200.MsgLiquidStakeProtoMsg;
+        };
+        MsgLiquidStakeResponse: {
+            typeUrl: "/stride.staketia.MsgLiquidStakeResponse";
+            encode(message: _200.MsgLiquidStakeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgLiquidStakeResponse;
+            fromJSON(object: any): _200.MsgLiquidStakeResponse;
+            toJSON(message: _200.MsgLiquidStakeResponse): import("../json-safe.ts").JsonSafe<_200.MsgLiquidStakeResponse>;
+            fromPartial(object: Partial<_200.MsgLiquidStakeResponse>): _200.MsgLiquidStakeResponse;
+            fromProtoMsg(message: _200.MsgLiquidStakeResponseProtoMsg): _200.MsgLiquidStakeResponse;
+            toProto(message: _200.MsgLiquidStakeResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgLiquidStakeResponse): _200.MsgLiquidStakeResponseProtoMsg;
+        };
+        MsgRedeemStake: {
+            typeUrl: "/stride.staketia.MsgRedeemStake";
+            encode(message: _200.MsgRedeemStake, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgRedeemStake;
+            fromJSON(object: any): _200.MsgRedeemStake;
+            toJSON(message: _200.MsgRedeemStake): import("../json-safe.ts").JsonSafe<_200.MsgRedeemStake>;
+            fromPartial(object: Partial<_200.MsgRedeemStake>): _200.MsgRedeemStake;
+            fromProtoMsg(message: _200.MsgRedeemStakeProtoMsg): _200.MsgRedeemStake;
+            toProto(message: _200.MsgRedeemStake): Uint8Array;
+            toProtoMsg(message: _200.MsgRedeemStake): _200.MsgRedeemStakeProtoMsg;
+        };
+        MsgRedeemStakeResponse: {
+            typeUrl: "/stride.staketia.MsgRedeemStakeResponse";
+            encode(message: _200.MsgRedeemStakeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgRedeemStakeResponse;
+            fromJSON(object: any): _200.MsgRedeemStakeResponse;
+            toJSON(message: _200.MsgRedeemStakeResponse): import("../json-safe.ts").JsonSafe<_200.MsgRedeemStakeResponse>;
+            fromPartial(object: Partial<_200.MsgRedeemStakeResponse>): _200.MsgRedeemStakeResponse;
+            fromProtoMsg(message: _200.MsgRedeemStakeResponseProtoMsg): _200.MsgRedeemStakeResponse;
+            toProto(message: _200.MsgRedeemStakeResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgRedeemStakeResponse): _200.MsgRedeemStakeResponseProtoMsg;
+        };
+        MsgConfirmDelegation: {
+            typeUrl: "/stride.staketia.MsgConfirmDelegation";
+            encode(message: _200.MsgConfirmDelegation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgConfirmDelegation;
+            fromJSON(object: any): _200.MsgConfirmDelegation;
+            toJSON(message: _200.MsgConfirmDelegation): import("../json-safe.ts").JsonSafe<_200.MsgConfirmDelegation>;
+            fromPartial(object: Partial<_200.MsgConfirmDelegation>): _200.MsgConfirmDelegation;
+            fromProtoMsg(message: _200.MsgConfirmDelegationProtoMsg): _200.MsgConfirmDelegation;
+            toProto(message: _200.MsgConfirmDelegation): Uint8Array;
+            toProtoMsg(message: _200.MsgConfirmDelegation): _200.MsgConfirmDelegationProtoMsg;
+        };
+        MsgConfirmDelegationResponse: {
+            typeUrl: "/stride.staketia.MsgConfirmDelegationResponse";
+            encode(_: _200.MsgConfirmDelegationResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgConfirmDelegationResponse;
+            fromJSON(_: any): _200.MsgConfirmDelegationResponse;
+            toJSON(_: _200.MsgConfirmDelegationResponse): import("../json-safe.ts").JsonSafe<_200.MsgConfirmDelegationResponse>;
+            fromPartial(_: Partial<_200.MsgConfirmDelegationResponse>): _200.MsgConfirmDelegationResponse;
+            fromProtoMsg(message: _200.MsgConfirmDelegationResponseProtoMsg): _200.MsgConfirmDelegationResponse;
+            toProto(message: _200.MsgConfirmDelegationResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgConfirmDelegationResponse): _200.MsgConfirmDelegationResponseProtoMsg;
+        };
+        MsgConfirmUndelegation: {
+            typeUrl: "/stride.staketia.MsgConfirmUndelegation";
+            encode(message: _200.MsgConfirmUndelegation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgConfirmUndelegation;
+            fromJSON(object: any): _200.MsgConfirmUndelegation;
+            toJSON(message: _200.MsgConfirmUndelegation): import("../json-safe.ts").JsonSafe<_200.MsgConfirmUndelegation>;
+            fromPartial(object: Partial<_200.MsgConfirmUndelegation>): _200.MsgConfirmUndelegation;
+            fromProtoMsg(message: _200.MsgConfirmUndelegationProtoMsg): _200.MsgConfirmUndelegation;
+            toProto(message: _200.MsgConfirmUndelegation): Uint8Array;
+            toProtoMsg(message: _200.MsgConfirmUndelegation): _200.MsgConfirmUndelegationProtoMsg;
+        };
+        MsgConfirmUndelegationResponse: {
+            typeUrl: "/stride.staketia.MsgConfirmUndelegationResponse";
+            encode(_: _200.MsgConfirmUndelegationResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgConfirmUndelegationResponse;
+            fromJSON(_: any): _200.MsgConfirmUndelegationResponse;
+            toJSON(_: _200.MsgConfirmUndelegationResponse): import("../json-safe.ts").JsonSafe<_200.MsgConfirmUndelegationResponse>;
+            fromPartial(_: Partial<_200.MsgConfirmUndelegationResponse>): _200.MsgConfirmUndelegationResponse;
+            fromProtoMsg(message: _200.MsgConfirmUndelegationResponseProtoMsg): _200.MsgConfirmUndelegationResponse;
+            toProto(message: _200.MsgConfirmUndelegationResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgConfirmUndelegationResponse): _200.MsgConfirmUndelegationResponseProtoMsg;
+        };
+        MsgConfirmUnbondedTokenSweep: {
+            typeUrl: "/stride.staketia.MsgConfirmUnbondedTokenSweep";
+            encode(message: _200.MsgConfirmUnbondedTokenSweep, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgConfirmUnbondedTokenSweep;
+            fromJSON(object: any): _200.MsgConfirmUnbondedTokenSweep;
+            toJSON(message: _200.MsgConfirmUnbondedTokenSweep): import("../json-safe.ts").JsonSafe<_200.MsgConfirmUnbondedTokenSweep>;
+            fromPartial(object: Partial<_200.MsgConfirmUnbondedTokenSweep>): _200.MsgConfirmUnbondedTokenSweep;
+            fromProtoMsg(message: _200.MsgConfirmUnbondedTokenSweepProtoMsg): _200.MsgConfirmUnbondedTokenSweep;
+            toProto(message: _200.MsgConfirmUnbondedTokenSweep): Uint8Array;
+            toProtoMsg(message: _200.MsgConfirmUnbondedTokenSweep): _200.MsgConfirmUnbondedTokenSweepProtoMsg;
+        };
+        MsgConfirmUnbondedTokenSweepResponse: {
+            typeUrl: "/stride.staketia.MsgConfirmUnbondedTokenSweepResponse";
+            encode(_: _200.MsgConfirmUnbondedTokenSweepResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgConfirmUnbondedTokenSweepResponse;
+            fromJSON(_: any): _200.MsgConfirmUnbondedTokenSweepResponse;
+            toJSON(_: _200.MsgConfirmUnbondedTokenSweepResponse): import("../json-safe.ts").JsonSafe<_200.MsgConfirmUnbondedTokenSweepResponse>;
+            fromPartial(_: Partial<_200.MsgConfirmUnbondedTokenSweepResponse>): _200.MsgConfirmUnbondedTokenSweepResponse;
+            fromProtoMsg(message: _200.MsgConfirmUnbondedTokenSweepResponseProtoMsg): _200.MsgConfirmUnbondedTokenSweepResponse;
+            toProto(message: _200.MsgConfirmUnbondedTokenSweepResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgConfirmUnbondedTokenSweepResponse): _200.MsgConfirmUnbondedTokenSweepResponseProtoMsg;
+        };
+        MsgAdjustDelegatedBalance: {
+            typeUrl: "/stride.staketia.MsgAdjustDelegatedBalance";
+            encode(message: _200.MsgAdjustDelegatedBalance, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgAdjustDelegatedBalance;
+            fromJSON(object: any): _200.MsgAdjustDelegatedBalance;
+            toJSON(message: _200.MsgAdjustDelegatedBalance): import("../json-safe.ts").JsonSafe<_200.MsgAdjustDelegatedBalance>;
+            fromPartial(object: Partial<_200.MsgAdjustDelegatedBalance>): _200.MsgAdjustDelegatedBalance;
+            fromProtoMsg(message: _200.MsgAdjustDelegatedBalanceProtoMsg): _200.MsgAdjustDelegatedBalance;
+            toProto(message: _200.MsgAdjustDelegatedBalance): Uint8Array;
+            toProtoMsg(message: _200.MsgAdjustDelegatedBalance): _200.MsgAdjustDelegatedBalanceProtoMsg;
+        };
+        MsgAdjustDelegatedBalanceResponse: {
+            typeUrl: "/stride.staketia.MsgAdjustDelegatedBalanceResponse";
+            encode(_: _200.MsgAdjustDelegatedBalanceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgAdjustDelegatedBalanceResponse;
+            fromJSON(_: any): _200.MsgAdjustDelegatedBalanceResponse;
+            toJSON(_: _200.MsgAdjustDelegatedBalanceResponse): import("../json-safe.ts").JsonSafe<_200.MsgAdjustDelegatedBalanceResponse>;
+            fromPartial(_: Partial<_200.MsgAdjustDelegatedBalanceResponse>): _200.MsgAdjustDelegatedBalanceResponse;
+            fromProtoMsg(message: _200.MsgAdjustDelegatedBalanceResponseProtoMsg): _200.MsgAdjustDelegatedBalanceResponse;
+            toProto(message: _200.MsgAdjustDelegatedBalanceResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgAdjustDelegatedBalanceResponse): _200.MsgAdjustDelegatedBalanceResponseProtoMsg;
+        };
+        MsgUpdateInnerRedemptionRateBounds: {
+            typeUrl: "/stride.staketia.MsgUpdateInnerRedemptionRateBounds";
+            encode(message: _200.MsgUpdateInnerRedemptionRateBounds, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgUpdateInnerRedemptionRateBounds;
+            fromJSON(object: any): _200.MsgUpdateInnerRedemptionRateBounds;
+            toJSON(message: _200.MsgUpdateInnerRedemptionRateBounds): import("../json-safe.ts").JsonSafe<_200.MsgUpdateInnerRedemptionRateBounds>;
+            fromPartial(object: Partial<_200.MsgUpdateInnerRedemptionRateBounds>): _200.MsgUpdateInnerRedemptionRateBounds;
+            fromProtoMsg(message: _200.MsgUpdateInnerRedemptionRateBoundsProtoMsg): _200.MsgUpdateInnerRedemptionRateBounds;
+            toProto(message: _200.MsgUpdateInnerRedemptionRateBounds): Uint8Array;
+            toProtoMsg(message: _200.MsgUpdateInnerRedemptionRateBounds): _200.MsgUpdateInnerRedemptionRateBoundsProtoMsg;
+        };
+        MsgUpdateInnerRedemptionRateBoundsResponse: {
+            typeUrl: "/stride.staketia.MsgUpdateInnerRedemptionRateBoundsResponse";
+            encode(_: _200.MsgUpdateInnerRedemptionRateBoundsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgUpdateInnerRedemptionRateBoundsResponse;
+            fromJSON(_: any): _200.MsgUpdateInnerRedemptionRateBoundsResponse;
+            toJSON(_: _200.MsgUpdateInnerRedemptionRateBoundsResponse): import("../json-safe.ts").JsonSafe<_200.MsgUpdateInnerRedemptionRateBoundsResponse>;
+            fromPartial(_: Partial<_200.MsgUpdateInnerRedemptionRateBoundsResponse>): _200.MsgUpdateInnerRedemptionRateBoundsResponse;
+            fromProtoMsg(message: _200.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg): _200.MsgUpdateInnerRedemptionRateBoundsResponse;
+            toProto(message: _200.MsgUpdateInnerRedemptionRateBoundsResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgUpdateInnerRedemptionRateBoundsResponse): _200.MsgUpdateInnerRedemptionRateBoundsResponseProtoMsg;
+        };
+        MsgResumeHostZone: {
+            typeUrl: "/stride.staketia.MsgResumeHostZone";
+            encode(message: _200.MsgResumeHostZone, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgResumeHostZone;
+            fromJSON(object: any): _200.MsgResumeHostZone;
+            toJSON(message: _200.MsgResumeHostZone): import("../json-safe.ts").JsonSafe<_200.MsgResumeHostZone>;
+            fromPartial(object: Partial<_200.MsgResumeHostZone>): _200.MsgResumeHostZone;
+            fromProtoMsg(message: _200.MsgResumeHostZoneProtoMsg): _200.MsgResumeHostZone;
+            toProto(message: _200.MsgResumeHostZone): Uint8Array;
+            toProtoMsg(message: _200.MsgResumeHostZone): _200.MsgResumeHostZoneProtoMsg;
+        };
+        MsgResumeHostZoneResponse: {
+            typeUrl: "/stride.staketia.MsgResumeHostZoneResponse";
+            encode(_: _200.MsgResumeHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgResumeHostZoneResponse;
+            fromJSON(_: any): _200.MsgResumeHostZoneResponse;
+            toJSON(_: _200.MsgResumeHostZoneResponse): import("../json-safe.ts").JsonSafe<_200.MsgResumeHostZoneResponse>;
+            fromPartial(_: Partial<_200.MsgResumeHostZoneResponse>): _200.MsgResumeHostZoneResponse;
+            fromProtoMsg(message: _200.MsgResumeHostZoneResponseProtoMsg): _200.MsgResumeHostZoneResponse;
+            toProto(message: _200.MsgResumeHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgResumeHostZoneResponse): _200.MsgResumeHostZoneResponseProtoMsg;
+        };
+        MsgRefreshRedemptionRate: {
+            typeUrl: "/stride.staketia.MsgRefreshRedemptionRate";
+            encode(message: _200.MsgRefreshRedemptionRate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgRefreshRedemptionRate;
+            fromJSON(object: any): _200.MsgRefreshRedemptionRate;
+            toJSON(message: _200.MsgRefreshRedemptionRate): import("../json-safe.ts").JsonSafe<_200.MsgRefreshRedemptionRate>;
+            fromPartial(object: Partial<_200.MsgRefreshRedemptionRate>): _200.MsgRefreshRedemptionRate;
+            fromProtoMsg(message: _200.MsgRefreshRedemptionRateProtoMsg): _200.MsgRefreshRedemptionRate;
+            toProto(message: _200.MsgRefreshRedemptionRate): Uint8Array;
+            toProtoMsg(message: _200.MsgRefreshRedemptionRate): _200.MsgRefreshRedemptionRateProtoMsg;
+        };
+        MsgRefreshRedemptionRateResponse: {
+            typeUrl: "/stride.staketia.MsgRefreshRedemptionRateResponse";
+            encode(_: _200.MsgRefreshRedemptionRateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgRefreshRedemptionRateResponse;
+            fromJSON(_: any): _200.MsgRefreshRedemptionRateResponse;
+            toJSON(_: _200.MsgRefreshRedemptionRateResponse): import("../json-safe.ts").JsonSafe<_200.MsgRefreshRedemptionRateResponse>;
+            fromPartial(_: Partial<_200.MsgRefreshRedemptionRateResponse>): _200.MsgRefreshRedemptionRateResponse;
+            fromProtoMsg(message: _200.MsgRefreshRedemptionRateResponseProtoMsg): _200.MsgRefreshRedemptionRateResponse;
+            toProto(message: _200.MsgRefreshRedemptionRateResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgRefreshRedemptionRateResponse): _200.MsgRefreshRedemptionRateResponseProtoMsg;
+        };
+        MsgOverwriteDelegationRecord: {
+            typeUrl: "/stride.staketia.MsgOverwriteDelegationRecord";
+            encode(message: _200.MsgOverwriteDelegationRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgOverwriteDelegationRecord;
+            fromJSON(object: any): _200.MsgOverwriteDelegationRecord;
+            toJSON(message: _200.MsgOverwriteDelegationRecord): import("../json-safe.ts").JsonSafe<_200.MsgOverwriteDelegationRecord>;
+            fromPartial(object: Partial<_200.MsgOverwriteDelegationRecord>): _200.MsgOverwriteDelegationRecord;
+            fromProtoMsg(message: _200.MsgOverwriteDelegationRecordProtoMsg): _200.MsgOverwriteDelegationRecord;
+            toProto(message: _200.MsgOverwriteDelegationRecord): Uint8Array;
+            toProtoMsg(message: _200.MsgOverwriteDelegationRecord): _200.MsgOverwriteDelegationRecordProtoMsg;
+        };
+        MsgOverwriteDelegationRecordResponse: {
+            typeUrl: "/stride.staketia.MsgOverwriteDelegationRecordResponse";
+            encode(_: _200.MsgOverwriteDelegationRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgOverwriteDelegationRecordResponse;
+            fromJSON(_: any): _200.MsgOverwriteDelegationRecordResponse;
+            toJSON(_: _200.MsgOverwriteDelegationRecordResponse): import("../json-safe.ts").JsonSafe<_200.MsgOverwriteDelegationRecordResponse>;
+            fromPartial(_: Partial<_200.MsgOverwriteDelegationRecordResponse>): _200.MsgOverwriteDelegationRecordResponse;
+            fromProtoMsg(message: _200.MsgOverwriteDelegationRecordResponseProtoMsg): _200.MsgOverwriteDelegationRecordResponse;
+            toProto(message: _200.MsgOverwriteDelegationRecordResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgOverwriteDelegationRecordResponse): _200.MsgOverwriteDelegationRecordResponseProtoMsg;
+        };
+        MsgOverwriteUnbondingRecord: {
+            typeUrl: "/stride.staketia.MsgOverwriteUnbondingRecord";
+            encode(message: _200.MsgOverwriteUnbondingRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgOverwriteUnbondingRecord;
+            fromJSON(object: any): _200.MsgOverwriteUnbondingRecord;
+            toJSON(message: _200.MsgOverwriteUnbondingRecord): import("../json-safe.ts").JsonSafe<_200.MsgOverwriteUnbondingRecord>;
+            fromPartial(object: Partial<_200.MsgOverwriteUnbondingRecord>): _200.MsgOverwriteUnbondingRecord;
+            fromProtoMsg(message: _200.MsgOverwriteUnbondingRecordProtoMsg): _200.MsgOverwriteUnbondingRecord;
+            toProto(message: _200.MsgOverwriteUnbondingRecord): Uint8Array;
+            toProtoMsg(message: _200.MsgOverwriteUnbondingRecord): _200.MsgOverwriteUnbondingRecordProtoMsg;
+        };
+        MsgOverwriteUnbondingRecordResponse: {
+            typeUrl: "/stride.staketia.MsgOverwriteUnbondingRecordResponse";
+            encode(_: _200.MsgOverwriteUnbondingRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgOverwriteUnbondingRecordResponse;
+            fromJSON(_: any): _200.MsgOverwriteUnbondingRecordResponse;
+            toJSON(_: _200.MsgOverwriteUnbondingRecordResponse): import("../json-safe.ts").JsonSafe<_200.MsgOverwriteUnbondingRecordResponse>;
+            fromPartial(_: Partial<_200.MsgOverwriteUnbondingRecordResponse>): _200.MsgOverwriteUnbondingRecordResponse;
+            fromProtoMsg(message: _200.MsgOverwriteUnbondingRecordResponseProtoMsg): _200.MsgOverwriteUnbondingRecordResponse;
+            toProto(message: _200.MsgOverwriteUnbondingRecordResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgOverwriteUnbondingRecordResponse): _200.MsgOverwriteUnbondingRecordResponseProtoMsg;
+        };
+        MsgOverwriteRedemptionRecord: {
+            typeUrl: "/stride.staketia.MsgOverwriteRedemptionRecord";
+            encode(message: _200.MsgOverwriteRedemptionRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgOverwriteRedemptionRecord;
+            fromJSON(object: any): _200.MsgOverwriteRedemptionRecord;
+            toJSON(message: _200.MsgOverwriteRedemptionRecord): import("../json-safe.ts").JsonSafe<_200.MsgOverwriteRedemptionRecord>;
+            fromPartial(object: Partial<_200.MsgOverwriteRedemptionRecord>): _200.MsgOverwriteRedemptionRecord;
+            fromProtoMsg(message: _200.MsgOverwriteRedemptionRecordProtoMsg): _200.MsgOverwriteRedemptionRecord;
+            toProto(message: _200.MsgOverwriteRedemptionRecord): Uint8Array;
+            toProtoMsg(message: _200.MsgOverwriteRedemptionRecord): _200.MsgOverwriteRedemptionRecordProtoMsg;
+        };
+        MsgOverwriteRedemptionRecordResponse: {
+            typeUrl: "/stride.staketia.MsgOverwriteRedemptionRecordResponse";
+            encode(_: _200.MsgOverwriteRedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgOverwriteRedemptionRecordResponse;
+            fromJSON(_: any): _200.MsgOverwriteRedemptionRecordResponse;
+            toJSON(_: _200.MsgOverwriteRedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_200.MsgOverwriteRedemptionRecordResponse>;
+            fromPartial(_: Partial<_200.MsgOverwriteRedemptionRecordResponse>): _200.MsgOverwriteRedemptionRecordResponse;
+            fromProtoMsg(message: _200.MsgOverwriteRedemptionRecordResponseProtoMsg): _200.MsgOverwriteRedemptionRecordResponse;
+            toProto(message: _200.MsgOverwriteRedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgOverwriteRedemptionRecordResponse): _200.MsgOverwriteRedemptionRecordResponseProtoMsg;
+        };
+        MsgSetOperatorAddress: {
+            typeUrl: "/stride.staketia.MsgSetOperatorAddress";
+            encode(message: _200.MsgSetOperatorAddress, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgSetOperatorAddress;
+            fromJSON(object: any): _200.MsgSetOperatorAddress;
+            toJSON(message: _200.MsgSetOperatorAddress): import("../json-safe.ts").JsonSafe<_200.MsgSetOperatorAddress>;
+            fromPartial(object: Partial<_200.MsgSetOperatorAddress>): _200.MsgSetOperatorAddress;
+            fromProtoMsg(message: _200.MsgSetOperatorAddressProtoMsg): _200.MsgSetOperatorAddress;
+            toProto(message: _200.MsgSetOperatorAddress): Uint8Array;
+            toProtoMsg(message: _200.MsgSetOperatorAddress): _200.MsgSetOperatorAddressProtoMsg;
+        };
+        MsgSetOperatorAddressResponse: {
+            typeUrl: "/stride.staketia.MsgSetOperatorAddressResponse";
+            encode(_: _200.MsgSetOperatorAddressResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _200.MsgSetOperatorAddressResponse;
+            fromJSON(_: any): _200.MsgSetOperatorAddressResponse;
+            toJSON(_: _200.MsgSetOperatorAddressResponse): import("../json-safe.ts").JsonSafe<_200.MsgSetOperatorAddressResponse>;
+            fromPartial(_: Partial<_200.MsgSetOperatorAddressResponse>): _200.MsgSetOperatorAddressResponse;
+            fromProtoMsg(message: _200.MsgSetOperatorAddressResponseProtoMsg): _200.MsgSetOperatorAddressResponse;
+            toProto(message: _200.MsgSetOperatorAddressResponse): Uint8Array;
+            toProtoMsg(message: _200.MsgSetOperatorAddressResponse): _200.MsgSetOperatorAddressResponseProtoMsg;
+        };
+        delegationRecordStatusFromJSON(object: any): _199.DelegationRecordStatus;
+        delegationRecordStatusToJSON(object: _199.DelegationRecordStatus): string;
+        unbondingRecordStatusFromJSON(object: any): _199.UnbondingRecordStatus;
+        unbondingRecordStatusToJSON(object: _199.UnbondingRecordStatus): string;
+        DelegationRecordStatus: typeof _199.DelegationRecordStatus;
+        DelegationRecordStatusSDKType: typeof _199.DelegationRecordStatus;
+        UnbondingRecordStatus: typeof _199.UnbondingRecordStatus;
+        UnbondingRecordStatusSDKType: typeof _199.UnbondingRecordStatus;
+        HostZone: {
+            typeUrl: "/stride.staketia.HostZone";
+            encode(message: _199.HostZone, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _199.HostZone;
+            fromJSON(object: any): _199.HostZone;
+            toJSON(message: _199.HostZone): import("../json-safe.ts").JsonSafe<_199.HostZone>;
+            fromPartial(object: Partial<_199.HostZone>): _199.HostZone;
+            fromProtoMsg(message: _199.HostZoneProtoMsg): _199.HostZone;
+            toProto(message: _199.HostZone): Uint8Array;
+            toProtoMsg(message: _199.HostZone): _199.HostZoneProtoMsg;
+        };
+        DelegationRecord: {
+            typeUrl: "/stride.staketia.DelegationRecord";
+            encode(message: _199.DelegationRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _199.DelegationRecord;
+            fromJSON(object: any): _199.DelegationRecord;
+            toJSON(message: _199.DelegationRecord): import("../json-safe.ts").JsonSafe<_199.DelegationRecord>;
+            fromPartial(object: Partial<_199.DelegationRecord>): _199.DelegationRecord;
+            fromProtoMsg(message: _199.DelegationRecordProtoMsg): _199.DelegationRecord;
+            toProto(message: _199.DelegationRecord): Uint8Array;
+            toProtoMsg(message: _199.DelegationRecord): _199.DelegationRecordProtoMsg;
+        };
+        UnbondingRecord: {
+            typeUrl: "/stride.staketia.UnbondingRecord";
+            encode(message: _199.UnbondingRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _199.UnbondingRecord;
+            fromJSON(object: any): _199.UnbondingRecord;
+            toJSON(message: _199.UnbondingRecord): import("../json-safe.ts").JsonSafe<_199.UnbondingRecord>;
+            fromPartial(object: Partial<_199.UnbondingRecord>): _199.UnbondingRecord;
+            fromProtoMsg(message: _199.UnbondingRecordProtoMsg): _199.UnbondingRecord;
+            toProto(message: _199.UnbondingRecord): Uint8Array;
+            toProtoMsg(message: _199.UnbondingRecord): _199.UnbondingRecordProtoMsg;
+        };
+        RedemptionRecord: {
+            typeUrl: "/stride.staketia.RedemptionRecord";
+            encode(message: _199.RedemptionRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _199.RedemptionRecord;
+            fromJSON(object: any): _199.RedemptionRecord;
+            toJSON(message: _199.RedemptionRecord): import("../json-safe.ts").JsonSafe<_199.RedemptionRecord>;
+            fromPartial(object: Partial<_199.RedemptionRecord>): _199.RedemptionRecord;
+            fromProtoMsg(message: _199.RedemptionRecordProtoMsg): _199.RedemptionRecord;
+            toProto(message: _199.RedemptionRecord): Uint8Array;
+            toProtoMsg(message: _199.RedemptionRecord): _199.RedemptionRecordProtoMsg;
+        };
+        SlashRecord: {
+            typeUrl: "/stride.staketia.SlashRecord";
+            encode(message: _199.SlashRecord, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _199.SlashRecord;
+            fromJSON(object: any): _199.SlashRecord;
+            toJSON(message: _199.SlashRecord): import("../json-safe.ts").JsonSafe<_199.SlashRecord>;
+            fromPartial(object: Partial<_199.SlashRecord>): _199.SlashRecord;
+            fromProtoMsg(message: _199.SlashRecordProtoMsg): _199.SlashRecord;
+            toProto(message: _199.SlashRecord): Uint8Array;
+            toProtoMsg(message: _199.SlashRecord): _199.SlashRecordProtoMsg;
+        };
+        QueryHostZoneRequest: {
+            typeUrl: "/stride.staketia.QueryHostZoneRequest";
+            encode(_: _198.QueryHostZoneRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryHostZoneRequest;
+            fromJSON(_: any): _198.QueryHostZoneRequest;
+            toJSON(_: _198.QueryHostZoneRequest): import("../json-safe.ts").JsonSafe<_198.QueryHostZoneRequest>;
+            fromPartial(_: Partial<_198.QueryHostZoneRequest>): _198.QueryHostZoneRequest;
+            fromProtoMsg(message: _198.QueryHostZoneRequestProtoMsg): _198.QueryHostZoneRequest;
+            toProto(message: _198.QueryHostZoneRequest): Uint8Array;
+            toProtoMsg(message: _198.QueryHostZoneRequest): _198.QueryHostZoneRequestProtoMsg;
+        };
+        QueryHostZoneResponse: {
+            typeUrl: "/stride.staketia.QueryHostZoneResponse";
+            encode(message: _198.QueryHostZoneResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryHostZoneResponse;
+            fromJSON(object: any): _198.QueryHostZoneResponse;
+            toJSON(message: _198.QueryHostZoneResponse): import("../json-safe.ts").JsonSafe<_198.QueryHostZoneResponse>;
+            fromPartial(object: Partial<_198.QueryHostZoneResponse>): _198.QueryHostZoneResponse;
+            fromProtoMsg(message: _198.QueryHostZoneResponseProtoMsg): _198.QueryHostZoneResponse;
+            toProto(message: _198.QueryHostZoneResponse): Uint8Array;
+            toProtoMsg(message: _198.QueryHostZoneResponse): _198.QueryHostZoneResponseProtoMsg;
+        };
+        QueryDelegationRecordsRequest: {
+            typeUrl: "/stride.staketia.QueryDelegationRecordsRequest";
+            encode(message: _198.QueryDelegationRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryDelegationRecordsRequest;
+            fromJSON(object: any): _198.QueryDelegationRecordsRequest;
+            toJSON(message: _198.QueryDelegationRecordsRequest): import("../json-safe.ts").JsonSafe<_198.QueryDelegationRecordsRequest>;
+            fromPartial(object: Partial<_198.QueryDelegationRecordsRequest>): _198.QueryDelegationRecordsRequest;
+            fromProtoMsg(message: _198.QueryDelegationRecordsRequestProtoMsg): _198.QueryDelegationRecordsRequest;
+            toProto(message: _198.QueryDelegationRecordsRequest): Uint8Array;
+            toProtoMsg(message: _198.QueryDelegationRecordsRequest): _198.QueryDelegationRecordsRequestProtoMsg;
+        };
+        QueryDelegationRecordsResponse: {
+            typeUrl: "/stride.staketia.QueryDelegationRecordsResponse";
+            encode(message: _198.QueryDelegationRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryDelegationRecordsResponse;
+            fromJSON(object: any): _198.QueryDelegationRecordsResponse;
+            toJSON(message: _198.QueryDelegationRecordsResponse): import("../json-safe.ts").JsonSafe<_198.QueryDelegationRecordsResponse>;
+            fromPartial(object: Partial<_198.QueryDelegationRecordsResponse>): _198.QueryDelegationRecordsResponse;
+            fromProtoMsg(message: _198.QueryDelegationRecordsResponseProtoMsg): _198.QueryDelegationRecordsResponse;
+            toProto(message: _198.QueryDelegationRecordsResponse): Uint8Array;
+            toProtoMsg(message: _198.QueryDelegationRecordsResponse): _198.QueryDelegationRecordsResponseProtoMsg;
+        };
+        QueryUnbondingRecordsRequest: {
+            typeUrl: "/stride.staketia.QueryUnbondingRecordsRequest";
+            encode(message: _198.QueryUnbondingRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryUnbondingRecordsRequest;
+            fromJSON(object: any): _198.QueryUnbondingRecordsRequest;
+            toJSON(message: _198.QueryUnbondingRecordsRequest): import("../json-safe.ts").JsonSafe<_198.QueryUnbondingRecordsRequest>;
+            fromPartial(object: Partial<_198.QueryUnbondingRecordsRequest>): _198.QueryUnbondingRecordsRequest;
+            fromProtoMsg(message: _198.QueryUnbondingRecordsRequestProtoMsg): _198.QueryUnbondingRecordsRequest;
+            toProto(message: _198.QueryUnbondingRecordsRequest): Uint8Array;
+            toProtoMsg(message: _198.QueryUnbondingRecordsRequest): _198.QueryUnbondingRecordsRequestProtoMsg;
+        };
+        QueryUnbondingRecordsResponse: {
+            typeUrl: "/stride.staketia.QueryUnbondingRecordsResponse";
+            encode(message: _198.QueryUnbondingRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryUnbondingRecordsResponse;
+            fromJSON(object: any): _198.QueryUnbondingRecordsResponse;
+            toJSON(message: _198.QueryUnbondingRecordsResponse): import("../json-safe.ts").JsonSafe<_198.QueryUnbondingRecordsResponse>;
+            fromPartial(object: Partial<_198.QueryUnbondingRecordsResponse>): _198.QueryUnbondingRecordsResponse;
+            fromProtoMsg(message: _198.QueryUnbondingRecordsResponseProtoMsg): _198.QueryUnbondingRecordsResponse;
+            toProto(message: _198.QueryUnbondingRecordsResponse): Uint8Array;
+            toProtoMsg(message: _198.QueryUnbondingRecordsResponse): _198.QueryUnbondingRecordsResponseProtoMsg;
+        };
+        QueryRedemptionRecordRequest: {
+            typeUrl: "/stride.staketia.QueryRedemptionRecordRequest";
+            encode(message: _198.QueryRedemptionRecordRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryRedemptionRecordRequest;
+            fromJSON(object: any): _198.QueryRedemptionRecordRequest;
+            toJSON(message: _198.QueryRedemptionRecordRequest): import("../json-safe.ts").JsonSafe<_198.QueryRedemptionRecordRequest>;
+            fromPartial(object: Partial<_198.QueryRedemptionRecordRequest>): _198.QueryRedemptionRecordRequest;
+            fromProtoMsg(message: _198.QueryRedemptionRecordRequestProtoMsg): _198.QueryRedemptionRecordRequest;
+            toProto(message: _198.QueryRedemptionRecordRequest): Uint8Array;
+            toProtoMsg(message: _198.QueryRedemptionRecordRequest): _198.QueryRedemptionRecordRequestProtoMsg;
+        };
+        QueryRedemptionRecordResponse: {
+            typeUrl: "/stride.staketia.QueryRedemptionRecordResponse";
+            encode(message: _198.QueryRedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryRedemptionRecordResponse;
+            fromJSON(object: any): _198.QueryRedemptionRecordResponse;
+            toJSON(message: _198.QueryRedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_198.QueryRedemptionRecordResponse>;
+            fromPartial(object: Partial<_198.QueryRedemptionRecordResponse>): _198.QueryRedemptionRecordResponse;
+            fromProtoMsg(message: _198.QueryRedemptionRecordResponseProtoMsg): _198.QueryRedemptionRecordResponse;
+            toProto(message: _198.QueryRedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _198.QueryRedemptionRecordResponse): _198.QueryRedemptionRecordResponseProtoMsg;
+        };
+        QueryRedemptionRecordsRequest: {
+            typeUrl: "/stride.staketia.QueryRedemptionRecordsRequest";
+            encode(message: _198.QueryRedemptionRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryRedemptionRecordsRequest;
+            fromJSON(object: any): _198.QueryRedemptionRecordsRequest;
+            toJSON(message: _198.QueryRedemptionRecordsRequest): import("../json-safe.ts").JsonSafe<_198.QueryRedemptionRecordsRequest>;
+            fromPartial(object: Partial<_198.QueryRedemptionRecordsRequest>): _198.QueryRedemptionRecordsRequest;
+            fromProtoMsg(message: _198.QueryRedemptionRecordsRequestProtoMsg): _198.QueryRedemptionRecordsRequest;
+            toProto(message: _198.QueryRedemptionRecordsRequest): Uint8Array;
+            toProtoMsg(message: _198.QueryRedemptionRecordsRequest): _198.QueryRedemptionRecordsRequestProtoMsg;
+        };
+        QueryRedemptionRecordsResponse: {
+            typeUrl: "/stride.staketia.QueryRedemptionRecordsResponse";
+            encode(message: _198.QueryRedemptionRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QueryRedemptionRecordsResponse;
+            fromJSON(object: any): _198.QueryRedemptionRecordsResponse;
+            toJSON(message: _198.QueryRedemptionRecordsResponse): import("../json-safe.ts").JsonSafe<_198.QueryRedemptionRecordsResponse>;
+            fromPartial(object: Partial<_198.QueryRedemptionRecordsResponse>): _198.QueryRedemptionRecordsResponse;
+            fromProtoMsg(message: _198.QueryRedemptionRecordsResponseProtoMsg): _198.QueryRedemptionRecordsResponse;
+            toProto(message: _198.QueryRedemptionRecordsResponse): Uint8Array;
+            toProtoMsg(message: _198.QueryRedemptionRecordsResponse): _198.QueryRedemptionRecordsResponseProtoMsg;
+        };
+        QuerySlashRecordsRequest: {
+            typeUrl: "/stride.staketia.QuerySlashRecordsRequest";
+            encode(_: _198.QuerySlashRecordsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QuerySlashRecordsRequest;
+            fromJSON(_: any): _198.QuerySlashRecordsRequest;
+            toJSON(_: _198.QuerySlashRecordsRequest): import("../json-safe.ts").JsonSafe<_198.QuerySlashRecordsRequest>;
+            fromPartial(_: Partial<_198.QuerySlashRecordsRequest>): _198.QuerySlashRecordsRequest;
+            fromProtoMsg(message: _198.QuerySlashRecordsRequestProtoMsg): _198.QuerySlashRecordsRequest;
+            toProto(message: _198.QuerySlashRecordsRequest): Uint8Array;
+            toProtoMsg(message: _198.QuerySlashRecordsRequest): _198.QuerySlashRecordsRequestProtoMsg;
+        };
+        QuerySlashRecordsResponse: {
+            typeUrl: "/stride.staketia.QuerySlashRecordsResponse";
+            encode(message: _198.QuerySlashRecordsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.QuerySlashRecordsResponse;
+            fromJSON(object: any): _198.QuerySlashRecordsResponse;
+            toJSON(message: _198.QuerySlashRecordsResponse): import("../json-safe.ts").JsonSafe<_198.QuerySlashRecordsResponse>;
+            fromPartial(object: Partial<_198.QuerySlashRecordsResponse>): _198.QuerySlashRecordsResponse;
+            fromProtoMsg(message: _198.QuerySlashRecordsResponseProtoMsg): _198.QuerySlashRecordsResponse;
+            toProto(message: _198.QuerySlashRecordsResponse): Uint8Array;
+            toProtoMsg(message: _198.QuerySlashRecordsResponse): _198.QuerySlashRecordsResponseProtoMsg;
+        };
+        RedemptionRecordResponse: {
+            typeUrl: "/stride.staketia.RedemptionRecordResponse";
+            encode(message: _198.RedemptionRecordResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _198.RedemptionRecordResponse;
+            fromJSON(object: any): _198.RedemptionRecordResponse;
+            toJSON(message: _198.RedemptionRecordResponse): import("../json-safe.ts").JsonSafe<_198.RedemptionRecordResponse>;
+            fromPartial(object: Partial<_198.RedemptionRecordResponse>): _198.RedemptionRecordResponse;
+            fromProtoMsg(message: _198.RedemptionRecordResponseProtoMsg): _198.RedemptionRecordResponse;
+            toProto(message: _198.RedemptionRecordResponse): Uint8Array;
+            toProtoMsg(message: _198.RedemptionRecordResponse): _198.RedemptionRecordResponseProtoMsg;
+        };
+        Params: {
+            typeUrl: "/stride.staketia.Params";
+            encode(_: _197.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _197.Params;
+            fromJSON(_: any): _197.Params;
+            toJSON(_: _197.Params): import("../json-safe.ts").JsonSafe<_197.Params>;
+            fromPartial(_: Partial<_197.Params>): _197.Params;
+            fromProtoMsg(message: _197.ParamsProtoMsg): _197.Params;
+            toProto(message: _197.Params): Uint8Array;
+            toProtoMsg(message: _197.Params): _197.ParamsProtoMsg;
+        };
+        TransferInProgressRecordIds: {
+            typeUrl: "/stride.staketia.TransferInProgressRecordIds";
+            encode(message: _197.TransferInProgressRecordIds, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _197.TransferInProgressRecordIds;
+            fromJSON(object: any): _197.TransferInProgressRecordIds;
+            toJSON(message: _197.TransferInProgressRecordIds): import("../json-safe.ts").JsonSafe<_197.TransferInProgressRecordIds>;
+            fromPartial(object: Partial<_197.TransferInProgressRecordIds>): _197.TransferInProgressRecordIds;
+            fromProtoMsg(message: _197.TransferInProgressRecordIdsProtoMsg): _197.TransferInProgressRecordIds;
+            toProto(message: _197.TransferInProgressRecordIds): Uint8Array;
+            toProtoMsg(message: _197.TransferInProgressRecordIds): _197.TransferInProgressRecordIdsProtoMsg;
+        };
+        GenesisState: {
+            typeUrl: "/stride.staketia.GenesisState";
+            encode(message: _197.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _197.GenesisState;
+            fromJSON(object: any): _197.GenesisState;
+            toJSON(message: _197.GenesisState): import("../json-safe.ts").JsonSafe<_197.GenesisState>;
+            fromPartial(object: Partial<_197.GenesisState>): _197.GenesisState;
+            fromProtoMsg(message: _197.GenesisStateProtoMsg): _197.GenesisState;
+            toProto(message: _197.GenesisState): Uint8Array;
+            toProtoMsg(message: _197.GenesisState): _197.GenesisStateProtoMsg;
+        };
+    };
+}
+//# sourceMappingURL=bundle.d.ts.map