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

package/dist/codegen/circle/cctp/v1/events.d.ts

@@ -0,0 +1,730 @@
+import { BinaryReader, BinaryWriter } from '../../../binary.js';
+import { type JsonSafe } from '../../../json-safe.js';
+/**
+ * Emitted when an attester is enabled
+ * @param attester newly enabled attester
+ */
+export interface AttesterEnabled {
+    attester: string;
+}
+export interface AttesterEnabledProtoMsg {
+    typeUrl: '/circle.cctp.v1.AttesterEnabled';
+    value: Uint8Array;
+}
+/**
+ * Emitted when an attester is enabled
+ * @param attester newly enabled attester
+ */
+export interface AttesterEnabledSDKType {
+    attester: string;
+}
+/**
+ * Emitted when an attester is disabled
+ * @param attester newly disabled attester
+ */
+export interface AttesterDisabled {
+    attester: string;
+}
+export interface AttesterDisabledProtoMsg {
+    typeUrl: '/circle.cctp.v1.AttesterDisabled';
+    value: Uint8Array;
+}
+/**
+ * Emitted when an attester is disabled
+ * @param attester newly disabled attester
+ */
+export interface AttesterDisabledSDKType {
+    attester: string;
+}
+/**
+ * Emitted when threshold number of attestations (m in m/n multisig) is updated
+ * @param old_signature_threshold old signature threshold
+ * @param new_signature_threshold new signature threshold
+ */
+export interface SignatureThresholdUpdated {
+    oldSignatureThreshold: bigint;
+    newSignatureThreshold: bigint;
+}
+export interface SignatureThresholdUpdatedProtoMsg {
+    typeUrl: '/circle.cctp.v1.SignatureThresholdUpdated';
+    value: Uint8Array;
+}
+/**
+ * Emitted when threshold number of attestations (m in m/n multisig) is updated
+ * @param old_signature_threshold old signature threshold
+ * @param new_signature_threshold new signature threshold
+ */
+export interface SignatureThresholdUpdatedSDKType {
+    old_signature_threshold: bigint;
+    new_signature_threshold: bigint;
+}
+/**
+ * Emitted when owner address is updated
+ * @param previous_owner representing the address of the previous owner
+ * @param new_owner representing the address of the new owner
+ */
+export interface OwnerUpdated {
+    previousOwner: string;
+    newOwner: string;
+}
+export interface OwnerUpdatedProtoMsg {
+    typeUrl: '/circle.cctp.v1.OwnerUpdated';
+    value: Uint8Array;
+}
+/**
+ * Emitted when owner address is updated
+ * @param previous_owner representing the address of the previous owner
+ * @param new_owner representing the address of the new owner
+ */
+export interface OwnerUpdatedSDKType {
+    previous_owner: string;
+    new_owner: string;
+}
+/**
+ * Emitted when starting the two stage transfer ownership process
+ * @param previousOwner representing the address of the previous owner
+ * @param newOwner representing the address of the new owner
+ */
+export interface OwnershipTransferStarted {
+    previousOwner: string;
+    newOwner: string;
+}
+export interface OwnershipTransferStartedProtoMsg {
+    typeUrl: '/circle.cctp.v1.OwnershipTransferStarted';
+    value: Uint8Array;
+}
+/**
+ * Emitted when starting the two stage transfer ownership process
+ * @param previousOwner representing the address of the previous owner
+ * @param newOwner representing the address of the new owner
+ */
+export interface OwnershipTransferStartedSDKType {
+    previous_owner: string;
+    new_owner: string;
+}
+/**
+ * Emitted when pauser address is updated
+ * @param previous_pauser representing the address of the previous pauser
+ * @param new_pauser representing the address of the new pauser
+ */
+export interface PauserUpdated {
+    previousPauser: string;
+    newPauser: string;
+}
+export interface PauserUpdatedProtoMsg {
+    typeUrl: '/circle.cctp.v1.PauserUpdated';
+    value: Uint8Array;
+}
+/**
+ * Emitted when pauser address is updated
+ * @param previous_pauser representing the address of the previous pauser
+ * @param new_pauser representing the address of the new pauser
+ */
+export interface PauserUpdatedSDKType {
+    previous_pauser: string;
+    new_pauser: string;
+}
+/**
+ * Emitted when attester manager address is updated
+ * @param previous_attester_manager representing the address of the previous
+ * attester manager
+ * @param new_attester_manager representing the address of the new attester
+ * manager
+ */
+export interface AttesterManagerUpdated {
+    previousAttesterManager: string;
+    newAttesterManager: string;
+}
+export interface AttesterManagerUpdatedProtoMsg {
+    typeUrl: '/circle.cctp.v1.AttesterManagerUpdated';
+    value: Uint8Array;
+}
+/**
+ * Emitted when attester manager address is updated
+ * @param previous_attester_manager representing the address of the previous
+ * attester manager
+ * @param new_attester_manager representing the address of the new attester
+ * manager
+ */
+export interface AttesterManagerUpdatedSDKType {
+    previous_attester_manager: string;
+    new_attester_manager: string;
+}
+/**
+ * Emitted when token controller address is updated
+ * @param previous_token_controller representing the address of the previous
+ * token controller
+ * @param new_token_controller representing the address of the new token
+ * controller
+ */
+export interface TokenControllerUpdated {
+    previousTokenController: string;
+    newTokenController: string;
+}
+export interface TokenControllerUpdatedProtoMsg {
+    typeUrl: '/circle.cctp.v1.TokenControllerUpdated';
+    value: Uint8Array;
+}
+/**
+ * Emitted when token controller address is updated
+ * @param previous_token_controller representing the address of the previous
+ * token controller
+ * @param new_token_controller representing the address of the new token
+ * controller
+ */
+export interface TokenControllerUpdatedSDKType {
+    previous_token_controller: string;
+    new_token_controller: string;
+}
+/** Emitted when burning and minting tokens is paused */
+export interface BurningAndMintingPausedEvent {
+}
+export interface BurningAndMintingPausedEventProtoMsg {
+    typeUrl: '/circle.cctp.v1.BurningAndMintingPausedEvent';
+    value: Uint8Array;
+}
+/** Emitted when burning and minting tokens is paused */
+export interface BurningAndMintingPausedEventSDKType {
+}
+/** Emitted when burning and minting tokens is unpaused */
+export interface BurningAndMintingUnpausedEvent {
+}
+export interface BurningAndMintingUnpausedEventProtoMsg {
+    typeUrl: '/circle.cctp.v1.BurningAndMintingUnpausedEvent';
+    value: Uint8Array;
+}
+/** Emitted when burning and minting tokens is unpaused */
+export interface BurningAndMintingUnpausedEventSDKType {
+}
+/** Emitted when sending and receiving messages is paused */
+export interface SendingAndReceivingPausedEvent {
+}
+export interface SendingAndReceivingPausedEventProtoMsg {
+    typeUrl: '/circle.cctp.v1.SendingAndReceivingPausedEvent';
+    value: Uint8Array;
+}
+/** Emitted when sending and receiving messages is paused */
+export interface SendingAndReceivingPausedEventSDKType {
+}
+/** Emitted when sending and receiving messages is paused */
+export interface SendingAndReceivingUnpausedEvent {
+}
+export interface SendingAndReceivingUnpausedEventProtoMsg {
+    typeUrl: '/circle.cctp.v1.SendingAndReceivingUnpausedEvent';
+    value: Uint8Array;
+}
+/** Emitted when sending and receiving messages is paused */
+export interface SendingAndReceivingUnpausedEventSDKType {
+}
+/**
+ * Emitted when a DepositForBurn message is sent
+ * @param nonce unique nonce reserved by message
+ * @param burn_token address of token burnt on source domain
+ * @param amount deposit amount
+ * @param depositor address where deposit is transferred from
+ * @param mint_recipient address receiving minted tokens on destination domain
+ * as bytes32
+ * @param destination_domain destination domain
+ * @param destination_token_messenger address of TokenMessenger on destination
+ * domain as bytes32
+ * @param destination_caller authorized caller as bytes32 of receiveMessage() on
+ * destination domain, if not equal to bytes32(0). If equal to bytes32(0), any
+ * address can call receiveMessage().
+ */
+export interface DepositForBurn {
+    nonce: bigint;
+    burnToken: string;
+    amount: string;
+    depositor: string;
+    mintRecipient: Uint8Array;
+    destinationDomain: number;
+    destinationTokenMessenger: Uint8Array;
+    destinationCaller: Uint8Array;
+}
+export interface DepositForBurnProtoMsg {
+    typeUrl: '/circle.cctp.v1.DepositForBurn';
+    value: Uint8Array;
+}
+/**
+ * Emitted when a DepositForBurn message is sent
+ * @param nonce unique nonce reserved by message
+ * @param burn_token address of token burnt on source domain
+ * @param amount deposit amount
+ * @param depositor address where deposit is transferred from
+ * @param mint_recipient address receiving minted tokens on destination domain
+ * as bytes32
+ * @param destination_domain destination domain
+ * @param destination_token_messenger address of TokenMessenger on destination
+ * domain as bytes32
+ * @param destination_caller authorized caller as bytes32 of receiveMessage() on
+ * destination domain, if not equal to bytes32(0). If equal to bytes32(0), any
+ * address can call receiveMessage().
+ */
+export interface DepositForBurnSDKType {
+    nonce: bigint;
+    burn_token: string;
+    amount: string;
+    depositor: string;
+    mint_recipient: Uint8Array;
+    destination_domain: number;
+    destination_token_messenger: Uint8Array;
+    destination_caller: Uint8Array;
+}
+/**
+ * Emitted when tokens are minted
+ * @param mint_recipient recipient address of minted tokens
+ * @param amount amount of minted tokens
+ * @param mint_token contract address of minted token
+ */
+export interface MintAndWithdraw {
+    mintRecipient: Uint8Array;
+    amount: string;
+    mintToken: string;
+}
+export interface MintAndWithdrawProtoMsg {
+    typeUrl: '/circle.cctp.v1.MintAndWithdraw';
+    value: Uint8Array;
+}
+/**
+ * Emitted when tokens are minted
+ * @param mint_recipient recipient address of minted tokens
+ * @param amount amount of minted tokens
+ * @param mint_token contract address of minted token
+ */
+export interface MintAndWithdrawSDKType {
+    mint_recipient: Uint8Array;
+    amount: string;
+    mint_token: string;
+}
+/**
+ * Emitted when a token pair is linked
+ * @param local_token local token to support
+ * @param remote_domain remote domain
+ * @param remote_token token on `remoteDomain` corresponding to `localToken`
+ */
+export interface TokenPairLinked {
+    localToken: string;
+    remoteDomain: number;
+    remoteToken: Uint8Array;
+}
+export interface TokenPairLinkedProtoMsg {
+    typeUrl: '/circle.cctp.v1.TokenPairLinked';
+    value: Uint8Array;
+}
+/**
+ * Emitted when a token pair is linked
+ * @param local_token local token to support
+ * @param remote_domain remote domain
+ * @param remote_token token on `remoteDomain` corresponding to `localToken`
+ */
+export interface TokenPairLinkedSDKType {
+    local_token: string;
+    remote_domain: number;
+    remote_token: Uint8Array;
+}
+/**
+ * Emitted when a token pair is unlinked
+ * @param local_token local token address
+ * @param remote_domain remote domain
+ * @param remote_token token on `remoteDomain` unlinked from `localToken`
+ */
+export interface TokenPairUnlinked {
+    localToken: string;
+    remoteDomain: number;
+    remoteToken: Uint8Array;
+}
+export interface TokenPairUnlinkedProtoMsg {
+    typeUrl: '/circle.cctp.v1.TokenPairUnlinked';
+    value: Uint8Array;
+}
+/**
+ * Emitted when a token pair is unlinked
+ * @param local_token local token address
+ * @param remote_domain remote domain
+ * @param remote_token token on `remoteDomain` unlinked from `localToken`
+ */
+export interface TokenPairUnlinkedSDKType {
+    local_token: string;
+    remote_domain: number;
+    remote_token: Uint8Array;
+}
+/**
+ * Emitted when a new message is dispatched
+ * @param message Raw bytes of message
+ */
+export interface MessageSent {
+    message: Uint8Array;
+}
+export interface MessageSentProtoMsg {
+    typeUrl: '/circle.cctp.v1.MessageSent';
+    value: Uint8Array;
+}
+/**
+ * Emitted when a new message is dispatched
+ * @param message Raw bytes of message
+ */
+export interface MessageSentSDKType {
+    message: Uint8Array;
+}
+/**
+ * Emitted when a new message is received
+ * @param caller caller (msg.sender) on destination domain
+ * @param source_domain the source domain this message originated from
+ * @param nonce the nonce unique to this message
+ * @param sender the sender of this message
+ * @param message_body message body bytes
+ */
+export interface MessageReceived {
+    caller: string;
+    sourceDomain: number;
+    nonce: bigint;
+    sender: Uint8Array;
+    messageBody: Uint8Array;
+}
+export interface MessageReceivedProtoMsg {
+    typeUrl: '/circle.cctp.v1.MessageReceived';
+    value: Uint8Array;
+}
+/**
+ * Emitted when a new message is received
+ * @param caller caller (msg.sender) on destination domain
+ * @param source_domain the source domain this message originated from
+ * @param nonce the nonce unique to this message
+ * @param sender the sender of this message
+ * @param message_body message body bytes
+ */
+export interface MessageReceivedSDKType {
+    caller: string;
+    source_domain: number;
+    nonce: bigint;
+    sender: Uint8Array;
+    message_body: Uint8Array;
+}
+/**
+ * Emitted when max message body size is updated
+ * @param new_max_message_body_size new maximum message body size, in bytes
+ */
+export interface MaxMessageBodySizeUpdated {
+    newMaxMessageBodySize: bigint;
+}
+export interface MaxMessageBodySizeUpdatedProtoMsg {
+    typeUrl: '/circle.cctp.v1.MaxMessageBodySizeUpdated';
+    value: Uint8Array;
+}
+/**
+ * Emitted when max message body size is updated
+ * @param new_max_message_body_size new maximum message body size, in bytes
+ */
+export interface MaxMessageBodySizeUpdatedSDKType {
+    new_max_message_body_size: bigint;
+}
+/**
+ * Emitted when a RemoteTokenMessenger is added
+ * @param domain remote domain
+ * @param remote_token_messenger RemoteTokenMessenger on domain
+ */
+export interface RemoteTokenMessengerAdded {
+    domain: number;
+    remoteTokenMessenger: Uint8Array;
+}
+export interface RemoteTokenMessengerAddedProtoMsg {
+    typeUrl: '/circle.cctp.v1.RemoteTokenMessengerAdded';
+    value: Uint8Array;
+}
+/**
+ * Emitted when a RemoteTokenMessenger is added
+ * @param domain remote domain
+ * @param remote_token_messenger RemoteTokenMessenger on domain
+ */
+export interface RemoteTokenMessengerAddedSDKType {
+    domain: number;
+    remote_token_messenger: Uint8Array;
+}
+/**
+ * Emitted when a RemoteTokenMessenger is removed
+ * @param domain remote domain
+ * @param remote_token_messenger RemoteTokenMessenger on domain
+ */
+export interface RemoteTokenMessengerRemoved {
+    domain: number;
+    remoteTokenMessenger: Uint8Array;
+}
+export interface RemoteTokenMessengerRemovedProtoMsg {
+    typeUrl: '/circle.cctp.v1.RemoteTokenMessengerRemoved';
+    value: Uint8Array;
+}
+/**
+ * Emitted when a RemoteTokenMessenger is removed
+ * @param domain remote domain
+ * @param remote_token_messenger RemoteTokenMessenger on domain
+ */
+export interface RemoteTokenMessengerRemovedSDKType {
+    domain: number;
+    remote_token_messenger: Uint8Array;
+}
+/**
+ * Emitted when max burn amount per message is updated
+ * @param local_token
+ * @param old_amount old max burn amount
+ * @param new_amount new max burn amount
+ */
+export interface SetBurnLimitPerMessage {
+    token: string;
+    burnLimitPerMessage: string;
+}
+export interface SetBurnLimitPerMessageProtoMsg {
+    typeUrl: '/circle.cctp.v1.SetBurnLimitPerMessage';
+    value: Uint8Array;
+}
+/**
+ * Emitted when max burn amount per message is updated
+ * @param local_token
+ * @param old_amount old max burn amount
+ * @param new_amount new max burn amount
+ */
+export interface SetBurnLimitPerMessageSDKType {
+    token: string;
+    burn_limit_per_message: string;
+}
+export declare const AttesterEnabled: {
+    typeUrl: string;
+    encode(message: AttesterEnabled, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AttesterEnabled;
+    fromJSON(object: any): AttesterEnabled;
+    toJSON(message: AttesterEnabled): JsonSafe<AttesterEnabled>;
+    fromPartial(object: Partial<AttesterEnabled>): AttesterEnabled;
+    fromProtoMsg(message: AttesterEnabledProtoMsg): AttesterEnabled;
+    toProto(message: AttesterEnabled): Uint8Array;
+    toProtoMsg(message: AttesterEnabled): AttesterEnabledProtoMsg;
+};
+export declare const AttesterDisabled: {
+    typeUrl: string;
+    encode(message: AttesterDisabled, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AttesterDisabled;
+    fromJSON(object: any): AttesterDisabled;
+    toJSON(message: AttesterDisabled): JsonSafe<AttesterDisabled>;
+    fromPartial(object: Partial<AttesterDisabled>): AttesterDisabled;
+    fromProtoMsg(message: AttesterDisabledProtoMsg): AttesterDisabled;
+    toProto(message: AttesterDisabled): Uint8Array;
+    toProtoMsg(message: AttesterDisabled): AttesterDisabledProtoMsg;
+};
+export declare const SignatureThresholdUpdated: {
+    typeUrl: string;
+    encode(message: SignatureThresholdUpdated, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SignatureThresholdUpdated;
+    fromJSON(object: any): SignatureThresholdUpdated;
+    toJSON(message: SignatureThresholdUpdated): JsonSafe<SignatureThresholdUpdated>;
+    fromPartial(object: Partial<SignatureThresholdUpdated>): SignatureThresholdUpdated;
+    fromProtoMsg(message: SignatureThresholdUpdatedProtoMsg): SignatureThresholdUpdated;
+    toProto(message: SignatureThresholdUpdated): Uint8Array;
+    toProtoMsg(message: SignatureThresholdUpdated): SignatureThresholdUpdatedProtoMsg;
+};
+export declare const OwnerUpdated: {
+    typeUrl: string;
+    encode(message: OwnerUpdated, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): OwnerUpdated;
+    fromJSON(object: any): OwnerUpdated;
+    toJSON(message: OwnerUpdated): JsonSafe<OwnerUpdated>;
+    fromPartial(object: Partial<OwnerUpdated>): OwnerUpdated;
+    fromProtoMsg(message: OwnerUpdatedProtoMsg): OwnerUpdated;
+    toProto(message: OwnerUpdated): Uint8Array;
+    toProtoMsg(message: OwnerUpdated): OwnerUpdatedProtoMsg;
+};
+export declare const OwnershipTransferStarted: {
+    typeUrl: string;
+    encode(message: OwnershipTransferStarted, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): OwnershipTransferStarted;
+    fromJSON(object: any): OwnershipTransferStarted;
+    toJSON(message: OwnershipTransferStarted): JsonSafe<OwnershipTransferStarted>;
+    fromPartial(object: Partial<OwnershipTransferStarted>): OwnershipTransferStarted;
+    fromProtoMsg(message: OwnershipTransferStartedProtoMsg): OwnershipTransferStarted;
+    toProto(message: OwnershipTransferStarted): Uint8Array;
+    toProtoMsg(message: OwnershipTransferStarted): OwnershipTransferStartedProtoMsg;
+};
+export declare const PauserUpdated: {
+    typeUrl: string;
+    encode(message: PauserUpdated, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PauserUpdated;
+    fromJSON(object: any): PauserUpdated;
+    toJSON(message: PauserUpdated): JsonSafe<PauserUpdated>;
+    fromPartial(object: Partial<PauserUpdated>): PauserUpdated;
+    fromProtoMsg(message: PauserUpdatedProtoMsg): PauserUpdated;
+    toProto(message: PauserUpdated): Uint8Array;
+    toProtoMsg(message: PauserUpdated): PauserUpdatedProtoMsg;
+};
+export declare const AttesterManagerUpdated: {
+    typeUrl: string;
+    encode(message: AttesterManagerUpdated, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AttesterManagerUpdated;
+    fromJSON(object: any): AttesterManagerUpdated;
+    toJSON(message: AttesterManagerUpdated): JsonSafe<AttesterManagerUpdated>;
+    fromPartial(object: Partial<AttesterManagerUpdated>): AttesterManagerUpdated;
+    fromProtoMsg(message: AttesterManagerUpdatedProtoMsg): AttesterManagerUpdated;
+    toProto(message: AttesterManagerUpdated): Uint8Array;
+    toProtoMsg(message: AttesterManagerUpdated): AttesterManagerUpdatedProtoMsg;
+};
+export declare const TokenControllerUpdated: {
+    typeUrl: string;
+    encode(message: TokenControllerUpdated, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): TokenControllerUpdated;
+    fromJSON(object: any): TokenControllerUpdated;
+    toJSON(message: TokenControllerUpdated): JsonSafe<TokenControllerUpdated>;
+    fromPartial(object: Partial<TokenControllerUpdated>): TokenControllerUpdated;
+    fromProtoMsg(message: TokenControllerUpdatedProtoMsg): TokenControllerUpdated;
+    toProto(message: TokenControllerUpdated): Uint8Array;
+    toProtoMsg(message: TokenControllerUpdated): TokenControllerUpdatedProtoMsg;
+};
+export declare const BurningAndMintingPausedEvent: {
+    typeUrl: string;
+    encode(_: BurningAndMintingPausedEvent, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BurningAndMintingPausedEvent;
+    fromJSON(_: any): BurningAndMintingPausedEvent;
+    toJSON(_: BurningAndMintingPausedEvent): JsonSafe<BurningAndMintingPausedEvent>;
+    fromPartial(_: Partial<BurningAndMintingPausedEvent>): BurningAndMintingPausedEvent;
+    fromProtoMsg(message: BurningAndMintingPausedEventProtoMsg): BurningAndMintingPausedEvent;
+    toProto(message: BurningAndMintingPausedEvent): Uint8Array;
+    toProtoMsg(message: BurningAndMintingPausedEvent): BurningAndMintingPausedEventProtoMsg;
+};
+export declare const BurningAndMintingUnpausedEvent: {
+    typeUrl: string;
+    encode(_: BurningAndMintingUnpausedEvent, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BurningAndMintingUnpausedEvent;
+    fromJSON(_: any): BurningAndMintingUnpausedEvent;
+    toJSON(_: BurningAndMintingUnpausedEvent): JsonSafe<BurningAndMintingUnpausedEvent>;
+    fromPartial(_: Partial<BurningAndMintingUnpausedEvent>): BurningAndMintingUnpausedEvent;
+    fromProtoMsg(message: BurningAndMintingUnpausedEventProtoMsg): BurningAndMintingUnpausedEvent;
+    toProto(message: BurningAndMintingUnpausedEvent): Uint8Array;
+    toProtoMsg(message: BurningAndMintingUnpausedEvent): BurningAndMintingUnpausedEventProtoMsg;
+};
+export declare const SendingAndReceivingPausedEvent: {
+    typeUrl: string;
+    encode(_: SendingAndReceivingPausedEvent, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SendingAndReceivingPausedEvent;
+    fromJSON(_: any): SendingAndReceivingPausedEvent;
+    toJSON(_: SendingAndReceivingPausedEvent): JsonSafe<SendingAndReceivingPausedEvent>;
+    fromPartial(_: Partial<SendingAndReceivingPausedEvent>): SendingAndReceivingPausedEvent;
+    fromProtoMsg(message: SendingAndReceivingPausedEventProtoMsg): SendingAndReceivingPausedEvent;
+    toProto(message: SendingAndReceivingPausedEvent): Uint8Array;
+    toProtoMsg(message: SendingAndReceivingPausedEvent): SendingAndReceivingPausedEventProtoMsg;
+};
+export declare const SendingAndReceivingUnpausedEvent: {
+    typeUrl: string;
+    encode(_: SendingAndReceivingUnpausedEvent, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SendingAndReceivingUnpausedEvent;
+    fromJSON(_: any): SendingAndReceivingUnpausedEvent;
+    toJSON(_: SendingAndReceivingUnpausedEvent): JsonSafe<SendingAndReceivingUnpausedEvent>;
+    fromPartial(_: Partial<SendingAndReceivingUnpausedEvent>): SendingAndReceivingUnpausedEvent;
+    fromProtoMsg(message: SendingAndReceivingUnpausedEventProtoMsg): SendingAndReceivingUnpausedEvent;
+    toProto(message: SendingAndReceivingUnpausedEvent): Uint8Array;
+    toProtoMsg(message: SendingAndReceivingUnpausedEvent): SendingAndReceivingUnpausedEventProtoMsg;
+};
+export declare const DepositForBurn: {
+    typeUrl: string;
+    encode(message: DepositForBurn, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): DepositForBurn;
+    fromJSON(object: any): DepositForBurn;
+    toJSON(message: DepositForBurn): JsonSafe<DepositForBurn>;
+    fromPartial(object: Partial<DepositForBurn>): DepositForBurn;
+    fromProtoMsg(message: DepositForBurnProtoMsg): DepositForBurn;
+    toProto(message: DepositForBurn): Uint8Array;
+    toProtoMsg(message: DepositForBurn): DepositForBurnProtoMsg;
+};
+export declare const MintAndWithdraw: {
+    typeUrl: string;
+    encode(message: MintAndWithdraw, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MintAndWithdraw;
+    fromJSON(object: any): MintAndWithdraw;
+    toJSON(message: MintAndWithdraw): JsonSafe<MintAndWithdraw>;
+    fromPartial(object: Partial<MintAndWithdraw>): MintAndWithdraw;
+    fromProtoMsg(message: MintAndWithdrawProtoMsg): MintAndWithdraw;
+    toProto(message: MintAndWithdraw): Uint8Array;
+    toProtoMsg(message: MintAndWithdraw): MintAndWithdrawProtoMsg;
+};
+export declare const TokenPairLinked: {
+    typeUrl: string;
+    encode(message: TokenPairLinked, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): TokenPairLinked;
+    fromJSON(object: any): TokenPairLinked;
+    toJSON(message: TokenPairLinked): JsonSafe<TokenPairLinked>;
+    fromPartial(object: Partial<TokenPairLinked>): TokenPairLinked;
+    fromProtoMsg(message: TokenPairLinkedProtoMsg): TokenPairLinked;
+    toProto(message: TokenPairLinked): Uint8Array;
+    toProtoMsg(message: TokenPairLinked): TokenPairLinkedProtoMsg;
+};
+export declare const TokenPairUnlinked: {
+    typeUrl: string;
+    encode(message: TokenPairUnlinked, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): TokenPairUnlinked;
+    fromJSON(object: any): TokenPairUnlinked;
+    toJSON(message: TokenPairUnlinked): JsonSafe<TokenPairUnlinked>;
+    fromPartial(object: Partial<TokenPairUnlinked>): TokenPairUnlinked;
+    fromProtoMsg(message: TokenPairUnlinkedProtoMsg): TokenPairUnlinked;
+    toProto(message: TokenPairUnlinked): Uint8Array;
+    toProtoMsg(message: TokenPairUnlinked): TokenPairUnlinkedProtoMsg;
+};
+export declare const MessageSent: {
+    typeUrl: string;
+    encode(message: MessageSent, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MessageSent;
+    fromJSON(object: any): MessageSent;
+    toJSON(message: MessageSent): JsonSafe<MessageSent>;
+    fromPartial(object: Partial<MessageSent>): MessageSent;
+    fromProtoMsg(message: MessageSentProtoMsg): MessageSent;
+    toProto(message: MessageSent): Uint8Array;
+    toProtoMsg(message: MessageSent): MessageSentProtoMsg;
+};
+export declare const MessageReceived: {
+    typeUrl: string;
+    encode(message: MessageReceived, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MessageReceived;
+    fromJSON(object: any): MessageReceived;
+    toJSON(message: MessageReceived): JsonSafe<MessageReceived>;
+    fromPartial(object: Partial<MessageReceived>): MessageReceived;
+    fromProtoMsg(message: MessageReceivedProtoMsg): MessageReceived;
+    toProto(message: MessageReceived): Uint8Array;
+    toProtoMsg(message: MessageReceived): MessageReceivedProtoMsg;
+};
+export declare const MaxMessageBodySizeUpdated: {
+    typeUrl: string;
+    encode(message: MaxMessageBodySizeUpdated, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MaxMessageBodySizeUpdated;
+    fromJSON(object: any): MaxMessageBodySizeUpdated;
+    toJSON(message: MaxMessageBodySizeUpdated): JsonSafe<MaxMessageBodySizeUpdated>;
+    fromPartial(object: Partial<MaxMessageBodySizeUpdated>): MaxMessageBodySizeUpdated;
+    fromProtoMsg(message: MaxMessageBodySizeUpdatedProtoMsg): MaxMessageBodySizeUpdated;
+    toProto(message: MaxMessageBodySizeUpdated): Uint8Array;
+    toProtoMsg(message: MaxMessageBodySizeUpdated): MaxMessageBodySizeUpdatedProtoMsg;
+};
+export declare const RemoteTokenMessengerAdded: {
+    typeUrl: string;
+    encode(message: RemoteTokenMessengerAdded, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RemoteTokenMessengerAdded;
+    fromJSON(object: any): RemoteTokenMessengerAdded;
+    toJSON(message: RemoteTokenMessengerAdded): JsonSafe<RemoteTokenMessengerAdded>;
+    fromPartial(object: Partial<RemoteTokenMessengerAdded>): RemoteTokenMessengerAdded;
+    fromProtoMsg(message: RemoteTokenMessengerAddedProtoMsg): RemoteTokenMessengerAdded;
+    toProto(message: RemoteTokenMessengerAdded): Uint8Array;
+    toProtoMsg(message: RemoteTokenMessengerAdded): RemoteTokenMessengerAddedProtoMsg;
+};
+export declare const RemoteTokenMessengerRemoved: {
+    typeUrl: string;
+    encode(message: RemoteTokenMessengerRemoved, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RemoteTokenMessengerRemoved;
+    fromJSON(object: any): RemoteTokenMessengerRemoved;
+    toJSON(message: RemoteTokenMessengerRemoved): JsonSafe<RemoteTokenMessengerRemoved>;
+    fromPartial(object: Partial<RemoteTokenMessengerRemoved>): RemoteTokenMessengerRemoved;
+    fromProtoMsg(message: RemoteTokenMessengerRemovedProtoMsg): RemoteTokenMessengerRemoved;
+    toProto(message: RemoteTokenMessengerRemoved): Uint8Array;
+    toProtoMsg(message: RemoteTokenMessengerRemoved): RemoteTokenMessengerRemovedProtoMsg;
+};
+export declare const SetBurnLimitPerMessage: {
+    typeUrl: string;
+    encode(message: SetBurnLimitPerMessage, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SetBurnLimitPerMessage;
+    fromJSON(object: any): SetBurnLimitPerMessage;
+    toJSON(message: SetBurnLimitPerMessage): JsonSafe<SetBurnLimitPerMessage>;
+    fromPartial(object: Partial<SetBurnLimitPerMessage>): SetBurnLimitPerMessage;
+    fromProtoMsg(message: SetBurnLimitPerMessageProtoMsg): SetBurnLimitPerMessage;
+    toProto(message: SetBurnLimitPerMessage): Uint8Array;
+    toProtoMsg(message: SetBurnLimitPerMessage): SetBurnLimitPerMessageProtoMsg;
+};