@agoric/cosmic-proto 0.5.0-u18.5 → 0.5.0-u19.0

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

@@ -0,0 +1,1363 @@
+import * as _17 from './cctp/v1/attester.js';
+import * as _18 from './cctp/v1/burn_message.js';
+import * as _19 from './cctp/v1/burning_and_minting_paused.js';
+import * as _20 from './cctp/v1/events.js';
+import * as _21 from './cctp/v1/genesis.js';
+import * as _22 from './cctp/v1/max_message_body_size.js';
+import * as _23 from './cctp/v1/message.js';
+import * as _24 from './cctp/v1/nonce.js';
+import * as _25 from './cctp/v1/per_message_burn_limit.js';
+import * as _26 from './cctp/v1/query.js';
+import * as _27 from './cctp/v1/remote_token_messenger.js';
+import * as _28 from './cctp/v1/sending_and_receiving_messages_paused.js';
+import * as _29 from './cctp/v1/signature_threshold.js';
+import * as _30 from './cctp/v1/token_pair.js';
+import * as _31 from './cctp/v1/tx.js';
+export declare namespace circle {
+    namespace cctp {
+        const v1: {
+            MsgUpdateOwner: {
+                typeUrl: string;
+                encode(message: _31.MsgUpdateOwner, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateOwner;
+                fromJSON(object: any): _31.MsgUpdateOwner;
+                toJSON(message: _31.MsgUpdateOwner): import("../json-safe.ts").JsonSafe<_31.MsgUpdateOwner>;
+                fromPartial(object: Partial<_31.MsgUpdateOwner>): _31.MsgUpdateOwner;
+                fromProtoMsg(message: _31.MsgUpdateOwnerProtoMsg): _31.MsgUpdateOwner;
+                toProto(message: _31.MsgUpdateOwner): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateOwner): _31.MsgUpdateOwnerProtoMsg;
+            };
+            MsgUpdateOwnerResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUpdateOwnerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateOwnerResponse;
+                fromJSON(_: any): _31.MsgUpdateOwnerResponse;
+                toJSON(_: _31.MsgUpdateOwnerResponse): import("../json-safe.ts").JsonSafe<_31.MsgUpdateOwnerResponse>;
+                fromPartial(_: Partial<_31.MsgUpdateOwnerResponse>): _31.MsgUpdateOwnerResponse;
+                fromProtoMsg(message: _31.MsgUpdateOwnerResponseProtoMsg): _31.MsgUpdateOwnerResponse;
+                toProto(message: _31.MsgUpdateOwnerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateOwnerResponse): _31.MsgUpdateOwnerResponseProtoMsg;
+            };
+            MsgUpdateAttesterManager: {
+                typeUrl: string;
+                encode(message: _31.MsgUpdateAttesterManager, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateAttesterManager;
+                fromJSON(object: any): _31.MsgUpdateAttesterManager;
+                toJSON(message: _31.MsgUpdateAttesterManager): import("../json-safe.ts").JsonSafe<_31.MsgUpdateAttesterManager>;
+                fromPartial(object: Partial<_31.MsgUpdateAttesterManager>): _31.MsgUpdateAttesterManager;
+                fromProtoMsg(message: _31.MsgUpdateAttesterManagerProtoMsg): _31.MsgUpdateAttesterManager;
+                toProto(message: _31.MsgUpdateAttesterManager): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateAttesterManager): _31.MsgUpdateAttesterManagerProtoMsg;
+            };
+            MsgUpdateAttesterManagerResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUpdateAttesterManagerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateAttesterManagerResponse;
+                fromJSON(_: any): _31.MsgUpdateAttesterManagerResponse;
+                toJSON(_: _31.MsgUpdateAttesterManagerResponse): import("../json-safe.ts").JsonSafe<_31.MsgUpdateAttesterManagerResponse>;
+                fromPartial(_: Partial<_31.MsgUpdateAttesterManagerResponse>): _31.MsgUpdateAttesterManagerResponse;
+                fromProtoMsg(message: _31.MsgUpdateAttesterManagerResponseProtoMsg): _31.MsgUpdateAttesterManagerResponse;
+                toProto(message: _31.MsgUpdateAttesterManagerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateAttesterManagerResponse): _31.MsgUpdateAttesterManagerResponseProtoMsg;
+            };
+            MsgUpdateTokenController: {
+                typeUrl: string;
+                encode(message: _31.MsgUpdateTokenController, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateTokenController;
+                fromJSON(object: any): _31.MsgUpdateTokenController;
+                toJSON(message: _31.MsgUpdateTokenController): import("../json-safe.ts").JsonSafe<_31.MsgUpdateTokenController>;
+                fromPartial(object: Partial<_31.MsgUpdateTokenController>): _31.MsgUpdateTokenController;
+                fromProtoMsg(message: _31.MsgUpdateTokenControllerProtoMsg): _31.MsgUpdateTokenController;
+                toProto(message: _31.MsgUpdateTokenController): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateTokenController): _31.MsgUpdateTokenControllerProtoMsg;
+            };
+            MsgUpdateTokenControllerResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUpdateTokenControllerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateTokenControllerResponse;
+                fromJSON(_: any): _31.MsgUpdateTokenControllerResponse;
+                toJSON(_: _31.MsgUpdateTokenControllerResponse): import("../json-safe.ts").JsonSafe<_31.MsgUpdateTokenControllerResponse>;
+                fromPartial(_: Partial<_31.MsgUpdateTokenControllerResponse>): _31.MsgUpdateTokenControllerResponse;
+                fromProtoMsg(message: _31.MsgUpdateTokenControllerResponseProtoMsg): _31.MsgUpdateTokenControllerResponse;
+                toProto(message: _31.MsgUpdateTokenControllerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateTokenControllerResponse): _31.MsgUpdateTokenControllerResponseProtoMsg;
+            };
+            MsgUpdatePauser: {
+                typeUrl: string;
+                encode(message: _31.MsgUpdatePauser, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdatePauser;
+                fromJSON(object: any): _31.MsgUpdatePauser;
+                toJSON(message: _31.MsgUpdatePauser): import("../json-safe.ts").JsonSafe<_31.MsgUpdatePauser>;
+                fromPartial(object: Partial<_31.MsgUpdatePauser>): _31.MsgUpdatePauser;
+                fromProtoMsg(message: _31.MsgUpdatePauserProtoMsg): _31.MsgUpdatePauser;
+                toProto(message: _31.MsgUpdatePauser): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdatePauser): _31.MsgUpdatePauserProtoMsg;
+            };
+            MsgUpdatePauserResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUpdatePauserResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdatePauserResponse;
+                fromJSON(_: any): _31.MsgUpdatePauserResponse;
+                toJSON(_: _31.MsgUpdatePauserResponse): import("../json-safe.ts").JsonSafe<_31.MsgUpdatePauserResponse>;
+                fromPartial(_: Partial<_31.MsgUpdatePauserResponse>): _31.MsgUpdatePauserResponse;
+                fromProtoMsg(message: _31.MsgUpdatePauserResponseProtoMsg): _31.MsgUpdatePauserResponse;
+                toProto(message: _31.MsgUpdatePauserResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdatePauserResponse): _31.MsgUpdatePauserResponseProtoMsg;
+            };
+            MsgAcceptOwner: {
+                typeUrl: string;
+                encode(message: _31.MsgAcceptOwner, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgAcceptOwner;
+                fromJSON(object: any): _31.MsgAcceptOwner;
+                toJSON(message: _31.MsgAcceptOwner): import("../json-safe.ts").JsonSafe<_31.MsgAcceptOwner>;
+                fromPartial(object: Partial<_31.MsgAcceptOwner>): _31.MsgAcceptOwner;
+                fromProtoMsg(message: _31.MsgAcceptOwnerProtoMsg): _31.MsgAcceptOwner;
+                toProto(message: _31.MsgAcceptOwner): Uint8Array;
+                toProtoMsg(message: _31.MsgAcceptOwner): _31.MsgAcceptOwnerProtoMsg;
+            };
+            MsgAcceptOwnerResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgAcceptOwnerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgAcceptOwnerResponse;
+                fromJSON(_: any): _31.MsgAcceptOwnerResponse;
+                toJSON(_: _31.MsgAcceptOwnerResponse): import("../json-safe.ts").JsonSafe<_31.MsgAcceptOwnerResponse>;
+                fromPartial(_: Partial<_31.MsgAcceptOwnerResponse>): _31.MsgAcceptOwnerResponse;
+                fromProtoMsg(message: _31.MsgAcceptOwnerResponseProtoMsg): _31.MsgAcceptOwnerResponse;
+                toProto(message: _31.MsgAcceptOwnerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgAcceptOwnerResponse): _31.MsgAcceptOwnerResponseProtoMsg;
+            };
+            MsgEnableAttester: {
+                typeUrl: string;
+                encode(message: _31.MsgEnableAttester, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgEnableAttester;
+                fromJSON(object: any): _31.MsgEnableAttester;
+                toJSON(message: _31.MsgEnableAttester): import("../json-safe.ts").JsonSafe<_31.MsgEnableAttester>;
+                fromPartial(object: Partial<_31.MsgEnableAttester>): _31.MsgEnableAttester;
+                fromProtoMsg(message: _31.MsgEnableAttesterProtoMsg): _31.MsgEnableAttester;
+                toProto(message: _31.MsgEnableAttester): Uint8Array;
+                toProtoMsg(message: _31.MsgEnableAttester): _31.MsgEnableAttesterProtoMsg;
+            };
+            MsgEnableAttesterResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgEnableAttesterResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgEnableAttesterResponse;
+                fromJSON(_: any): _31.MsgEnableAttesterResponse;
+                toJSON(_: _31.MsgEnableAttesterResponse): import("../json-safe.ts").JsonSafe<_31.MsgEnableAttesterResponse>;
+                fromPartial(_: Partial<_31.MsgEnableAttesterResponse>): _31.MsgEnableAttesterResponse;
+                fromProtoMsg(message: _31.MsgEnableAttesterResponseProtoMsg): _31.MsgEnableAttesterResponse;
+                toProto(message: _31.MsgEnableAttesterResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgEnableAttesterResponse): _31.MsgEnableAttesterResponseProtoMsg;
+            };
+            MsgDisableAttester: {
+                typeUrl: string;
+                encode(message: _31.MsgDisableAttester, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgDisableAttester;
+                fromJSON(object: any): _31.MsgDisableAttester;
+                toJSON(message: _31.MsgDisableAttester): import("../json-safe.ts").JsonSafe<_31.MsgDisableAttester>;
+                fromPartial(object: Partial<_31.MsgDisableAttester>): _31.MsgDisableAttester;
+                fromProtoMsg(message: _31.MsgDisableAttesterProtoMsg): _31.MsgDisableAttester;
+                toProto(message: _31.MsgDisableAttester): Uint8Array;
+                toProtoMsg(message: _31.MsgDisableAttester): _31.MsgDisableAttesterProtoMsg;
+            };
+            MsgDisableAttesterResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgDisableAttesterResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgDisableAttesterResponse;
+                fromJSON(_: any): _31.MsgDisableAttesterResponse;
+                toJSON(_: _31.MsgDisableAttesterResponse): import("../json-safe.ts").JsonSafe<_31.MsgDisableAttesterResponse>;
+                fromPartial(_: Partial<_31.MsgDisableAttesterResponse>): _31.MsgDisableAttesterResponse;
+                fromProtoMsg(message: _31.MsgDisableAttesterResponseProtoMsg): _31.MsgDisableAttesterResponse;
+                toProto(message: _31.MsgDisableAttesterResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgDisableAttesterResponse): _31.MsgDisableAttesterResponseProtoMsg;
+            };
+            MsgPauseBurningAndMinting: {
+                typeUrl: string;
+                encode(message: _31.MsgPauseBurningAndMinting, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgPauseBurningAndMinting;
+                fromJSON(object: any): _31.MsgPauseBurningAndMinting;
+                toJSON(message: _31.MsgPauseBurningAndMinting): import("../json-safe.ts").JsonSafe<_31.MsgPauseBurningAndMinting>;
+                fromPartial(object: Partial<_31.MsgPauseBurningAndMinting>): _31.MsgPauseBurningAndMinting;
+                fromProtoMsg(message: _31.MsgPauseBurningAndMintingProtoMsg): _31.MsgPauseBurningAndMinting;
+                toProto(message: _31.MsgPauseBurningAndMinting): Uint8Array;
+                toProtoMsg(message: _31.MsgPauseBurningAndMinting): _31.MsgPauseBurningAndMintingProtoMsg;
+            };
+            MsgPauseBurningAndMintingResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgPauseBurningAndMintingResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgPauseBurningAndMintingResponse;
+                fromJSON(_: any): _31.MsgPauseBurningAndMintingResponse;
+                toJSON(_: _31.MsgPauseBurningAndMintingResponse): import("../json-safe.ts").JsonSafe<_31.MsgPauseBurningAndMintingResponse>;
+                fromPartial(_: Partial<_31.MsgPauseBurningAndMintingResponse>): _31.MsgPauseBurningAndMintingResponse;
+                fromProtoMsg(message: _31.MsgPauseBurningAndMintingResponseProtoMsg): _31.MsgPauseBurningAndMintingResponse;
+                toProto(message: _31.MsgPauseBurningAndMintingResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgPauseBurningAndMintingResponse): _31.MsgPauseBurningAndMintingResponseProtoMsg;
+            };
+            MsgUnpauseBurningAndMinting: {
+                typeUrl: string;
+                encode(message: _31.MsgUnpauseBurningAndMinting, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUnpauseBurningAndMinting;
+                fromJSON(object: any): _31.MsgUnpauseBurningAndMinting;
+                toJSON(message: _31.MsgUnpauseBurningAndMinting): import("../json-safe.ts").JsonSafe<_31.MsgUnpauseBurningAndMinting>;
+                fromPartial(object: Partial<_31.MsgUnpauseBurningAndMinting>): _31.MsgUnpauseBurningAndMinting;
+                fromProtoMsg(message: _31.MsgUnpauseBurningAndMintingProtoMsg): _31.MsgUnpauseBurningAndMinting;
+                toProto(message: _31.MsgUnpauseBurningAndMinting): Uint8Array;
+                toProtoMsg(message: _31.MsgUnpauseBurningAndMinting): _31.MsgUnpauseBurningAndMintingProtoMsg;
+            };
+            MsgUnpauseBurningAndMintingResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUnpauseBurningAndMintingResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUnpauseBurningAndMintingResponse;
+                fromJSON(_: any): _31.MsgUnpauseBurningAndMintingResponse;
+                toJSON(_: _31.MsgUnpauseBurningAndMintingResponse): import("../json-safe.ts").JsonSafe<_31.MsgUnpauseBurningAndMintingResponse>;
+                fromPartial(_: Partial<_31.MsgUnpauseBurningAndMintingResponse>): _31.MsgUnpauseBurningAndMintingResponse;
+                fromProtoMsg(message: _31.MsgUnpauseBurningAndMintingResponseProtoMsg): _31.MsgUnpauseBurningAndMintingResponse;
+                toProto(message: _31.MsgUnpauseBurningAndMintingResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUnpauseBurningAndMintingResponse): _31.MsgUnpauseBurningAndMintingResponseProtoMsg;
+            };
+            MsgPauseSendingAndReceivingMessages: {
+                typeUrl: string;
+                encode(message: _31.MsgPauseSendingAndReceivingMessages, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgPauseSendingAndReceivingMessages;
+                fromJSON(object: any): _31.MsgPauseSendingAndReceivingMessages;
+                toJSON(message: _31.MsgPauseSendingAndReceivingMessages): import("../json-safe.ts").JsonSafe<_31.MsgPauseSendingAndReceivingMessages>;
+                fromPartial(object: Partial<_31.MsgPauseSendingAndReceivingMessages>): _31.MsgPauseSendingAndReceivingMessages;
+                fromProtoMsg(message: _31.MsgPauseSendingAndReceivingMessagesProtoMsg): _31.MsgPauseSendingAndReceivingMessages;
+                toProto(message: _31.MsgPauseSendingAndReceivingMessages): Uint8Array;
+                toProtoMsg(message: _31.MsgPauseSendingAndReceivingMessages): _31.MsgPauseSendingAndReceivingMessagesProtoMsg;
+            };
+            MsgPauseSendingAndReceivingMessagesResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgPauseSendingAndReceivingMessagesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgPauseSendingAndReceivingMessagesResponse;
+                fromJSON(_: any): _31.MsgPauseSendingAndReceivingMessagesResponse;
+                toJSON(_: _31.MsgPauseSendingAndReceivingMessagesResponse): import("../json-safe.ts").JsonSafe<_31.MsgPauseSendingAndReceivingMessagesResponse>;
+                fromPartial(_: Partial<_31.MsgPauseSendingAndReceivingMessagesResponse>): _31.MsgPauseSendingAndReceivingMessagesResponse;
+                fromProtoMsg(message: _31.MsgPauseSendingAndReceivingMessagesResponseProtoMsg): _31.MsgPauseSendingAndReceivingMessagesResponse;
+                toProto(message: _31.MsgPauseSendingAndReceivingMessagesResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgPauseSendingAndReceivingMessagesResponse): _31.MsgPauseSendingAndReceivingMessagesResponseProtoMsg;
+            };
+            MsgUnpauseSendingAndReceivingMessages: {
+                typeUrl: string;
+                encode(message: _31.MsgUnpauseSendingAndReceivingMessages, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUnpauseSendingAndReceivingMessages;
+                fromJSON(object: any): _31.MsgUnpauseSendingAndReceivingMessages;
+                toJSON(message: _31.MsgUnpauseSendingAndReceivingMessages): import("../json-safe.ts").JsonSafe<_31.MsgUnpauseSendingAndReceivingMessages>;
+                fromPartial(object: Partial<_31.MsgUnpauseSendingAndReceivingMessages>): _31.MsgUnpauseSendingAndReceivingMessages;
+                fromProtoMsg(message: _31.MsgUnpauseSendingAndReceivingMessagesProtoMsg): _31.MsgUnpauseSendingAndReceivingMessages;
+                toProto(message: _31.MsgUnpauseSendingAndReceivingMessages): Uint8Array;
+                toProtoMsg(message: _31.MsgUnpauseSendingAndReceivingMessages): _31.MsgUnpauseSendingAndReceivingMessagesProtoMsg;
+            };
+            MsgUnpauseSendingAndReceivingMessagesResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUnpauseSendingAndReceivingMessagesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUnpauseSendingAndReceivingMessagesResponse;
+                fromJSON(_: any): _31.MsgUnpauseSendingAndReceivingMessagesResponse;
+                toJSON(_: _31.MsgUnpauseSendingAndReceivingMessagesResponse): import("../json-safe.ts").JsonSafe<_31.MsgUnpauseSendingAndReceivingMessagesResponse>;
+                fromPartial(_: Partial<_31.MsgUnpauseSendingAndReceivingMessagesResponse>): _31.MsgUnpauseSendingAndReceivingMessagesResponse;
+                fromProtoMsg(message: _31.MsgUnpauseSendingAndReceivingMessagesResponseProtoMsg): _31.MsgUnpauseSendingAndReceivingMessagesResponse;
+                toProto(message: _31.MsgUnpauseSendingAndReceivingMessagesResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUnpauseSendingAndReceivingMessagesResponse): _31.MsgUnpauseSendingAndReceivingMessagesResponseProtoMsg;
+            };
+            MsgUpdateMaxMessageBodySize: {
+                typeUrl: string;
+                encode(message: _31.MsgUpdateMaxMessageBodySize, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateMaxMessageBodySize;
+                fromJSON(object: any): _31.MsgUpdateMaxMessageBodySize;
+                toJSON(message: _31.MsgUpdateMaxMessageBodySize): import("../json-safe.ts").JsonSafe<_31.MsgUpdateMaxMessageBodySize>;
+                fromPartial(object: Partial<_31.MsgUpdateMaxMessageBodySize>): _31.MsgUpdateMaxMessageBodySize;
+                fromProtoMsg(message: _31.MsgUpdateMaxMessageBodySizeProtoMsg): _31.MsgUpdateMaxMessageBodySize;
+                toProto(message: _31.MsgUpdateMaxMessageBodySize): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateMaxMessageBodySize): _31.MsgUpdateMaxMessageBodySizeProtoMsg;
+            };
+            MsgUpdateMaxMessageBodySizeResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUpdateMaxMessageBodySizeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateMaxMessageBodySizeResponse;
+                fromJSON(_: any): _31.MsgUpdateMaxMessageBodySizeResponse;
+                toJSON(_: _31.MsgUpdateMaxMessageBodySizeResponse): import("../json-safe.ts").JsonSafe<_31.MsgUpdateMaxMessageBodySizeResponse>;
+                fromPartial(_: Partial<_31.MsgUpdateMaxMessageBodySizeResponse>): _31.MsgUpdateMaxMessageBodySizeResponse;
+                fromProtoMsg(message: _31.MsgUpdateMaxMessageBodySizeResponseProtoMsg): _31.MsgUpdateMaxMessageBodySizeResponse;
+                toProto(message: _31.MsgUpdateMaxMessageBodySizeResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateMaxMessageBodySizeResponse): _31.MsgUpdateMaxMessageBodySizeResponseProtoMsg;
+            };
+            MsgSetMaxBurnAmountPerMessage: {
+                typeUrl: string;
+                encode(message: _31.MsgSetMaxBurnAmountPerMessage, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgSetMaxBurnAmountPerMessage;
+                fromJSON(object: any): _31.MsgSetMaxBurnAmountPerMessage;
+                toJSON(message: _31.MsgSetMaxBurnAmountPerMessage): import("../json-safe.ts").JsonSafe<_31.MsgSetMaxBurnAmountPerMessage>;
+                fromPartial(object: Partial<_31.MsgSetMaxBurnAmountPerMessage>): _31.MsgSetMaxBurnAmountPerMessage;
+                fromProtoMsg(message: _31.MsgSetMaxBurnAmountPerMessageProtoMsg): _31.MsgSetMaxBurnAmountPerMessage;
+                toProto(message: _31.MsgSetMaxBurnAmountPerMessage): Uint8Array;
+                toProtoMsg(message: _31.MsgSetMaxBurnAmountPerMessage): _31.MsgSetMaxBurnAmountPerMessageProtoMsg;
+            };
+            MsgSetMaxBurnAmountPerMessageResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgSetMaxBurnAmountPerMessageResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgSetMaxBurnAmountPerMessageResponse;
+                fromJSON(_: any): _31.MsgSetMaxBurnAmountPerMessageResponse;
+                toJSON(_: _31.MsgSetMaxBurnAmountPerMessageResponse): import("../json-safe.ts").JsonSafe<_31.MsgSetMaxBurnAmountPerMessageResponse>;
+                fromPartial(_: Partial<_31.MsgSetMaxBurnAmountPerMessageResponse>): _31.MsgSetMaxBurnAmountPerMessageResponse;
+                fromProtoMsg(message: _31.MsgSetMaxBurnAmountPerMessageResponseProtoMsg): _31.MsgSetMaxBurnAmountPerMessageResponse;
+                toProto(message: _31.MsgSetMaxBurnAmountPerMessageResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgSetMaxBurnAmountPerMessageResponse): _31.MsgSetMaxBurnAmountPerMessageResponseProtoMsg;
+            };
+            MsgDepositForBurn: {
+                typeUrl: string;
+                encode(message: _31.MsgDepositForBurn, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgDepositForBurn;
+                fromJSON(object: any): _31.MsgDepositForBurn;
+                toJSON(message: _31.MsgDepositForBurn): import("../json-safe.ts").JsonSafe<_31.MsgDepositForBurn>;
+                fromPartial(object: Partial<_31.MsgDepositForBurn>): _31.MsgDepositForBurn;
+                fromProtoMsg(message: _31.MsgDepositForBurnProtoMsg): _31.MsgDepositForBurn;
+                toProto(message: _31.MsgDepositForBurn): Uint8Array;
+                toProtoMsg(message: _31.MsgDepositForBurn): _31.MsgDepositForBurnProtoMsg;
+            };
+            MsgDepositForBurnResponse: {
+                typeUrl: string;
+                encode(message: _31.MsgDepositForBurnResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgDepositForBurnResponse;
+                fromJSON(object: any): _31.MsgDepositForBurnResponse;
+                toJSON(message: _31.MsgDepositForBurnResponse): import("../json-safe.ts").JsonSafe<_31.MsgDepositForBurnResponse>;
+                fromPartial(object: Partial<_31.MsgDepositForBurnResponse>): _31.MsgDepositForBurnResponse;
+                fromProtoMsg(message: _31.MsgDepositForBurnResponseProtoMsg): _31.MsgDepositForBurnResponse;
+                toProto(message: _31.MsgDepositForBurnResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgDepositForBurnResponse): _31.MsgDepositForBurnResponseProtoMsg;
+            };
+            MsgDepositForBurnWithCaller: {
+                typeUrl: string;
+                encode(message: _31.MsgDepositForBurnWithCaller, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgDepositForBurnWithCaller;
+                fromJSON(object: any): _31.MsgDepositForBurnWithCaller;
+                toJSON(message: _31.MsgDepositForBurnWithCaller): import("../json-safe.ts").JsonSafe<_31.MsgDepositForBurnWithCaller>;
+                fromPartial(object: Partial<_31.MsgDepositForBurnWithCaller>): _31.MsgDepositForBurnWithCaller;
+                fromProtoMsg(message: _31.MsgDepositForBurnWithCallerProtoMsg): _31.MsgDepositForBurnWithCaller;
+                toProto(message: _31.MsgDepositForBurnWithCaller): Uint8Array;
+                toProtoMsg(message: _31.MsgDepositForBurnWithCaller): _31.MsgDepositForBurnWithCallerProtoMsg;
+            };
+            MsgDepositForBurnWithCallerResponse: {
+                typeUrl: string;
+                encode(message: _31.MsgDepositForBurnWithCallerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgDepositForBurnWithCallerResponse;
+                fromJSON(object: any): _31.MsgDepositForBurnWithCallerResponse;
+                toJSON(message: _31.MsgDepositForBurnWithCallerResponse): import("../json-safe.ts").JsonSafe<_31.MsgDepositForBurnWithCallerResponse>;
+                fromPartial(object: Partial<_31.MsgDepositForBurnWithCallerResponse>): _31.MsgDepositForBurnWithCallerResponse;
+                fromProtoMsg(message: _31.MsgDepositForBurnWithCallerResponseProtoMsg): _31.MsgDepositForBurnWithCallerResponse;
+                toProto(message: _31.MsgDepositForBurnWithCallerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgDepositForBurnWithCallerResponse): _31.MsgDepositForBurnWithCallerResponseProtoMsg;
+            };
+            MsgReplaceDepositForBurn: {
+                typeUrl: string;
+                encode(message: _31.MsgReplaceDepositForBurn, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgReplaceDepositForBurn;
+                fromJSON(object: any): _31.MsgReplaceDepositForBurn;
+                toJSON(message: _31.MsgReplaceDepositForBurn): import("../json-safe.ts").JsonSafe<_31.MsgReplaceDepositForBurn>;
+                fromPartial(object: Partial<_31.MsgReplaceDepositForBurn>): _31.MsgReplaceDepositForBurn;
+                fromProtoMsg(message: _31.MsgReplaceDepositForBurnProtoMsg): _31.MsgReplaceDepositForBurn;
+                toProto(message: _31.MsgReplaceDepositForBurn): Uint8Array;
+                toProtoMsg(message: _31.MsgReplaceDepositForBurn): _31.MsgReplaceDepositForBurnProtoMsg;
+            };
+            MsgReplaceDepositForBurnResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgReplaceDepositForBurnResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgReplaceDepositForBurnResponse;
+                fromJSON(_: any): _31.MsgReplaceDepositForBurnResponse;
+                toJSON(_: _31.MsgReplaceDepositForBurnResponse): import("../json-safe.ts").JsonSafe<_31.MsgReplaceDepositForBurnResponse>;
+                fromPartial(_: Partial<_31.MsgReplaceDepositForBurnResponse>): _31.MsgReplaceDepositForBurnResponse;
+                fromProtoMsg(message: _31.MsgReplaceDepositForBurnResponseProtoMsg): _31.MsgReplaceDepositForBurnResponse;
+                toProto(message: _31.MsgReplaceDepositForBurnResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgReplaceDepositForBurnResponse): _31.MsgReplaceDepositForBurnResponseProtoMsg;
+            };
+            MsgReceiveMessage: {
+                typeUrl: string;
+                encode(message: _31.MsgReceiveMessage, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgReceiveMessage;
+                fromJSON(object: any): _31.MsgReceiveMessage;
+                toJSON(message: _31.MsgReceiveMessage): import("../json-safe.ts").JsonSafe<_31.MsgReceiveMessage>;
+                fromPartial(object: Partial<_31.MsgReceiveMessage>): _31.MsgReceiveMessage;
+                fromProtoMsg(message: _31.MsgReceiveMessageProtoMsg): _31.MsgReceiveMessage;
+                toProto(message: _31.MsgReceiveMessage): Uint8Array;
+                toProtoMsg(message: _31.MsgReceiveMessage): _31.MsgReceiveMessageProtoMsg;
+            };
+            MsgReceiveMessageResponse: {
+                typeUrl: string;
+                encode(message: _31.MsgReceiveMessageResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgReceiveMessageResponse;
+                fromJSON(object: any): _31.MsgReceiveMessageResponse;
+                toJSON(message: _31.MsgReceiveMessageResponse): import("../json-safe.ts").JsonSafe<_31.MsgReceiveMessageResponse>;
+                fromPartial(object: Partial<_31.MsgReceiveMessageResponse>): _31.MsgReceiveMessageResponse;
+                fromProtoMsg(message: _31.MsgReceiveMessageResponseProtoMsg): _31.MsgReceiveMessageResponse;
+                toProto(message: _31.MsgReceiveMessageResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgReceiveMessageResponse): _31.MsgReceiveMessageResponseProtoMsg;
+            };
+            MsgSendMessage: {
+                typeUrl: string;
+                encode(message: _31.MsgSendMessage, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgSendMessage;
+                fromJSON(object: any): _31.MsgSendMessage;
+                toJSON(message: _31.MsgSendMessage): import("../json-safe.ts").JsonSafe<_31.MsgSendMessage>;
+                fromPartial(object: Partial<_31.MsgSendMessage>): _31.MsgSendMessage;
+                fromProtoMsg(message: _31.MsgSendMessageProtoMsg): _31.MsgSendMessage;
+                toProto(message: _31.MsgSendMessage): Uint8Array;
+                toProtoMsg(message: _31.MsgSendMessage): _31.MsgSendMessageProtoMsg;
+            };
+            MsgSendMessageResponse: {
+                typeUrl: string;
+                encode(message: _31.MsgSendMessageResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgSendMessageResponse;
+                fromJSON(object: any): _31.MsgSendMessageResponse;
+                toJSON(message: _31.MsgSendMessageResponse): import("../json-safe.ts").JsonSafe<_31.MsgSendMessageResponse>;
+                fromPartial(object: Partial<_31.MsgSendMessageResponse>): _31.MsgSendMessageResponse;
+                fromProtoMsg(message: _31.MsgSendMessageResponseProtoMsg): _31.MsgSendMessageResponse;
+                toProto(message: _31.MsgSendMessageResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgSendMessageResponse): _31.MsgSendMessageResponseProtoMsg;
+            };
+            MsgSendMessageWithCaller: {
+                typeUrl: string;
+                encode(message: _31.MsgSendMessageWithCaller, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgSendMessageWithCaller;
+                fromJSON(object: any): _31.MsgSendMessageWithCaller;
+                toJSON(message: _31.MsgSendMessageWithCaller): import("../json-safe.ts").JsonSafe<_31.MsgSendMessageWithCaller>;
+                fromPartial(object: Partial<_31.MsgSendMessageWithCaller>): _31.MsgSendMessageWithCaller;
+                fromProtoMsg(message: _31.MsgSendMessageWithCallerProtoMsg): _31.MsgSendMessageWithCaller;
+                toProto(message: _31.MsgSendMessageWithCaller): Uint8Array;
+                toProtoMsg(message: _31.MsgSendMessageWithCaller): _31.MsgSendMessageWithCallerProtoMsg;
+            };
+            MsgSendMessageWithCallerResponse: {
+                typeUrl: string;
+                encode(message: _31.MsgSendMessageWithCallerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgSendMessageWithCallerResponse;
+                fromJSON(object: any): _31.MsgSendMessageWithCallerResponse;
+                toJSON(message: _31.MsgSendMessageWithCallerResponse): import("../json-safe.ts").JsonSafe<_31.MsgSendMessageWithCallerResponse>;
+                fromPartial(object: Partial<_31.MsgSendMessageWithCallerResponse>): _31.MsgSendMessageWithCallerResponse;
+                fromProtoMsg(message: _31.MsgSendMessageWithCallerResponseProtoMsg): _31.MsgSendMessageWithCallerResponse;
+                toProto(message: _31.MsgSendMessageWithCallerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgSendMessageWithCallerResponse): _31.MsgSendMessageWithCallerResponseProtoMsg;
+            };
+            MsgReplaceMessage: {
+                typeUrl: string;
+                encode(message: _31.MsgReplaceMessage, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgReplaceMessage;
+                fromJSON(object: any): _31.MsgReplaceMessage;
+                toJSON(message: _31.MsgReplaceMessage): import("../json-safe.ts").JsonSafe<_31.MsgReplaceMessage>;
+                fromPartial(object: Partial<_31.MsgReplaceMessage>): _31.MsgReplaceMessage;
+                fromProtoMsg(message: _31.MsgReplaceMessageProtoMsg): _31.MsgReplaceMessage;
+                toProto(message: _31.MsgReplaceMessage): Uint8Array;
+                toProtoMsg(message: _31.MsgReplaceMessage): _31.MsgReplaceMessageProtoMsg;
+            };
+            MsgReplaceMessageResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgReplaceMessageResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgReplaceMessageResponse;
+                fromJSON(_: any): _31.MsgReplaceMessageResponse;
+                toJSON(_: _31.MsgReplaceMessageResponse): import("../json-safe.ts").JsonSafe<_31.MsgReplaceMessageResponse>;
+                fromPartial(_: Partial<_31.MsgReplaceMessageResponse>): _31.MsgReplaceMessageResponse;
+                fromProtoMsg(message: _31.MsgReplaceMessageResponseProtoMsg): _31.MsgReplaceMessageResponse;
+                toProto(message: _31.MsgReplaceMessageResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgReplaceMessageResponse): _31.MsgReplaceMessageResponseProtoMsg;
+            };
+            MsgUpdateSignatureThreshold: {
+                typeUrl: string;
+                encode(message: _31.MsgUpdateSignatureThreshold, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateSignatureThreshold;
+                fromJSON(object: any): _31.MsgUpdateSignatureThreshold;
+                toJSON(message: _31.MsgUpdateSignatureThreshold): import("../json-safe.ts").JsonSafe<_31.MsgUpdateSignatureThreshold>;
+                fromPartial(object: Partial<_31.MsgUpdateSignatureThreshold>): _31.MsgUpdateSignatureThreshold;
+                fromProtoMsg(message: _31.MsgUpdateSignatureThresholdProtoMsg): _31.MsgUpdateSignatureThreshold;
+                toProto(message: _31.MsgUpdateSignatureThreshold): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateSignatureThreshold): _31.MsgUpdateSignatureThresholdProtoMsg;
+            };
+            MsgUpdateSignatureThresholdResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUpdateSignatureThresholdResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUpdateSignatureThresholdResponse;
+                fromJSON(_: any): _31.MsgUpdateSignatureThresholdResponse;
+                toJSON(_: _31.MsgUpdateSignatureThresholdResponse): import("../json-safe.ts").JsonSafe<_31.MsgUpdateSignatureThresholdResponse>;
+                fromPartial(_: Partial<_31.MsgUpdateSignatureThresholdResponse>): _31.MsgUpdateSignatureThresholdResponse;
+                fromProtoMsg(message: _31.MsgUpdateSignatureThresholdResponseProtoMsg): _31.MsgUpdateSignatureThresholdResponse;
+                toProto(message: _31.MsgUpdateSignatureThresholdResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUpdateSignatureThresholdResponse): _31.MsgUpdateSignatureThresholdResponseProtoMsg;
+            };
+            MsgLinkTokenPair: {
+                typeUrl: string;
+                encode(message: _31.MsgLinkTokenPair, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgLinkTokenPair;
+                fromJSON(object: any): _31.MsgLinkTokenPair;
+                toJSON(message: _31.MsgLinkTokenPair): import("../json-safe.ts").JsonSafe<_31.MsgLinkTokenPair>;
+                fromPartial(object: Partial<_31.MsgLinkTokenPair>): _31.MsgLinkTokenPair;
+                fromProtoMsg(message: _31.MsgLinkTokenPairProtoMsg): _31.MsgLinkTokenPair;
+                toProto(message: _31.MsgLinkTokenPair): Uint8Array;
+                toProtoMsg(message: _31.MsgLinkTokenPair): _31.MsgLinkTokenPairProtoMsg;
+            };
+            MsgLinkTokenPairResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgLinkTokenPairResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgLinkTokenPairResponse;
+                fromJSON(_: any): _31.MsgLinkTokenPairResponse;
+                toJSON(_: _31.MsgLinkTokenPairResponse): import("../json-safe.ts").JsonSafe<_31.MsgLinkTokenPairResponse>;
+                fromPartial(_: Partial<_31.MsgLinkTokenPairResponse>): _31.MsgLinkTokenPairResponse;
+                fromProtoMsg(message: _31.MsgLinkTokenPairResponseProtoMsg): _31.MsgLinkTokenPairResponse;
+                toProto(message: _31.MsgLinkTokenPairResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgLinkTokenPairResponse): _31.MsgLinkTokenPairResponseProtoMsg;
+            };
+            MsgUnlinkTokenPair: {
+                typeUrl: string;
+                encode(message: _31.MsgUnlinkTokenPair, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUnlinkTokenPair;
+                fromJSON(object: any): _31.MsgUnlinkTokenPair;
+                toJSON(message: _31.MsgUnlinkTokenPair): import("../json-safe.ts").JsonSafe<_31.MsgUnlinkTokenPair>;
+                fromPartial(object: Partial<_31.MsgUnlinkTokenPair>): _31.MsgUnlinkTokenPair;
+                fromProtoMsg(message: _31.MsgUnlinkTokenPairProtoMsg): _31.MsgUnlinkTokenPair;
+                toProto(message: _31.MsgUnlinkTokenPair): Uint8Array;
+                toProtoMsg(message: _31.MsgUnlinkTokenPair): _31.MsgUnlinkTokenPairProtoMsg;
+            };
+            MsgUnlinkTokenPairResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgUnlinkTokenPairResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgUnlinkTokenPairResponse;
+                fromJSON(_: any): _31.MsgUnlinkTokenPairResponse;
+                toJSON(_: _31.MsgUnlinkTokenPairResponse): import("../json-safe.ts").JsonSafe<_31.MsgUnlinkTokenPairResponse>;
+                fromPartial(_: Partial<_31.MsgUnlinkTokenPairResponse>): _31.MsgUnlinkTokenPairResponse;
+                fromProtoMsg(message: _31.MsgUnlinkTokenPairResponseProtoMsg): _31.MsgUnlinkTokenPairResponse;
+                toProto(message: _31.MsgUnlinkTokenPairResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgUnlinkTokenPairResponse): _31.MsgUnlinkTokenPairResponseProtoMsg;
+            };
+            MsgAddRemoteTokenMessenger: {
+                typeUrl: string;
+                encode(message: _31.MsgAddRemoteTokenMessenger, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgAddRemoteTokenMessenger;
+                fromJSON(object: any): _31.MsgAddRemoteTokenMessenger;
+                toJSON(message: _31.MsgAddRemoteTokenMessenger): import("../json-safe.ts").JsonSafe<_31.MsgAddRemoteTokenMessenger>;
+                fromPartial(object: Partial<_31.MsgAddRemoteTokenMessenger>): _31.MsgAddRemoteTokenMessenger;
+                fromProtoMsg(message: _31.MsgAddRemoteTokenMessengerProtoMsg): _31.MsgAddRemoteTokenMessenger;
+                toProto(message: _31.MsgAddRemoteTokenMessenger): Uint8Array;
+                toProtoMsg(message: _31.MsgAddRemoteTokenMessenger): _31.MsgAddRemoteTokenMessengerProtoMsg;
+            };
+            MsgAddRemoteTokenMessengerResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgAddRemoteTokenMessengerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgAddRemoteTokenMessengerResponse;
+                fromJSON(_: any): _31.MsgAddRemoteTokenMessengerResponse;
+                toJSON(_: _31.MsgAddRemoteTokenMessengerResponse): import("../json-safe.ts").JsonSafe<_31.MsgAddRemoteTokenMessengerResponse>;
+                fromPartial(_: Partial<_31.MsgAddRemoteTokenMessengerResponse>): _31.MsgAddRemoteTokenMessengerResponse;
+                fromProtoMsg(message: _31.MsgAddRemoteTokenMessengerResponseProtoMsg): _31.MsgAddRemoteTokenMessengerResponse;
+                toProto(message: _31.MsgAddRemoteTokenMessengerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgAddRemoteTokenMessengerResponse): _31.MsgAddRemoteTokenMessengerResponseProtoMsg;
+            };
+            MsgRemoveRemoteTokenMessenger: {
+                typeUrl: string;
+                encode(message: _31.MsgRemoveRemoteTokenMessenger, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgRemoveRemoteTokenMessenger;
+                fromJSON(object: any): _31.MsgRemoveRemoteTokenMessenger;
+                toJSON(message: _31.MsgRemoveRemoteTokenMessenger): import("../json-safe.ts").JsonSafe<_31.MsgRemoveRemoteTokenMessenger>;
+                fromPartial(object: Partial<_31.MsgRemoveRemoteTokenMessenger>): _31.MsgRemoveRemoteTokenMessenger;
+                fromProtoMsg(message: _31.MsgRemoveRemoteTokenMessengerProtoMsg): _31.MsgRemoveRemoteTokenMessenger;
+                toProto(message: _31.MsgRemoveRemoteTokenMessenger): Uint8Array;
+                toProtoMsg(message: _31.MsgRemoveRemoteTokenMessenger): _31.MsgRemoveRemoteTokenMessengerProtoMsg;
+            };
+            MsgRemoveRemoteTokenMessengerResponse: {
+                typeUrl: string;
+                encode(_: _31.MsgRemoveRemoteTokenMessengerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _31.MsgRemoveRemoteTokenMessengerResponse;
+                fromJSON(_: any): _31.MsgRemoveRemoteTokenMessengerResponse;
+                toJSON(_: _31.MsgRemoveRemoteTokenMessengerResponse): import("../json-safe.ts").JsonSafe<_31.MsgRemoveRemoteTokenMessengerResponse>;
+                fromPartial(_: Partial<_31.MsgRemoveRemoteTokenMessengerResponse>): _31.MsgRemoveRemoteTokenMessengerResponse;
+                fromProtoMsg(message: _31.MsgRemoveRemoteTokenMessengerResponseProtoMsg): _31.MsgRemoveRemoteTokenMessengerResponse;
+                toProto(message: _31.MsgRemoveRemoteTokenMessengerResponse): Uint8Array;
+                toProtoMsg(message: _31.MsgRemoveRemoteTokenMessengerResponse): _31.MsgRemoveRemoteTokenMessengerResponseProtoMsg;
+            };
+            TokenPair: {
+                typeUrl: string;
+                encode(message: _30.TokenPair, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _30.TokenPair;
+                fromJSON(object: any): _30.TokenPair;
+                toJSON(message: _30.TokenPair): import("../json-safe.ts").JsonSafe<_30.TokenPair>;
+                fromPartial(object: Partial<_30.TokenPair>): _30.TokenPair;
+                fromProtoMsg(message: _30.TokenPairProtoMsg): _30.TokenPair;
+                toProto(message: _30.TokenPair): Uint8Array;
+                toProtoMsg(message: _30.TokenPair): _30.TokenPairProtoMsg;
+            };
+            SignatureThreshold: {
+                typeUrl: string;
+                encode(message: _29.SignatureThreshold, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _29.SignatureThreshold;
+                fromJSON(object: any): _29.SignatureThreshold;
+                toJSON(message: _29.SignatureThreshold): import("../json-safe.ts").JsonSafe<_29.SignatureThreshold>;
+                fromPartial(object: Partial<_29.SignatureThreshold>): _29.SignatureThreshold;
+                fromProtoMsg(message: _29.SignatureThresholdProtoMsg): _29.SignatureThreshold;
+                toProto(message: _29.SignatureThreshold): Uint8Array;
+                toProtoMsg(message: _29.SignatureThreshold): _29.SignatureThresholdProtoMsg;
+            };
+            SendingAndReceivingMessagesPaused: {
+                typeUrl: string;
+                encode(message: _28.SendingAndReceivingMessagesPaused, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _28.SendingAndReceivingMessagesPaused;
+                fromJSON(object: any): _28.SendingAndReceivingMessagesPaused;
+                toJSON(message: _28.SendingAndReceivingMessagesPaused): import("../json-safe.ts").JsonSafe<_28.SendingAndReceivingMessagesPaused>;
+                fromPartial(object: Partial<_28.SendingAndReceivingMessagesPaused>): _28.SendingAndReceivingMessagesPaused;
+                fromProtoMsg(message: _28.SendingAndReceivingMessagesPausedProtoMsg): _28.SendingAndReceivingMessagesPaused;
+                toProto(message: _28.SendingAndReceivingMessagesPaused): Uint8Array;
+                toProtoMsg(message: _28.SendingAndReceivingMessagesPaused): _28.SendingAndReceivingMessagesPausedProtoMsg;
+            };
+            RemoteTokenMessenger: {
+                typeUrl: string;
+                encode(message: _27.RemoteTokenMessenger, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _27.RemoteTokenMessenger;
+                fromJSON(object: any): _27.RemoteTokenMessenger;
+                toJSON(message: _27.RemoteTokenMessenger): import("../json-safe.ts").JsonSafe<_27.RemoteTokenMessenger>;
+                fromPartial(object: Partial<_27.RemoteTokenMessenger>): _27.RemoteTokenMessenger;
+                fromProtoMsg(message: _27.RemoteTokenMessengerProtoMsg): _27.RemoteTokenMessenger;
+                toProto(message: _27.RemoteTokenMessenger): Uint8Array;
+                toProtoMsg(message: _27.RemoteTokenMessenger): _27.RemoteTokenMessengerProtoMsg;
+            };
+            QueryRolesRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryRolesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryRolesRequest;
+                fromJSON(_: any): _26.QueryRolesRequest;
+                toJSON(_: _26.QueryRolesRequest): import("../json-safe.ts").JsonSafe<_26.QueryRolesRequest>;
+                fromPartial(_: Partial<_26.QueryRolesRequest>): _26.QueryRolesRequest;
+                fromProtoMsg(message: _26.QueryRolesRequestProtoMsg): _26.QueryRolesRequest;
+                toProto(message: _26.QueryRolesRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryRolesRequest): _26.QueryRolesRequestProtoMsg;
+            };
+            QueryRolesResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryRolesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryRolesResponse;
+                fromJSON(object: any): _26.QueryRolesResponse;
+                toJSON(message: _26.QueryRolesResponse): import("../json-safe.ts").JsonSafe<_26.QueryRolesResponse>;
+                fromPartial(object: Partial<_26.QueryRolesResponse>): _26.QueryRolesResponse;
+                fromProtoMsg(message: _26.QueryRolesResponseProtoMsg): _26.QueryRolesResponse;
+                toProto(message: _26.QueryRolesResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryRolesResponse): _26.QueryRolesResponseProtoMsg;
+            };
+            QueryGetAttesterRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryGetAttesterRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetAttesterRequest;
+                fromJSON(object: any): _26.QueryGetAttesterRequest;
+                toJSON(message: _26.QueryGetAttesterRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetAttesterRequest>;
+                fromPartial(object: Partial<_26.QueryGetAttesterRequest>): _26.QueryGetAttesterRequest;
+                fromProtoMsg(message: _26.QueryGetAttesterRequestProtoMsg): _26.QueryGetAttesterRequest;
+                toProto(message: _26.QueryGetAttesterRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetAttesterRequest): _26.QueryGetAttesterRequestProtoMsg;
+            };
+            QueryGetAttesterResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetAttesterResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetAttesterResponse;
+                fromJSON(object: any): _26.QueryGetAttesterResponse;
+                toJSON(message: _26.QueryGetAttesterResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetAttesterResponse>;
+                fromPartial(object: Partial<_26.QueryGetAttesterResponse>): _26.QueryGetAttesterResponse;
+                fromProtoMsg(message: _26.QueryGetAttesterResponseProtoMsg): _26.QueryGetAttesterResponse;
+                toProto(message: _26.QueryGetAttesterResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetAttesterResponse): _26.QueryGetAttesterResponseProtoMsg;
+            };
+            QueryAllAttestersRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryAllAttestersRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllAttestersRequest;
+                fromJSON(object: any): _26.QueryAllAttestersRequest;
+                toJSON(message: _26.QueryAllAttestersRequest): import("../json-safe.ts").JsonSafe<_26.QueryAllAttestersRequest>;
+                fromPartial(object: Partial<_26.QueryAllAttestersRequest>): _26.QueryAllAttestersRequest;
+                fromProtoMsg(message: _26.QueryAllAttestersRequestProtoMsg): _26.QueryAllAttestersRequest;
+                toProto(message: _26.QueryAllAttestersRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryAllAttestersRequest): _26.QueryAllAttestersRequestProtoMsg;
+            };
+            QueryAllAttestersResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryAllAttestersResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllAttestersResponse;
+                fromJSON(object: any): _26.QueryAllAttestersResponse;
+                toJSON(message: _26.QueryAllAttestersResponse): import("../json-safe.ts").JsonSafe<_26.QueryAllAttestersResponse>;
+                fromPartial(object: Partial<_26.QueryAllAttestersResponse>): _26.QueryAllAttestersResponse;
+                fromProtoMsg(message: _26.QueryAllAttestersResponseProtoMsg): _26.QueryAllAttestersResponse;
+                toProto(message: _26.QueryAllAttestersResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryAllAttestersResponse): _26.QueryAllAttestersResponseProtoMsg;
+            };
+            QueryGetPerMessageBurnLimitRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryGetPerMessageBurnLimitRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetPerMessageBurnLimitRequest;
+                fromJSON(object: any): _26.QueryGetPerMessageBurnLimitRequest;
+                toJSON(message: _26.QueryGetPerMessageBurnLimitRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetPerMessageBurnLimitRequest>;
+                fromPartial(object: Partial<_26.QueryGetPerMessageBurnLimitRequest>): _26.QueryGetPerMessageBurnLimitRequest;
+                fromProtoMsg(message: _26.QueryGetPerMessageBurnLimitRequestProtoMsg): _26.QueryGetPerMessageBurnLimitRequest;
+                toProto(message: _26.QueryGetPerMessageBurnLimitRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetPerMessageBurnLimitRequest): _26.QueryGetPerMessageBurnLimitRequestProtoMsg;
+            };
+            QueryGetPerMessageBurnLimitResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetPerMessageBurnLimitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetPerMessageBurnLimitResponse;
+                fromJSON(object: any): _26.QueryGetPerMessageBurnLimitResponse;
+                toJSON(message: _26.QueryGetPerMessageBurnLimitResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetPerMessageBurnLimitResponse>;
+                fromPartial(object: Partial<_26.QueryGetPerMessageBurnLimitResponse>): _26.QueryGetPerMessageBurnLimitResponse;
+                fromProtoMsg(message: _26.QueryGetPerMessageBurnLimitResponseProtoMsg): _26.QueryGetPerMessageBurnLimitResponse;
+                toProto(message: _26.QueryGetPerMessageBurnLimitResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetPerMessageBurnLimitResponse): _26.QueryGetPerMessageBurnLimitResponseProtoMsg;
+            };
+            QueryAllPerMessageBurnLimitsRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryAllPerMessageBurnLimitsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllPerMessageBurnLimitsRequest;
+                fromJSON(object: any): _26.QueryAllPerMessageBurnLimitsRequest;
+                toJSON(message: _26.QueryAllPerMessageBurnLimitsRequest): import("../json-safe.ts").JsonSafe<_26.QueryAllPerMessageBurnLimitsRequest>;
+                fromPartial(object: Partial<_26.QueryAllPerMessageBurnLimitsRequest>): _26.QueryAllPerMessageBurnLimitsRequest;
+                fromProtoMsg(message: _26.QueryAllPerMessageBurnLimitsRequestProtoMsg): _26.QueryAllPerMessageBurnLimitsRequest;
+                toProto(message: _26.QueryAllPerMessageBurnLimitsRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryAllPerMessageBurnLimitsRequest): _26.QueryAllPerMessageBurnLimitsRequestProtoMsg;
+            };
+            QueryAllPerMessageBurnLimitsResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryAllPerMessageBurnLimitsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllPerMessageBurnLimitsResponse;
+                fromJSON(object: any): _26.QueryAllPerMessageBurnLimitsResponse;
+                toJSON(message: _26.QueryAllPerMessageBurnLimitsResponse): import("../json-safe.ts").JsonSafe<_26.QueryAllPerMessageBurnLimitsResponse>;
+                fromPartial(object: Partial<_26.QueryAllPerMessageBurnLimitsResponse>): _26.QueryAllPerMessageBurnLimitsResponse;
+                fromProtoMsg(message: _26.QueryAllPerMessageBurnLimitsResponseProtoMsg): _26.QueryAllPerMessageBurnLimitsResponse;
+                toProto(message: _26.QueryAllPerMessageBurnLimitsResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryAllPerMessageBurnLimitsResponse): _26.QueryAllPerMessageBurnLimitsResponseProtoMsg;
+            };
+            QueryGetBurningAndMintingPausedRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryGetBurningAndMintingPausedRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetBurningAndMintingPausedRequest;
+                fromJSON(_: any): _26.QueryGetBurningAndMintingPausedRequest;
+                toJSON(_: _26.QueryGetBurningAndMintingPausedRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetBurningAndMintingPausedRequest>;
+                fromPartial(_: Partial<_26.QueryGetBurningAndMintingPausedRequest>): _26.QueryGetBurningAndMintingPausedRequest;
+                fromProtoMsg(message: _26.QueryGetBurningAndMintingPausedRequestProtoMsg): _26.QueryGetBurningAndMintingPausedRequest;
+                toProto(message: _26.QueryGetBurningAndMintingPausedRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetBurningAndMintingPausedRequest): _26.QueryGetBurningAndMintingPausedRequestProtoMsg;
+            };
+            QueryGetBurningAndMintingPausedResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetBurningAndMintingPausedResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetBurningAndMintingPausedResponse;
+                fromJSON(object: any): _26.QueryGetBurningAndMintingPausedResponse;
+                toJSON(message: _26.QueryGetBurningAndMintingPausedResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetBurningAndMintingPausedResponse>;
+                fromPartial(object: Partial<_26.QueryGetBurningAndMintingPausedResponse>): _26.QueryGetBurningAndMintingPausedResponse;
+                fromProtoMsg(message: _26.QueryGetBurningAndMintingPausedResponseProtoMsg): _26.QueryGetBurningAndMintingPausedResponse;
+                toProto(message: _26.QueryGetBurningAndMintingPausedResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetBurningAndMintingPausedResponse): _26.QueryGetBurningAndMintingPausedResponseProtoMsg;
+            };
+            QueryGetSendingAndReceivingMessagesPausedRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryGetSendingAndReceivingMessagesPausedRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetSendingAndReceivingMessagesPausedRequest;
+                fromJSON(_: any): _26.QueryGetSendingAndReceivingMessagesPausedRequest;
+                toJSON(_: _26.QueryGetSendingAndReceivingMessagesPausedRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetSendingAndReceivingMessagesPausedRequest>;
+                fromPartial(_: Partial<_26.QueryGetSendingAndReceivingMessagesPausedRequest>): _26.QueryGetSendingAndReceivingMessagesPausedRequest;
+                fromProtoMsg(message: _26.QueryGetSendingAndReceivingMessagesPausedRequestProtoMsg): _26.QueryGetSendingAndReceivingMessagesPausedRequest;
+                toProto(message: _26.QueryGetSendingAndReceivingMessagesPausedRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetSendingAndReceivingMessagesPausedRequest): _26.QueryGetSendingAndReceivingMessagesPausedRequestProtoMsg;
+            };
+            QueryGetSendingAndReceivingMessagesPausedResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetSendingAndReceivingMessagesPausedResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetSendingAndReceivingMessagesPausedResponse;
+                fromJSON(object: any): _26.QueryGetSendingAndReceivingMessagesPausedResponse;
+                toJSON(message: _26.QueryGetSendingAndReceivingMessagesPausedResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetSendingAndReceivingMessagesPausedResponse>;
+                fromPartial(object: Partial<_26.QueryGetSendingAndReceivingMessagesPausedResponse>): _26.QueryGetSendingAndReceivingMessagesPausedResponse;
+                fromProtoMsg(message: _26.QueryGetSendingAndReceivingMessagesPausedResponseProtoMsg): _26.QueryGetSendingAndReceivingMessagesPausedResponse;
+                toProto(message: _26.QueryGetSendingAndReceivingMessagesPausedResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetSendingAndReceivingMessagesPausedResponse): _26.QueryGetSendingAndReceivingMessagesPausedResponseProtoMsg;
+            };
+            QueryGetMaxMessageBodySizeRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryGetMaxMessageBodySizeRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetMaxMessageBodySizeRequest;
+                fromJSON(_: any): _26.QueryGetMaxMessageBodySizeRequest;
+                toJSON(_: _26.QueryGetMaxMessageBodySizeRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetMaxMessageBodySizeRequest>;
+                fromPartial(_: Partial<_26.QueryGetMaxMessageBodySizeRequest>): _26.QueryGetMaxMessageBodySizeRequest;
+                fromProtoMsg(message: _26.QueryGetMaxMessageBodySizeRequestProtoMsg): _26.QueryGetMaxMessageBodySizeRequest;
+                toProto(message: _26.QueryGetMaxMessageBodySizeRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetMaxMessageBodySizeRequest): _26.QueryGetMaxMessageBodySizeRequestProtoMsg;
+            };
+            QueryGetMaxMessageBodySizeResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetMaxMessageBodySizeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetMaxMessageBodySizeResponse;
+                fromJSON(object: any): _26.QueryGetMaxMessageBodySizeResponse;
+                toJSON(message: _26.QueryGetMaxMessageBodySizeResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetMaxMessageBodySizeResponse>;
+                fromPartial(object: Partial<_26.QueryGetMaxMessageBodySizeResponse>): _26.QueryGetMaxMessageBodySizeResponse;
+                fromProtoMsg(message: _26.QueryGetMaxMessageBodySizeResponseProtoMsg): _26.QueryGetMaxMessageBodySizeResponse;
+                toProto(message: _26.QueryGetMaxMessageBodySizeResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetMaxMessageBodySizeResponse): _26.QueryGetMaxMessageBodySizeResponseProtoMsg;
+            };
+            QueryGetNextAvailableNonceRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryGetNextAvailableNonceRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetNextAvailableNonceRequest;
+                fromJSON(_: any): _26.QueryGetNextAvailableNonceRequest;
+                toJSON(_: _26.QueryGetNextAvailableNonceRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetNextAvailableNonceRequest>;
+                fromPartial(_: Partial<_26.QueryGetNextAvailableNonceRequest>): _26.QueryGetNextAvailableNonceRequest;
+                fromProtoMsg(message: _26.QueryGetNextAvailableNonceRequestProtoMsg): _26.QueryGetNextAvailableNonceRequest;
+                toProto(message: _26.QueryGetNextAvailableNonceRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetNextAvailableNonceRequest): _26.QueryGetNextAvailableNonceRequestProtoMsg;
+            };
+            QueryGetNextAvailableNonceResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetNextAvailableNonceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetNextAvailableNonceResponse;
+                fromJSON(object: any): _26.QueryGetNextAvailableNonceResponse;
+                toJSON(message: _26.QueryGetNextAvailableNonceResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetNextAvailableNonceResponse>;
+                fromPartial(object: Partial<_26.QueryGetNextAvailableNonceResponse>): _26.QueryGetNextAvailableNonceResponse;
+                fromProtoMsg(message: _26.QueryGetNextAvailableNonceResponseProtoMsg): _26.QueryGetNextAvailableNonceResponse;
+                toProto(message: _26.QueryGetNextAvailableNonceResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetNextAvailableNonceResponse): _26.QueryGetNextAvailableNonceResponseProtoMsg;
+            };
+            QueryGetSignatureThresholdRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryGetSignatureThresholdRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetSignatureThresholdRequest;
+                fromJSON(_: any): _26.QueryGetSignatureThresholdRequest;
+                toJSON(_: _26.QueryGetSignatureThresholdRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetSignatureThresholdRequest>;
+                fromPartial(_: Partial<_26.QueryGetSignatureThresholdRequest>): _26.QueryGetSignatureThresholdRequest;
+                fromProtoMsg(message: _26.QueryGetSignatureThresholdRequestProtoMsg): _26.QueryGetSignatureThresholdRequest;
+                toProto(message: _26.QueryGetSignatureThresholdRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetSignatureThresholdRequest): _26.QueryGetSignatureThresholdRequestProtoMsg;
+            };
+            QueryGetSignatureThresholdResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetSignatureThresholdResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetSignatureThresholdResponse;
+                fromJSON(object: any): _26.QueryGetSignatureThresholdResponse;
+                toJSON(message: _26.QueryGetSignatureThresholdResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetSignatureThresholdResponse>;
+                fromPartial(object: Partial<_26.QueryGetSignatureThresholdResponse>): _26.QueryGetSignatureThresholdResponse;
+                fromProtoMsg(message: _26.QueryGetSignatureThresholdResponseProtoMsg): _26.QueryGetSignatureThresholdResponse;
+                toProto(message: _26.QueryGetSignatureThresholdResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetSignatureThresholdResponse): _26.QueryGetSignatureThresholdResponseProtoMsg;
+            };
+            QueryGetTokenPairRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryGetTokenPairRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetTokenPairRequest;
+                fromJSON(object: any): _26.QueryGetTokenPairRequest;
+                toJSON(message: _26.QueryGetTokenPairRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetTokenPairRequest>;
+                fromPartial(object: Partial<_26.QueryGetTokenPairRequest>): _26.QueryGetTokenPairRequest;
+                fromProtoMsg(message: _26.QueryGetTokenPairRequestProtoMsg): _26.QueryGetTokenPairRequest;
+                toProto(message: _26.QueryGetTokenPairRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetTokenPairRequest): _26.QueryGetTokenPairRequestProtoMsg;
+            };
+            QueryGetTokenPairResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetTokenPairResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetTokenPairResponse;
+                fromJSON(object: any): _26.QueryGetTokenPairResponse;
+                toJSON(message: _26.QueryGetTokenPairResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetTokenPairResponse>;
+                fromPartial(object: Partial<_26.QueryGetTokenPairResponse>): _26.QueryGetTokenPairResponse;
+                fromProtoMsg(message: _26.QueryGetTokenPairResponseProtoMsg): _26.QueryGetTokenPairResponse;
+                toProto(message: _26.QueryGetTokenPairResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetTokenPairResponse): _26.QueryGetTokenPairResponseProtoMsg;
+            };
+            QueryAllTokenPairsRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryAllTokenPairsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllTokenPairsRequest;
+                fromJSON(object: any): _26.QueryAllTokenPairsRequest;
+                toJSON(message: _26.QueryAllTokenPairsRequest): import("../json-safe.ts").JsonSafe<_26.QueryAllTokenPairsRequest>;
+                fromPartial(object: Partial<_26.QueryAllTokenPairsRequest>): _26.QueryAllTokenPairsRequest;
+                fromProtoMsg(message: _26.QueryAllTokenPairsRequestProtoMsg): _26.QueryAllTokenPairsRequest;
+                toProto(message: _26.QueryAllTokenPairsRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryAllTokenPairsRequest): _26.QueryAllTokenPairsRequestProtoMsg;
+            };
+            QueryAllTokenPairsResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryAllTokenPairsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllTokenPairsResponse;
+                fromJSON(object: any): _26.QueryAllTokenPairsResponse;
+                toJSON(message: _26.QueryAllTokenPairsResponse): import("../json-safe.ts").JsonSafe<_26.QueryAllTokenPairsResponse>;
+                fromPartial(object: Partial<_26.QueryAllTokenPairsResponse>): _26.QueryAllTokenPairsResponse;
+                fromProtoMsg(message: _26.QueryAllTokenPairsResponseProtoMsg): _26.QueryAllTokenPairsResponse;
+                toProto(message: _26.QueryAllTokenPairsResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryAllTokenPairsResponse): _26.QueryAllTokenPairsResponseProtoMsg;
+            };
+            QueryGetUsedNonceRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryGetUsedNonceRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetUsedNonceRequest;
+                fromJSON(object: any): _26.QueryGetUsedNonceRequest;
+                toJSON(message: _26.QueryGetUsedNonceRequest): import("../json-safe.ts").JsonSafe<_26.QueryGetUsedNonceRequest>;
+                fromPartial(object: Partial<_26.QueryGetUsedNonceRequest>): _26.QueryGetUsedNonceRequest;
+                fromProtoMsg(message: _26.QueryGetUsedNonceRequestProtoMsg): _26.QueryGetUsedNonceRequest;
+                toProto(message: _26.QueryGetUsedNonceRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryGetUsedNonceRequest): _26.QueryGetUsedNonceRequestProtoMsg;
+            };
+            QueryGetUsedNonceResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryGetUsedNonceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryGetUsedNonceResponse;
+                fromJSON(object: any): _26.QueryGetUsedNonceResponse;
+                toJSON(message: _26.QueryGetUsedNonceResponse): import("../json-safe.ts").JsonSafe<_26.QueryGetUsedNonceResponse>;
+                fromPartial(object: Partial<_26.QueryGetUsedNonceResponse>): _26.QueryGetUsedNonceResponse;
+                fromProtoMsg(message: _26.QueryGetUsedNonceResponseProtoMsg): _26.QueryGetUsedNonceResponse;
+                toProto(message: _26.QueryGetUsedNonceResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryGetUsedNonceResponse): _26.QueryGetUsedNonceResponseProtoMsg;
+            };
+            QueryAllUsedNoncesRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryAllUsedNoncesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllUsedNoncesRequest;
+                fromJSON(object: any): _26.QueryAllUsedNoncesRequest;
+                toJSON(message: _26.QueryAllUsedNoncesRequest): import("../json-safe.ts").JsonSafe<_26.QueryAllUsedNoncesRequest>;
+                fromPartial(object: Partial<_26.QueryAllUsedNoncesRequest>): _26.QueryAllUsedNoncesRequest;
+                fromProtoMsg(message: _26.QueryAllUsedNoncesRequestProtoMsg): _26.QueryAllUsedNoncesRequest;
+                toProto(message: _26.QueryAllUsedNoncesRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryAllUsedNoncesRequest): _26.QueryAllUsedNoncesRequestProtoMsg;
+            };
+            QueryAllUsedNoncesResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryAllUsedNoncesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryAllUsedNoncesResponse;
+                fromJSON(object: any): _26.QueryAllUsedNoncesResponse;
+                toJSON(message: _26.QueryAllUsedNoncesResponse): import("../json-safe.ts").JsonSafe<_26.QueryAllUsedNoncesResponse>;
+                fromPartial(object: Partial<_26.QueryAllUsedNoncesResponse>): _26.QueryAllUsedNoncesResponse;
+                fromProtoMsg(message: _26.QueryAllUsedNoncesResponseProtoMsg): _26.QueryAllUsedNoncesResponse;
+                toProto(message: _26.QueryAllUsedNoncesResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryAllUsedNoncesResponse): _26.QueryAllUsedNoncesResponseProtoMsg;
+            };
+            QueryRemoteTokenMessengerRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryRemoteTokenMessengerRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryRemoteTokenMessengerRequest;
+                fromJSON(object: any): _26.QueryRemoteTokenMessengerRequest;
+                toJSON(message: _26.QueryRemoteTokenMessengerRequest): import("../json-safe.ts").JsonSafe<_26.QueryRemoteTokenMessengerRequest>;
+                fromPartial(object: Partial<_26.QueryRemoteTokenMessengerRequest>): _26.QueryRemoteTokenMessengerRequest;
+                fromProtoMsg(message: _26.QueryRemoteTokenMessengerRequestProtoMsg): _26.QueryRemoteTokenMessengerRequest;
+                toProto(message: _26.QueryRemoteTokenMessengerRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryRemoteTokenMessengerRequest): _26.QueryRemoteTokenMessengerRequestProtoMsg;
+            };
+            QueryRemoteTokenMessengerResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryRemoteTokenMessengerResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryRemoteTokenMessengerResponse;
+                fromJSON(object: any): _26.QueryRemoteTokenMessengerResponse;
+                toJSON(message: _26.QueryRemoteTokenMessengerResponse): import("../json-safe.ts").JsonSafe<_26.QueryRemoteTokenMessengerResponse>;
+                fromPartial(object: Partial<_26.QueryRemoteTokenMessengerResponse>): _26.QueryRemoteTokenMessengerResponse;
+                fromProtoMsg(message: _26.QueryRemoteTokenMessengerResponseProtoMsg): _26.QueryRemoteTokenMessengerResponse;
+                toProto(message: _26.QueryRemoteTokenMessengerResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryRemoteTokenMessengerResponse): _26.QueryRemoteTokenMessengerResponseProtoMsg;
+            };
+            QueryRemoteTokenMessengersRequest: {
+                typeUrl: string;
+                encode(message: _26.QueryRemoteTokenMessengersRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryRemoteTokenMessengersRequest;
+                fromJSON(object: any): _26.QueryRemoteTokenMessengersRequest;
+                toJSON(message: _26.QueryRemoteTokenMessengersRequest): import("../json-safe.ts").JsonSafe<_26.QueryRemoteTokenMessengersRequest>;
+                fromPartial(object: Partial<_26.QueryRemoteTokenMessengersRequest>): _26.QueryRemoteTokenMessengersRequest;
+                fromProtoMsg(message: _26.QueryRemoteTokenMessengersRequestProtoMsg): _26.QueryRemoteTokenMessengersRequest;
+                toProto(message: _26.QueryRemoteTokenMessengersRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryRemoteTokenMessengersRequest): _26.QueryRemoteTokenMessengersRequestProtoMsg;
+            };
+            QueryRemoteTokenMessengersResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryRemoteTokenMessengersResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryRemoteTokenMessengersResponse;
+                fromJSON(object: any): _26.QueryRemoteTokenMessengersResponse;
+                toJSON(message: _26.QueryRemoteTokenMessengersResponse): import("../json-safe.ts").JsonSafe<_26.QueryRemoteTokenMessengersResponse>;
+                fromPartial(object: Partial<_26.QueryRemoteTokenMessengersResponse>): _26.QueryRemoteTokenMessengersResponse;
+                fromProtoMsg(message: _26.QueryRemoteTokenMessengersResponseProtoMsg): _26.QueryRemoteTokenMessengersResponse;
+                toProto(message: _26.QueryRemoteTokenMessengersResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryRemoteTokenMessengersResponse): _26.QueryRemoteTokenMessengersResponseProtoMsg;
+            };
+            QueryBurnMessageVersionRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryBurnMessageVersionRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryBurnMessageVersionRequest;
+                fromJSON(_: any): _26.QueryBurnMessageVersionRequest;
+                toJSON(_: _26.QueryBurnMessageVersionRequest): import("../json-safe.ts").JsonSafe<_26.QueryBurnMessageVersionRequest>;
+                fromPartial(_: Partial<_26.QueryBurnMessageVersionRequest>): _26.QueryBurnMessageVersionRequest;
+                fromProtoMsg(message: _26.QueryBurnMessageVersionRequestProtoMsg): _26.QueryBurnMessageVersionRequest;
+                toProto(message: _26.QueryBurnMessageVersionRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryBurnMessageVersionRequest): _26.QueryBurnMessageVersionRequestProtoMsg;
+            };
+            QueryBurnMessageVersionResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryBurnMessageVersionResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryBurnMessageVersionResponse;
+                fromJSON(object: any): _26.QueryBurnMessageVersionResponse;
+                toJSON(message: _26.QueryBurnMessageVersionResponse): import("../json-safe.ts").JsonSafe<_26.QueryBurnMessageVersionResponse>;
+                fromPartial(object: Partial<_26.QueryBurnMessageVersionResponse>): _26.QueryBurnMessageVersionResponse;
+                fromProtoMsg(message: _26.QueryBurnMessageVersionResponseProtoMsg): _26.QueryBurnMessageVersionResponse;
+                toProto(message: _26.QueryBurnMessageVersionResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryBurnMessageVersionResponse): _26.QueryBurnMessageVersionResponseProtoMsg;
+            };
+            QueryLocalMessageVersionRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryLocalMessageVersionRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryLocalMessageVersionRequest;
+                fromJSON(_: any): _26.QueryLocalMessageVersionRequest;
+                toJSON(_: _26.QueryLocalMessageVersionRequest): import("../json-safe.ts").JsonSafe<_26.QueryLocalMessageVersionRequest>;
+                fromPartial(_: Partial<_26.QueryLocalMessageVersionRequest>): _26.QueryLocalMessageVersionRequest;
+                fromProtoMsg(message: _26.QueryLocalMessageVersionRequestProtoMsg): _26.QueryLocalMessageVersionRequest;
+                toProto(message: _26.QueryLocalMessageVersionRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryLocalMessageVersionRequest): _26.QueryLocalMessageVersionRequestProtoMsg;
+            };
+            QueryLocalMessageVersionResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryLocalMessageVersionResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryLocalMessageVersionResponse;
+                fromJSON(object: any): _26.QueryLocalMessageVersionResponse;
+                toJSON(message: _26.QueryLocalMessageVersionResponse): import("../json-safe.ts").JsonSafe<_26.QueryLocalMessageVersionResponse>;
+                fromPartial(object: Partial<_26.QueryLocalMessageVersionResponse>): _26.QueryLocalMessageVersionResponse;
+                fromProtoMsg(message: _26.QueryLocalMessageVersionResponseProtoMsg): _26.QueryLocalMessageVersionResponse;
+                toProto(message: _26.QueryLocalMessageVersionResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryLocalMessageVersionResponse): _26.QueryLocalMessageVersionResponseProtoMsg;
+            };
+            QueryLocalDomainRequest: {
+                typeUrl: string;
+                encode(_: _26.QueryLocalDomainRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryLocalDomainRequest;
+                fromJSON(_: any): _26.QueryLocalDomainRequest;
+                toJSON(_: _26.QueryLocalDomainRequest): import("../json-safe.ts").JsonSafe<_26.QueryLocalDomainRequest>;
+                fromPartial(_: Partial<_26.QueryLocalDomainRequest>): _26.QueryLocalDomainRequest;
+                fromProtoMsg(message: _26.QueryLocalDomainRequestProtoMsg): _26.QueryLocalDomainRequest;
+                toProto(message: _26.QueryLocalDomainRequest): Uint8Array;
+                toProtoMsg(message: _26.QueryLocalDomainRequest): _26.QueryLocalDomainRequestProtoMsg;
+            };
+            QueryLocalDomainResponse: {
+                typeUrl: string;
+                encode(message: _26.QueryLocalDomainResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _26.QueryLocalDomainResponse;
+                fromJSON(object: any): _26.QueryLocalDomainResponse;
+                toJSON(message: _26.QueryLocalDomainResponse): import("../json-safe.ts").JsonSafe<_26.QueryLocalDomainResponse>;
+                fromPartial(object: Partial<_26.QueryLocalDomainResponse>): _26.QueryLocalDomainResponse;
+                fromProtoMsg(message: _26.QueryLocalDomainResponseProtoMsg): _26.QueryLocalDomainResponse;
+                toProto(message: _26.QueryLocalDomainResponse): Uint8Array;
+                toProtoMsg(message: _26.QueryLocalDomainResponse): _26.QueryLocalDomainResponseProtoMsg;
+            };
+            PerMessageBurnLimit: {
+                typeUrl: string;
+                encode(message: _25.PerMessageBurnLimit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _25.PerMessageBurnLimit;
+                fromJSON(object: any): _25.PerMessageBurnLimit;
+                toJSON(message: _25.PerMessageBurnLimit): import("../json-safe.ts").JsonSafe<_25.PerMessageBurnLimit>;
+                fromPartial(object: Partial<_25.PerMessageBurnLimit>): _25.PerMessageBurnLimit;
+                fromProtoMsg(message: _25.PerMessageBurnLimitProtoMsg): _25.PerMessageBurnLimit;
+                toProto(message: _25.PerMessageBurnLimit): Uint8Array;
+                toProtoMsg(message: _25.PerMessageBurnLimit): _25.PerMessageBurnLimitProtoMsg;
+            };
+            Nonce: {
+                typeUrl: string;
+                encode(message: _24.Nonce, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _24.Nonce;
+                fromJSON(object: any): _24.Nonce;
+                toJSON(message: _24.Nonce): import("../json-safe.ts").JsonSafe<_24.Nonce>;
+                fromPartial(object: Partial<_24.Nonce>): _24.Nonce;
+                fromProtoMsg(message: _24.NonceProtoMsg): _24.Nonce;
+                toProto(message: _24.Nonce): Uint8Array;
+                toProtoMsg(message: _24.Nonce): _24.NonceProtoMsg;
+            };
+            Message: {
+                typeUrl: string;
+                encode(message: _23.Message, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _23.Message;
+                fromJSON(object: any): _23.Message;
+                toJSON(message: _23.Message): import("../json-safe.ts").JsonSafe<_23.Message>;
+                fromPartial(object: Partial<_23.Message>): _23.Message;
+                fromProtoMsg(message: _23.MessageProtoMsg): _23.Message;
+                toProto(message: _23.Message): Uint8Array;
+                toProtoMsg(message: _23.Message): _23.MessageProtoMsg;
+            };
+            MaxMessageBodySize: {
+                typeUrl: string;
+                encode(message: _22.MaxMessageBodySize, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _22.MaxMessageBodySize;
+                fromJSON(object: any): _22.MaxMessageBodySize;
+                toJSON(message: _22.MaxMessageBodySize): import("../json-safe.ts").JsonSafe<_22.MaxMessageBodySize>;
+                fromPartial(object: Partial<_22.MaxMessageBodySize>): _22.MaxMessageBodySize;
+                fromProtoMsg(message: _22.MaxMessageBodySizeProtoMsg): _22.MaxMessageBodySize;
+                toProto(message: _22.MaxMessageBodySize): Uint8Array;
+                toProtoMsg(message: _22.MaxMessageBodySize): _22.MaxMessageBodySizeProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                encode(message: _21.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _21.GenesisState;
+                fromJSON(object: any): _21.GenesisState;
+                toJSON(message: _21.GenesisState): import("../json-safe.ts").JsonSafe<_21.GenesisState>;
+                fromPartial(object: Partial<_21.GenesisState>): _21.GenesisState;
+                fromProtoMsg(message: _21.GenesisStateProtoMsg): _21.GenesisState;
+                toProto(message: _21.GenesisState): Uint8Array;
+                toProtoMsg(message: _21.GenesisState): _21.GenesisStateProtoMsg;
+            };
+            AttesterEnabled: {
+                typeUrl: string;
+                encode(message: _20.AttesterEnabled, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.AttesterEnabled;
+                fromJSON(object: any): _20.AttesterEnabled;
+                toJSON(message: _20.AttesterEnabled): import("../json-safe.ts").JsonSafe<_20.AttesterEnabled>;
+                fromPartial(object: Partial<_20.AttesterEnabled>): _20.AttesterEnabled;
+                fromProtoMsg(message: _20.AttesterEnabledProtoMsg): _20.AttesterEnabled;
+                toProto(message: _20.AttesterEnabled): Uint8Array;
+                toProtoMsg(message: _20.AttesterEnabled): _20.AttesterEnabledProtoMsg;
+            };
+            AttesterDisabled: {
+                typeUrl: string;
+                encode(message: _20.AttesterDisabled, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.AttesterDisabled;
+                fromJSON(object: any): _20.AttesterDisabled;
+                toJSON(message: _20.AttesterDisabled): import("../json-safe.ts").JsonSafe<_20.AttesterDisabled>;
+                fromPartial(object: Partial<_20.AttesterDisabled>): _20.AttesterDisabled;
+                fromProtoMsg(message: _20.AttesterDisabledProtoMsg): _20.AttesterDisabled;
+                toProto(message: _20.AttesterDisabled): Uint8Array;
+                toProtoMsg(message: _20.AttesterDisabled): _20.AttesterDisabledProtoMsg;
+            };
+            SignatureThresholdUpdated: {
+                typeUrl: string;
+                encode(message: _20.SignatureThresholdUpdated, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.SignatureThresholdUpdated;
+                fromJSON(object: any): _20.SignatureThresholdUpdated;
+                toJSON(message: _20.SignatureThresholdUpdated): import("../json-safe.ts").JsonSafe<_20.SignatureThresholdUpdated>;
+                fromPartial(object: Partial<_20.SignatureThresholdUpdated>): _20.SignatureThresholdUpdated;
+                fromProtoMsg(message: _20.SignatureThresholdUpdatedProtoMsg): _20.SignatureThresholdUpdated;
+                toProto(message: _20.SignatureThresholdUpdated): Uint8Array;
+                toProtoMsg(message: _20.SignatureThresholdUpdated): _20.SignatureThresholdUpdatedProtoMsg;
+            };
+            OwnerUpdated: {
+                typeUrl: string;
+                encode(message: _20.OwnerUpdated, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.OwnerUpdated;
+                fromJSON(object: any): _20.OwnerUpdated;
+                toJSON(message: _20.OwnerUpdated): import("../json-safe.ts").JsonSafe<_20.OwnerUpdated>;
+                fromPartial(object: Partial<_20.OwnerUpdated>): _20.OwnerUpdated;
+                fromProtoMsg(message: _20.OwnerUpdatedProtoMsg): _20.OwnerUpdated;
+                toProto(message: _20.OwnerUpdated): Uint8Array;
+                toProtoMsg(message: _20.OwnerUpdated): _20.OwnerUpdatedProtoMsg;
+            };
+            OwnershipTransferStarted: {
+                typeUrl: string;
+                encode(message: _20.OwnershipTransferStarted, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.OwnershipTransferStarted;
+                fromJSON(object: any): _20.OwnershipTransferStarted;
+                toJSON(message: _20.OwnershipTransferStarted): import("../json-safe.ts").JsonSafe<_20.OwnershipTransferStarted>;
+                fromPartial(object: Partial<_20.OwnershipTransferStarted>): _20.OwnershipTransferStarted;
+                fromProtoMsg(message: _20.OwnershipTransferStartedProtoMsg): _20.OwnershipTransferStarted;
+                toProto(message: _20.OwnershipTransferStarted): Uint8Array;
+                toProtoMsg(message: _20.OwnershipTransferStarted): _20.OwnershipTransferStartedProtoMsg;
+            };
+            PauserUpdated: {
+                typeUrl: string;
+                encode(message: _20.PauserUpdated, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.PauserUpdated;
+                fromJSON(object: any): _20.PauserUpdated;
+                toJSON(message: _20.PauserUpdated): import("../json-safe.ts").JsonSafe<_20.PauserUpdated>;
+                fromPartial(object: Partial<_20.PauserUpdated>): _20.PauserUpdated;
+                fromProtoMsg(message: _20.PauserUpdatedProtoMsg): _20.PauserUpdated;
+                toProto(message: _20.PauserUpdated): Uint8Array;
+                toProtoMsg(message: _20.PauserUpdated): _20.PauserUpdatedProtoMsg;
+            };
+            AttesterManagerUpdated: {
+                typeUrl: string;
+                encode(message: _20.AttesterManagerUpdated, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.AttesterManagerUpdated;
+                fromJSON(object: any): _20.AttesterManagerUpdated;
+                toJSON(message: _20.AttesterManagerUpdated): import("../json-safe.ts").JsonSafe<_20.AttesterManagerUpdated>;
+                fromPartial(object: Partial<_20.AttesterManagerUpdated>): _20.AttesterManagerUpdated;
+                fromProtoMsg(message: _20.AttesterManagerUpdatedProtoMsg): _20.AttesterManagerUpdated;
+                toProto(message: _20.AttesterManagerUpdated): Uint8Array;
+                toProtoMsg(message: _20.AttesterManagerUpdated): _20.AttesterManagerUpdatedProtoMsg;
+            };
+            TokenControllerUpdated: {
+                typeUrl: string;
+                encode(message: _20.TokenControllerUpdated, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.TokenControllerUpdated;
+                fromJSON(object: any): _20.TokenControllerUpdated;
+                toJSON(message: _20.TokenControllerUpdated): import("../json-safe.ts").JsonSafe<_20.TokenControllerUpdated>;
+                fromPartial(object: Partial<_20.TokenControllerUpdated>): _20.TokenControllerUpdated;
+                fromProtoMsg(message: _20.TokenControllerUpdatedProtoMsg): _20.TokenControllerUpdated;
+                toProto(message: _20.TokenControllerUpdated): Uint8Array;
+                toProtoMsg(message: _20.TokenControllerUpdated): _20.TokenControllerUpdatedProtoMsg;
+            };
+            BurningAndMintingPausedEvent: {
+                typeUrl: string;
+                encode(_: _20.BurningAndMintingPausedEvent, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.BurningAndMintingPausedEvent;
+                fromJSON(_: any): _20.BurningAndMintingPausedEvent;
+                toJSON(_: _20.BurningAndMintingPausedEvent): import("../json-safe.ts").JsonSafe<_20.BurningAndMintingPausedEvent>;
+                fromPartial(_: Partial<_20.BurningAndMintingPausedEvent>): _20.BurningAndMintingPausedEvent;
+                fromProtoMsg(message: _20.BurningAndMintingPausedEventProtoMsg): _20.BurningAndMintingPausedEvent;
+                toProto(message: _20.BurningAndMintingPausedEvent): Uint8Array;
+                toProtoMsg(message: _20.BurningAndMintingPausedEvent): _20.BurningAndMintingPausedEventProtoMsg;
+            };
+            BurningAndMintingUnpausedEvent: {
+                typeUrl: string;
+                encode(_: _20.BurningAndMintingUnpausedEvent, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.BurningAndMintingUnpausedEvent;
+                fromJSON(_: any): _20.BurningAndMintingUnpausedEvent;
+                toJSON(_: _20.BurningAndMintingUnpausedEvent): import("../json-safe.ts").JsonSafe<_20.BurningAndMintingUnpausedEvent>;
+                fromPartial(_: Partial<_20.BurningAndMintingUnpausedEvent>): _20.BurningAndMintingUnpausedEvent;
+                fromProtoMsg(message: _20.BurningAndMintingUnpausedEventProtoMsg): _20.BurningAndMintingUnpausedEvent;
+                toProto(message: _20.BurningAndMintingUnpausedEvent): Uint8Array;
+                toProtoMsg(message: _20.BurningAndMintingUnpausedEvent): _20.BurningAndMintingUnpausedEventProtoMsg;
+            };
+            SendingAndReceivingPausedEvent: {
+                typeUrl: string;
+                encode(_: _20.SendingAndReceivingPausedEvent, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.SendingAndReceivingPausedEvent;
+                fromJSON(_: any): _20.SendingAndReceivingPausedEvent;
+                toJSON(_: _20.SendingAndReceivingPausedEvent): import("../json-safe.ts").JsonSafe<_20.SendingAndReceivingPausedEvent>;
+                fromPartial(_: Partial<_20.SendingAndReceivingPausedEvent>): _20.SendingAndReceivingPausedEvent;
+                fromProtoMsg(message: _20.SendingAndReceivingPausedEventProtoMsg): _20.SendingAndReceivingPausedEvent;
+                toProto(message: _20.SendingAndReceivingPausedEvent): Uint8Array;
+                toProtoMsg(message: _20.SendingAndReceivingPausedEvent): _20.SendingAndReceivingPausedEventProtoMsg;
+            };
+            SendingAndReceivingUnpausedEvent: {
+                typeUrl: string;
+                encode(_: _20.SendingAndReceivingUnpausedEvent, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.SendingAndReceivingUnpausedEvent;
+                fromJSON(_: any): _20.SendingAndReceivingUnpausedEvent;
+                toJSON(_: _20.SendingAndReceivingUnpausedEvent): import("../json-safe.ts").JsonSafe<_20.SendingAndReceivingUnpausedEvent>;
+                fromPartial(_: Partial<_20.SendingAndReceivingUnpausedEvent>): _20.SendingAndReceivingUnpausedEvent;
+                fromProtoMsg(message: _20.SendingAndReceivingUnpausedEventProtoMsg): _20.SendingAndReceivingUnpausedEvent;
+                toProto(message: _20.SendingAndReceivingUnpausedEvent): Uint8Array;
+                toProtoMsg(message: _20.SendingAndReceivingUnpausedEvent): _20.SendingAndReceivingUnpausedEventProtoMsg;
+            };
+            DepositForBurn: {
+                typeUrl: string;
+                encode(message: _20.DepositForBurn, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.DepositForBurn;
+                fromJSON(object: any): _20.DepositForBurn;
+                toJSON(message: _20.DepositForBurn): import("../json-safe.ts").JsonSafe<_20.DepositForBurn>;
+                fromPartial(object: Partial<_20.DepositForBurn>): _20.DepositForBurn;
+                fromProtoMsg(message: _20.DepositForBurnProtoMsg): _20.DepositForBurn;
+                toProto(message: _20.DepositForBurn): Uint8Array;
+                toProtoMsg(message: _20.DepositForBurn): _20.DepositForBurnProtoMsg;
+            };
+            MintAndWithdraw: {
+                typeUrl: string;
+                encode(message: _20.MintAndWithdraw, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.MintAndWithdraw;
+                fromJSON(object: any): _20.MintAndWithdraw;
+                toJSON(message: _20.MintAndWithdraw): import("../json-safe.ts").JsonSafe<_20.MintAndWithdraw>;
+                fromPartial(object: Partial<_20.MintAndWithdraw>): _20.MintAndWithdraw;
+                fromProtoMsg(message: _20.MintAndWithdrawProtoMsg): _20.MintAndWithdraw;
+                toProto(message: _20.MintAndWithdraw): Uint8Array;
+                toProtoMsg(message: _20.MintAndWithdraw): _20.MintAndWithdrawProtoMsg;
+            };
+            TokenPairLinked: {
+                typeUrl: string;
+                encode(message: _20.TokenPairLinked, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.TokenPairLinked;
+                fromJSON(object: any): _20.TokenPairLinked;
+                toJSON(message: _20.TokenPairLinked): import("../json-safe.ts").JsonSafe<_20.TokenPairLinked>;
+                fromPartial(object: Partial<_20.TokenPairLinked>): _20.TokenPairLinked;
+                fromProtoMsg(message: _20.TokenPairLinkedProtoMsg): _20.TokenPairLinked;
+                toProto(message: _20.TokenPairLinked): Uint8Array;
+                toProtoMsg(message: _20.TokenPairLinked): _20.TokenPairLinkedProtoMsg;
+            };
+            TokenPairUnlinked: {
+                typeUrl: string;
+                encode(message: _20.TokenPairUnlinked, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.TokenPairUnlinked;
+                fromJSON(object: any): _20.TokenPairUnlinked;
+                toJSON(message: _20.TokenPairUnlinked): import("../json-safe.ts").JsonSafe<_20.TokenPairUnlinked>;
+                fromPartial(object: Partial<_20.TokenPairUnlinked>): _20.TokenPairUnlinked;
+                fromProtoMsg(message: _20.TokenPairUnlinkedProtoMsg): _20.TokenPairUnlinked;
+                toProto(message: _20.TokenPairUnlinked): Uint8Array;
+                toProtoMsg(message: _20.TokenPairUnlinked): _20.TokenPairUnlinkedProtoMsg;
+            };
+            MessageSent: {
+                typeUrl: string;
+                encode(message: _20.MessageSent, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.MessageSent;
+                fromJSON(object: any): _20.MessageSent;
+                toJSON(message: _20.MessageSent): import("../json-safe.ts").JsonSafe<_20.MessageSent>;
+                fromPartial(object: Partial<_20.MessageSent>): _20.MessageSent;
+                fromProtoMsg(message: _20.MessageSentProtoMsg): _20.MessageSent;
+                toProto(message: _20.MessageSent): Uint8Array;
+                toProtoMsg(message: _20.MessageSent): _20.MessageSentProtoMsg;
+            };
+            MessageReceived: {
+                typeUrl: string;
+                encode(message: _20.MessageReceived, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.MessageReceived;
+                fromJSON(object: any): _20.MessageReceived;
+                toJSON(message: _20.MessageReceived): import("../json-safe.ts").JsonSafe<_20.MessageReceived>;
+                fromPartial(object: Partial<_20.MessageReceived>): _20.MessageReceived;
+                fromProtoMsg(message: _20.MessageReceivedProtoMsg): _20.MessageReceived;
+                toProto(message: _20.MessageReceived): Uint8Array;
+                toProtoMsg(message: _20.MessageReceived): _20.MessageReceivedProtoMsg;
+            };
+            MaxMessageBodySizeUpdated: {
+                typeUrl: string;
+                encode(message: _20.MaxMessageBodySizeUpdated, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.MaxMessageBodySizeUpdated;
+                fromJSON(object: any): _20.MaxMessageBodySizeUpdated;
+                toJSON(message: _20.MaxMessageBodySizeUpdated): import("../json-safe.ts").JsonSafe<_20.MaxMessageBodySizeUpdated>;
+                fromPartial(object: Partial<_20.MaxMessageBodySizeUpdated>): _20.MaxMessageBodySizeUpdated;
+                fromProtoMsg(message: _20.MaxMessageBodySizeUpdatedProtoMsg): _20.MaxMessageBodySizeUpdated;
+                toProto(message: _20.MaxMessageBodySizeUpdated): Uint8Array;
+                toProtoMsg(message: _20.MaxMessageBodySizeUpdated): _20.MaxMessageBodySizeUpdatedProtoMsg;
+            };
+            RemoteTokenMessengerAdded: {
+                typeUrl: string;
+                encode(message: _20.RemoteTokenMessengerAdded, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.RemoteTokenMessengerAdded;
+                fromJSON(object: any): _20.RemoteTokenMessengerAdded;
+                toJSON(message: _20.RemoteTokenMessengerAdded): import("../json-safe.ts").JsonSafe<_20.RemoteTokenMessengerAdded>;
+                fromPartial(object: Partial<_20.RemoteTokenMessengerAdded>): _20.RemoteTokenMessengerAdded;
+                fromProtoMsg(message: _20.RemoteTokenMessengerAddedProtoMsg): _20.RemoteTokenMessengerAdded;
+                toProto(message: _20.RemoteTokenMessengerAdded): Uint8Array;
+                toProtoMsg(message: _20.RemoteTokenMessengerAdded): _20.RemoteTokenMessengerAddedProtoMsg;
+            };
+            RemoteTokenMessengerRemoved: {
+                typeUrl: string;
+                encode(message: _20.RemoteTokenMessengerRemoved, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.RemoteTokenMessengerRemoved;
+                fromJSON(object: any): _20.RemoteTokenMessengerRemoved;
+                toJSON(message: _20.RemoteTokenMessengerRemoved): import("../json-safe.ts").JsonSafe<_20.RemoteTokenMessengerRemoved>;
+                fromPartial(object: Partial<_20.RemoteTokenMessengerRemoved>): _20.RemoteTokenMessengerRemoved;
+                fromProtoMsg(message: _20.RemoteTokenMessengerRemovedProtoMsg): _20.RemoteTokenMessengerRemoved;
+                toProto(message: _20.RemoteTokenMessengerRemoved): Uint8Array;
+                toProtoMsg(message: _20.RemoteTokenMessengerRemoved): _20.RemoteTokenMessengerRemovedProtoMsg;
+            };
+            SetBurnLimitPerMessage: {
+                typeUrl: string;
+                encode(message: _20.SetBurnLimitPerMessage, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _20.SetBurnLimitPerMessage;
+                fromJSON(object: any): _20.SetBurnLimitPerMessage;
+                toJSON(message: _20.SetBurnLimitPerMessage): import("../json-safe.ts").JsonSafe<_20.SetBurnLimitPerMessage>;
+                fromPartial(object: Partial<_20.SetBurnLimitPerMessage>): _20.SetBurnLimitPerMessage;
+                fromProtoMsg(message: _20.SetBurnLimitPerMessageProtoMsg): _20.SetBurnLimitPerMessage;
+                toProto(message: _20.SetBurnLimitPerMessage): Uint8Array;
+                toProtoMsg(message: _20.SetBurnLimitPerMessage): _20.SetBurnLimitPerMessageProtoMsg;
+            };
+            BurningAndMintingPaused: {
+                typeUrl: string;
+                encode(message: _19.BurningAndMintingPaused, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _19.BurningAndMintingPaused;
+                fromJSON(object: any): _19.BurningAndMintingPaused;
+                toJSON(message: _19.BurningAndMintingPaused): import("../json-safe.ts").JsonSafe<_19.BurningAndMintingPaused>;
+                fromPartial(object: Partial<_19.BurningAndMintingPaused>): _19.BurningAndMintingPaused;
+                fromProtoMsg(message: _19.BurningAndMintingPausedProtoMsg): _19.BurningAndMintingPaused;
+                toProto(message: _19.BurningAndMintingPaused): Uint8Array;
+                toProtoMsg(message: _19.BurningAndMintingPaused): _19.BurningAndMintingPausedProtoMsg;
+            };
+            BurnMessage: {
+                typeUrl: string;
+                encode(message: _18.BurnMessage, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _18.BurnMessage;
+                fromJSON(object: any): _18.BurnMessage;
+                toJSON(message: _18.BurnMessage): import("../json-safe.ts").JsonSafe<_18.BurnMessage>;
+                fromPartial(object: Partial<_18.BurnMessage>): _18.BurnMessage;
+                fromProtoMsg(message: _18.BurnMessageProtoMsg): _18.BurnMessage;
+                toProto(message: _18.BurnMessage): Uint8Array;
+                toProtoMsg(message: _18.BurnMessage): _18.BurnMessageProtoMsg;
+            };
+            Attester: {
+                typeUrl: string;
+                encode(message: _17.Attester, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _17.Attester;
+                fromJSON(object: any): _17.Attester;
+                toJSON(message: _17.Attester): import("../json-safe.ts").JsonSafe<_17.Attester>;
+                fromPartial(object: Partial<_17.Attester>): _17.Attester;
+                fromProtoMsg(message: _17.AttesterProtoMsg): _17.Attester;
+                toProto(message: _17.Attester): Uint8Array;
+                toProtoMsg(message: _17.Attester): _17.AttesterProtoMsg;
+            };
+        };
+    }
+}