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: "/circle.cctp.v1.AttesterEnabled";
    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: "/circle.cctp.v1.AttesterDisabled";
    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: "/circle.cctp.v1.SignatureThresholdUpdated";
    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: "/circle.cctp.v1.OwnerUpdated";
    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: "/circle.cctp.v1.OwnershipTransferStarted";
    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: "/circle.cctp.v1.PauserUpdated";
    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: "/circle.cctp.v1.AttesterManagerUpdated";
    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: "/circle.cctp.v1.TokenControllerUpdated";
    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: "/circle.cctp.v1.BurningAndMintingPausedEvent";
    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: "/circle.cctp.v1.BurningAndMintingUnpausedEvent";
    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: "/circle.cctp.v1.SendingAndReceivingPausedEvent";
    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: "/circle.cctp.v1.SendingAndReceivingUnpausedEvent";
    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: "/circle.cctp.v1.DepositForBurn";
    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: "/circle.cctp.v1.MintAndWithdraw";
    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: "/circle.cctp.v1.TokenPairLinked";
    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: "/circle.cctp.v1.TokenPairUnlinked";
    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: "/circle.cctp.v1.MessageSent";
    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: "/circle.cctp.v1.MessageReceived";
    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: "/circle.cctp.v1.MaxMessageBodySizeUpdated";
    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: "/circle.cctp.v1.RemoteTokenMessengerAdded";
    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: "/circle.cctp.v1.RemoteTokenMessengerRemoved";
    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: "/circle.cctp.v1.SetBurnLimitPerMessage";
    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;
};
//# sourceMappingURL=events.d.ts.map