import { SuiClient, SuiObjectResponse, SuiTransactionBlockResponse, ObjectOwner } from '@mysten/sui/client';
import { TransactionArgument, Transaction, TransactionResult } from '@mysten/sui/transactions';
import { Chain, Stage, EndpointId } from '@layerzerolabs/lz-definitions';
import { Keypair } from '@mysten/sui/cryptography';
import * as _mysten_sui_dist_cjs_bcs from '@mysten/sui/dist/cjs/bcs';
import * as _store__mysten_bcs_npm_1_6_3_20c656f643_package from '.store/@mysten-bcs-npm-1.6.3-20c656f643/package';

/**
 * Type representing the options for packages.
 */
interface PackageOptions {
    /**
     * The endpoint V2 address.
     */
    endpointV2: string;
    /**
     * The zro address.
     */
    zro: string;
    /**
     * The utils address.
     */
    utils: string;
    /**
     * The call address.
     */
    call: string;
    /**
     * The simple message library address.
     */
    simpleMessageLib: string;
    /**
     * The ULN-302 address.
     */
    uln302: string;
    /**
     * The treasury address.
     */
    treasury: string;
    /**
     * The common DVN address.
     */
    dvn: string;
    /**
     * The DVN fee lib address.
     */
    dvnFeeLib: string;
    /**
     * The common executor address.
     */
    executor: string;
    /**
     * The executor fee lib address.
     */
    executorFeeLib: string;
    /**
     * The price feed address.
     */
    priceFeed: string;
    /**
     * The common oapp address.
     */
    oapp: string;
    /**
     * The LayerZero Views address.
     */
    layerzeroViews: string;
    /**
     * The dvn layerzero address.
     */
    dvnLayerzero: string;
    /**
     * The executor layerzero address.
     */
    executorLayerzero: string;
    /**
     * The counter V2 address.
     */
    counterV2: string;
    /**
     * The ptb move call address.
     */
    ptbMoveCall: string;
    /**
     * The endpoint PTB builder address.
     */
    endpointPtbBuilder: string;
    /**
     * The simple message lib PTB builder address.
     */
    simpleMessageLibPtbBuilder: string;
    /**
     * The ULN-302 PTB builder address.
     */
    uln302PtbBuilder: string;
    /**
     * The DVN PTB builder address.
     */
    dvnPtbBuilder: string;
    /**
     * The executor PTB builder address.
     */
    executorPtbBuilder: string;
    /**
     * The package whitelist validator address.
     */
    packageWhitelistValidator: string;
    /**
     * The blocked message library object address.
     */
    blockedMessageLib: string;
    /**
     * The blocked message library PTB builder object address.
     */
    blockedMessageLibPtbBuilder: string;
    /**
     * The worker registry address.
     */
    workerRegistry: string;
    /**
     * The worker common address.
     */
    workerCommon: string;
    /**
     * Allow additional properties beyond the explicitly defined ones
     */
    [key: string]: any;
}
/**
 * Type representing the options for objects.
 */
interface ObjectOptions {
    /**
     * The endpoint V2 object address.
     */
    endpointV2: string;
    /**
     * The simple message library object address.
     */
    simpleMessageLib: string;
    /**
     * The simple message library cap object address.
     */
    simpleMessageLibAdminCap: string;
    /**
     * The simple message library PTB builder object address.
     */
    simpleMessageLibPtbBuilder: string;
    /**
     * The ULN-302 message library object address.
     */
    uln302: string;
    /**
     * The ULN-302 admin cap object address.
     */
    uln302AdminCap: string;
    /**
     * The ULN-302 verification object address.
     */
    uln302Verification: string;
    /**
     * The ULN-302 PTB builder object address.
     */
    uln302PtbBuilder: string;
    /**
     * The treasury object address.
     */
    treasury: string;
    /**
     * The treasury admin cap object address.
     */
    treasuryAdminCap: string;
    /**
     * The blocked message library object address.
     */
    blockedMessageLib: string;
    /**
     * The blocked message library PTB builder object address.
     */
    blockedMessageLibPtbBuilder: string;
    /**
     * The counter admin cap object address.
     */
    counterAdminCap: string;
    /**
     * The endpoint admin cap object address.
     */
    endpointAdminCap: string;
    /**
     * The endpoint PTB builder object address.
     */
    endpointPtbBuilder: string;
    /**
     * The endpoint PTB builder admin cap object address.
     */
    endpointPtbBuilderAdminCap: string;
    /**
     * The default DVN object address.
     */
    dvn: string;
    /**
     * The default DVN callCap object address, used in init_dvn move call
     */
    dvnCap: string;
    /**
     * The default DVN fee lib object address.
     */
    dvnFeeLib: string;
    /**
     * The default executor object address.
     */
    executor: string;
    /**
     * The default executor callCap object address, used in init_executor move call
     */
    executorCap: string;
    /**
     * The default executor owner cap object address.
     */
    executorOwnerCap: string;
    /**
     * The default executor fee lib object address.
     */
    executorFeeLib: string;
    /**
     * The default price feed object address.
     */
    priceFeed: string;
    /**
     * The default price feed owner cap object address.
     */
    priceFeedOwnerCap: string;
    /**
     * The counter OApp object address.
     */
    counter: string;
    /**
     * The OApp core object address.
     */
    counterOapp: string;
    /**
     * The default package whitelist validator object address.
     */
    packageWhitelistValidator: string;
    /**
     * The worker registry object address.
     */
    workerRegistry: string;
    /**
     * Allow additional properties beyond the explicitly defined ones
     */
    [key: string]: any;
}
/**
 * Module options for customizing module creation
 */
interface ModuleOptions {
    /** Custom package ID to use instead of default */
    packageId: string;
    /** Custom objects configuration to use instead of default */
    objects: Partial<ObjectOptions>;
}
/**
 * Options for initializing the SDK.
 */
interface SdkOptions {
    /** The chain for the SDK (default: Chain.SUI) */
    chain?: Chain;
    /** The Sui client for the SDK */
    client: SuiClient;
    /** The stage of the SDK (default: Stage.MAINNET) */
    stage?: Stage;
    /** Custom package addresses to override defaults */
    packages?: Partial<PackageOptions>;
    /** Custom object addresses to override defaults */
    objects?: Partial<ObjectOptions>;
}

/**
 * Enum containing all available SDK modules
 * Keys are capitalized, values match the actual module names used in the system
 */
declare enum Modules {
    Endpoint = "endpoint",
    SimpleMessageLib = "simpleMessageLib",
    BlockedMessageLib = "blockedMessageLib",
    Uln302 = "uln302",
    Utils = "utils",
    Zro = "zro",
    Call = "call",
    Treasury = "treasury",
    LayerZeroViews = "layerZeroViews",
    PtbBuilder = "ptbBuilder",
    EndpointPtbBuilder = "endpointPtbBuilder",
    SimpleMessageLibPtbBuilder = "simpleMessageLibPtbBuilder",
    BlockedMessageLibPtbBuilder = "blockedMessageLibPtbBuilder",
    Uln302PtbBuilder = "uln302PtbBuilder",
    Oapp = "oapp",
    Dvn = "dvn",
    DvnFeeLib = "dvnFeeLib",
    DvnLayerZero = "dvnLayerZero",
    Executor = "executor",
    ExecutorFeeLib = "executorFeeLib",
    ExecutorLayerZero = "executorLayerZero",
    PackageWhitelistValidator = "packageWhitelistValidator",
    PriceFeed = "priceFeed",
    Counter = "counter",
    DvnPtbBuilder = "dvnPtbBuilder",
    ExecutorPtbBuilder = "executorPtbBuilder",
    WorkerRegistry = "workerRegistry"
}

/**
 * Simulation-related type definitions
 */
interface SimulateResult {
    value: Uint8Array;
    type: string;
}

interface DvnDstConfig {
    gas: bigint;
    multiplierBps: number;
    floorMarginUsd: bigint;
}
interface VerifierFeePaid {
    dvn: string;
    fee: bigint;
}
interface SetDstConfigEvent {
    dvn: string;
    dstEid: number;
    gas: bigint;
    multiplierBps: number;
    floorMarginUsd: bigint;
}

declare class MoveAbortError extends Error {
    readonly abortCode: number;
    constructor(abortCode: number, rawMsg: string);
}
declare class UnclassifiedError extends Error {
}

interface DstConfig {
    lzReceiveBaseGas: bigint;
    lzComposeBaseGas: bigint;
    multiplierBps: number;
    floorMarginUsd: bigint;
    nativeCap: bigint;
}
interface NativeDropParams {
    receiver: string;
    amount: bigint;
}
declare const ExecutorOptionType: {
    readonly LZRECEIVE: 1;
    readonly NATIVE_DROP: 2;
    readonly LZCOMPOSE: 3;
    readonly ORDERED_EXECUTION: 4;
};
declare const ALL_EXECUTOR_OPTION_TYPES: (1 | 2 | 3 | 4)[];

interface MoveCall {
    function: Function;
    arguments: Argument[];
    type_arguments: string[];
    result_ids: Uint8Array[];
    is_builder_call: boolean;
}
interface Function {
    package: string;
    module_name: string;
    name: string;
}
type Argument = {
    ID: Uint8Array;
} | {
    Object: string;
} | {
    Pure: Uint8Array;
} | {
    NestedResult: [number, number];
};
declare const MAX_BATCH_SIZE = 50;
declare const DEFAULT_SIMULATION_TIMES = 5;
interface BuilderPlaceholderInfo {
    index: number;
    moveCallCount: number;
}

declare enum ModelType {
    DEFAULT = 0,
    ARB_STACK = 1,
    OP_STACK = 2
}
interface Price {
    priceRatio: bigint;
    gasPriceInUnit: bigint;
    gasPerByte: number;
}
interface ArbitrumPriceExt {
    gasPerL2Tx: bigint;
    gasPerL1CallDataByte: number;
}

declare enum MessageLibType {
    Send = 0,
    Receive = 1,
    SendAndReceive = 2
}
declare const CONFIG_TYPE: {
    readonly EXECUTOR: 1;
    readonly SEND_ULN: 2;
    readonly RECEIVE_ULN: 3;
};
interface ExecutorConfig {
    maxMessageSize: number;
    executor: string;
}
interface UlnConfig {
    confirmations: bigint;
    requiredDvns: string[];
    optionalDvns: string[];
    optionalDvnThreshold: number;
}
interface OAppUlnConfig {
    useDefaultConfirmations: boolean;
    useDefaultRequiredDvns: boolean;
    useDefaultOptionalDvns: boolean;
    ulnConfig: UlnConfig;
}
interface VersionInfo {
    major: bigint;
    minor: number;
    endpointVersion: number;
}

declare enum LzTypeName {
    EndpointQuoteParam = "EndpointQuoteParam",
    EndpointSendParam = "EndpointSendParam",
    MessageLibQuoteParam = "MessageLibQuoteParam",
    MessageLibSendParam = "MessageLibSendParam",
    MessageLibSetConfigParam = "MessageLibSetConfigParam",
    MessagingFee = "MessagingFee",
    MessagingReceipt = "MessagingReceipt",
    MoveCall = "MoveCall",
    EndpointLzReceiveParam = "EndpointLzReceiveParam",
    EndpointLzComposeParam = "EndpointLzComposeParam",
    CallVoid = "CallVoid",
    MessageLibSendResult = "MessageLibSendResult"
}
declare enum CallTypeName {
    EndpointQuoteCall = "EndpointQuoteCall",
    EndpointSendCall = "EndpointSendCall",
    MessageLibSendCall = "MessageLibSendCall",
    MessageLibQuoteCall = "MessageLibQuoteCall",
    MessageLibSetConfigCall = "MessageLibSetConfigCall",
    EndpointLzReceiveCall = "EndpointLzReceiveCall",
    EndpointLzComposeCall = "EndpointLzComposeCall"
}

declare const EndpointExecutionState: {
    readonly STATE_NOT_EXECUTABLE: 0;
    readonly STATE_VERIFIED_BUT_NOT_EXECUTABLE: 1;
    readonly STATE_EXECUTABLE: 2;
    readonly STATE_EXECUTED: 3;
};
declare const UlnVerificationState: {
    readonly STATE_VERIFYING: 0;
    readonly STATE_VERIFIABLE: 1;
    readonly STATE_VERIFIED: 2;
    readonly STATE_NOT_INITIALIZABLE: 3;
};
type EndpointExecutionStateType = (typeof EndpointExecutionState)[keyof typeof EndpointExecutionState];
type UlnVerificationStateType = (typeof UlnVerificationState)[keyof typeof UlnVerificationState];

/**
 * Parameters for checking message executability
 */
interface ExecutableParams {
    messagingChannel: string | TransactionArgument;
    srcEid: number | TransactionArgument;
    sender: Uint8Array | TransactionArgument;
    nonce: bigint | TransactionArgument;
}
/**
 * Parameters for checking message initializability
 */
interface InitializableParams {
    messagingChannel: string | TransactionArgument;
    srcEid: number | TransactionArgument;
    sender: Uint8Array | TransactionArgument;
}
/**
 * Parameters for checking message verifiability by endpoint
 */
interface VerifiableParams {
    messagingChannel: string | TransactionArgument;
    srcEid: number | TransactionArgument;
    sender: Uint8Array | TransactionArgument;
    nonce: bigint | TransactionArgument;
}
/**
 * Parameters for checking ULN verification state
 */
interface UlnVerifiableParams {
    verification: string | TransactionArgument;
    messagingChannel: string | TransactionArgument;
    packetHeaderBytes: Uint8Array | TransactionArgument;
    payloadHash: Uint8Array | TransactionArgument;
}

interface MessagingFee {
    nativeFee: bigint;
    zroFee: bigint;
}
interface Timeout {
    expiry: bigint;
    fallbackLib: string;
}
/**
 * LayerZero protocol version constants
 */
declare const OAppInfoVersion: {
    readonly VERSION_1: 1;
    readonly VERSION_2: 2;
};
declare const LzReceiveVersion: {
    readonly VERSION_1: 1;
};
declare const LzComposeVersion: {
    readonly VERSION_1: 1;
};

/**
 * Module Manager - Centralized management for all SDK modules
 * Uses unified storage for both core modules and cached modules with options
 */
declare class ModuleManager {
    packages: PackageOptions;
    objects: ObjectOptions;
    private storage;
    constructor(packages: PackageOptions, objects: ObjectOptions);
    /**
     * Generate a cache key using hash for modules with options
     */
    private generateCacheKey;
    private setCoreModules;
    /**
     * Get module instance (with options), throws error if not found
     */
    getModule<T>(moduleName: string, options?: ModuleOptions): T;
    /**
     * Store module instance (with options)
     */
    setModule<T>(moduleName: string, options: ModuleOptions | undefined, instance: T): void;
    /**
     * Check if module (with options) exists
     */
    hasModule(moduleName: string, options?: ModuleOptions): boolean;
    /**
     * Get module instance or create new one using factory function
     */
    getOrCreateModule<T>(moduleName: string, options: ModuleOptions | undefined, factory: () => T): T;
    /**
     * Get all core modules as an object
     */
    getAllCoreModules(): {
        [key: string]: unknown;
    };
    /**
     * Clear all modules and cache
     */
    clear(): void;
    /**
     * Remove a module with specific options
     */
    removeModule(moduleName: string, options?: ModuleOptions): boolean;
    /**
     * Initialize all standard LayerZero modules
     * @param packages - Package addresses configuration
     * @param objects - Object addresses configuration
     * @param client - Sui client instance
     * @param context - Context object to be populated with module references
     */
    initializeCoreModules(packages: PackageOptions, objects: ObjectOptions, client: SuiClient): void;
    getEndpoint(): Endpoint;
    getSimpleMessageLib(): SimpleMessageLib;
    getBlockedMessageLib(): BlockedMessageLib;
    getUln302(): Uln302;
    getUtils(): Utils;
    getZro(): Zro;
    getCall(): Call;
    getTreasury(): Treasury;
    getLayerZeroViews(): LayerZeroViews;
    getPtbBuilder(): PtbBuilder;
    getOApp(client: SuiClient, callCapId: string, options?: ModuleOptions): OApp;
    getCounter(client: SuiClient, options?: ModuleOptions): Counter;
    getExecutor(client: SuiClient, options?: ModuleOptions): Executor;
    getDvn(client: SuiClient, options?: ModuleOptions): DVN;
    getDvnFeeLib(client: SuiClient, options?: ModuleOptions): DVNFeeLib;
    getExecutorFeeLib(client: SuiClient, options?: ModuleOptions): ExecutorFeeLib;
    getPriceFeed(client: SuiClient, options?: ModuleOptions): PriceFeed;
    getDvnLayerZero(client: SuiClient, options?: ModuleOptions): DvnLayerZero;
    getExecutorLayerZero(client: SuiClient, options?: ModuleOptions): ExecutorLayerZero;
    getDvnPtbBuilder(client: SuiClient, options?: ModuleOptions): DvnPtbBuilder;
    getExecutorPtbBuilder(client: SuiClient, options?: ModuleOptions): ExecutorPtbBuilder;
    getPackageWhitelistValidator(client: SuiClient, options?: ModuleOptions): PackageWhitelistValidator;
    getUln302PtbBuilder(client: SuiClient, options?: ModuleOptions): Uln302PtbBuilder;
    getEndpointPtbBuilder(client: SuiClient, options?: ModuleOptions): EndpointPtbBuilder;
    getSimpleMessageLibPtbBuilder(client: SuiClient, options?: ModuleOptions): SimpleMessageLibPtbBuilder;
    getBlockedMessageLibPtbBuilder(client: SuiClient, options?: ModuleOptions): BlockedMessageLibPtbBuilder;
    getWorkerRegistry(client: SuiClient, options?: ModuleOptions): WorkerRegistry;
    /**
     * Merge objects configuration with options, avoiding unnecessary object spreading
     */
    private mergeObjectsOptions;
}

/**
 * Represents a move call with its associated object details
 */
interface MoveCallWithObjectDetails {
    moveCall: MoveCall;
    objectDetails: Map<string, SuiObjectResponse>;
}

interface ObjectFetchOptions {
    showOwner?: boolean;
    showType?: boolean;
    showContent?: boolean;
    showBcs?: boolean;
    showDisplay?: boolean;
    showStorageRebate?: boolean;
}
interface IPTBValidator {
    validate(moveCallsWithDetails: MoveCallWithObjectDetails[], sender?: string): void | Promise<void>;
}

declare const EndpointErrorCode: {
    readonly MessageLibManager_EAlreadyRegistered: 1;
    readonly MessageLibManager_EDefaultReceiveLibUnavailable: 2;
    readonly MessageLibManager_EDefaultSendLibUnavailable: 3;
    readonly MessageLibManager_EInvalidAddress: 4;
    readonly MessageLibManager_EInvalidBounds: 5;
    readonly MessageLibManager_EInvalidExpiry: 6;
    readonly MessageLibManager_EInvalidReceiveLib: 7;
    readonly MessageLibManager_EOnlyNonDefaultLib: 8;
    readonly MessageLibManager_EOnlyReceiveLib: 9;
    readonly MessageLibManager_EOnlyRegisteredLib: 10;
    readonly MessageLibManager_EOnlySendLib: 11;
    readonly MessageLibManager_ESameValue: 12;
    readonly MessagingChannel_EAlreadyInitialized: 1;
    readonly MessagingChannel_EInsufficientNativeFee: 2;
    readonly MessagingChannel_EInsufficientZroFee: 3;
    readonly MessagingChannel_EInvalidNonce: 4;
    readonly MessagingChannel_EInvalidOApp: 5;
    readonly MessagingChannel_EInvalidPayloadHash: 6;
    readonly MessagingChannel_ENotSending: 7;
    readonly MessagingChannel_EPathNotVerifiable: 8;
    readonly MessagingChannel_EPayloadHashNotFound: 9;
    readonly MessagingChannel_ESendReentrancy: 10;
    readonly MessagingChannel_EUninitializedChannel: 11;
    readonly MessagingComposer_EComposeExists: 1;
    readonly MessagingComposer_EComposeMessageMismatch: 2;
    readonly MessagingComposer_EComposeNotFound: 3;
    readonly MessagingComposer_EComposerNotRegistered: 4;
    readonly MessagingComposer_EComposerRegistered: 5;
    readonly OAppRegistry_EOAppNotRegistered: 1;
    readonly OAppRegistry_EOAppRegistered: 2;
    readonly Endpoint_EAlreadyInitialized: 1;
    readonly Endpoint_EInvalidEid: 2;
    readonly Endpoint_ENotInitialized: 3;
    readonly Endpoint_ERefundAddressNotFound: 4;
    readonly Endpoint_EUnauthorizedOApp: 5;
    readonly Endpoint_EUnauthorizedSendLibrary: 6;
};
declare class Endpoint {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Initialize the endpoint with an Endpoint ID (EID)
     * @param tx - The transaction to add the move call to
     * @param eid - The endpoint ID to initialize or transaction argument
     */
    initEidMoveCall(tx: Transaction, eid: number | TransactionArgument): void;
    /**
     * Register an OApp with the endpoint
     * @param tx - The transaction to add the move call to
     * @param oappCap - The OApp capability object ID or transaction argument
     * @param oappInfo - OApp information including lz_receive execution information
     * @returns Transaction result containing the messaging channel address
     */
    registerOAppMoveCall(tx: Transaction, oappCap: string | TransactionArgument, oappInfo: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Set a delegate for an OApp
     * @param tx - The transaction to add the move call to
     * @param oappCap - The OApp capability object ID or transaction argument
     * @param newDelegate - The new delegate address or transaction argument
     */
    setDelegateMoveCall(tx: Transaction, oappCap: string | TransactionArgument, newDelegate: string | TransactionArgument): void;
    /**
     * Set OApp information for an OApp
     * @param tx - The transaction to add the move call to
     * @param callerCap - The caller capability object ID or transaction argument
     * @param oapp - The OApp address or transaction argument
     * @param oappInfo - The OApp information including lz_receive execution information as bytes or transaction argument
     */
    setOappInfoMoveCall(tx: Transaction, callerCap: string | TransactionArgument, oapp: string | TransactionArgument, oappInfo: Uint8Array | TransactionArgument): void;
    /**
     * Initialize a messaging channel between local and remote OApps
     * @param tx - The transaction to add the move call to
     * @param callerCap - The caller capability object ID or transaction argument
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param remoteEid - The remote endpoint ID or transaction argument
     * @param remoteOapp - The remote OApp address as bytes or transaction argument
     */
    initChannelMoveCall(tx: Transaction, callerCap: string | TransactionArgument, messagingChannel: string | TransactionArgument, remoteEid: number | TransactionArgument, remoteOapp: Uint8Array | TransactionArgument): void;
    /**
     * Quote the messaging fee for sending a message
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param call - The call transaction result
     * @returns Transaction result containing the quote
     */
    quoteMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, call: TransactionArgument): TransactionResult;
    /**
     * Confirm quote operation with message library
     * @param tx - The transaction to add the move call to
     * @param endpointCall - The endpoint call transaction result or transaction argument
     * @param messageLibCall - The message library call transaction result or transaction argument
     */
    confirmQuoteMoveCall(tx: Transaction, endpointCall: TransactionArgument, messageLibCall: TransactionArgument): void;
    /**
     * Send a message through the messaging channel
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param call - The call transaction result
     * @returns Transaction result containing the send operation
     */
    sendMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, call: TransactionArgument): TransactionResult;
    /**
     * Confirm send operation with send library
     * @param tx - The transaction to add the move call to
     * @param sendLibrary - The send library object ID or transaction argument
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param endpointCall - The endpoint call transaction result
     * @param sendLibraryCall - The send library call transaction result
     * @returns Transaction result containing the confirmed send operation
     */
    confirmSendMoveCall(tx: Transaction, sendLibrary: string | TransactionArgument, messagingChannel: string | TransactionArgument, endpointCall: TransactionArgument, sendLibraryCall: TransactionArgument): TransactionResult;
    /**
     * Refund fees from a send operation
     * @param tx - The transaction to add the move call to
     * @param sendCall - The send call transaction result or transaction argument
     * @returns Transaction result containing the refund operation
     */
    refundMoveCall(tx: Transaction, sendCall: TransactionArgument): void;
    /**
     * Verify a message from another chain
     * @param tx - The transaction to add the move call to
     * @param receiveLibrary - The receive library object ID or transaction argument
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - The source endpoint ID or transaction argument
     * @param sender - The sender address as bytes or transaction argument
     * @param nonce - The message nonce or transaction argument
     * @param payloadHash - The payload hash as bytes or transaction argument
     */
    verifyMoveCall(tx: Transaction, receiveLibrary: string | TransactionArgument, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): void;
    /**
     * Clear a verified message by executing it
     * @param tx - The transaction to add the move call to
     * @param caller - The caller object ID or transaction argument
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     * @param guid - Globally unique identifier as bytes or transaction argument
     * @param message - Message payload as bytes or transaction argument
     */
    clearMoveCall(tx: Transaction, caller: string | TransactionArgument, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, guid: Uint8Array | TransactionArgument, message: Uint8Array | TransactionArgument): void;
    /**
     * Skip a message (mark as processed without execution)
     * @param tx - The transaction to add the move call to
     * @param caller - The caller object ID or transaction argument
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     */
    skipMoveCall(tx: Transaction, caller: string | TransactionArgument, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument): void;
    /**
     * Nilify a message (clear without execution)
     * @param tx - The transaction to add the move call to
     * @param caller - The caller object ID or transaction argument
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     * @param payloadHash - Message payload hash as bytes or transaction argument
     */
    nilifyMoveCall(tx: Transaction, caller: string | TransactionArgument, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): void;
    /**
     * Burn a message (permanently remove)
     * @param tx - The transaction to add the move call to
     * @param caller - The caller object ID or transaction argument
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     * @param payloadHash - Message payload hash as bytes or transaction argument
     */
    burnMoveCall(tx: Transaction, caller: string | TransactionArgument, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): void;
    /**
     * Execute a LayerZero receive operation
     * @param tx - The transaction to add the move call to
     * @param executorCallCap - The executor call capability
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - The source endpoint ID or transaction argument
     * @param sender - The sender address as bytes or transaction argument
     * @param nonce - The message nonce or transaction argument
     * @param guid - The globally unique identifier as bytes or transaction argument
     * @param message - The message payload as bytes or transaction argument
     * @param extraData - Additional data as bytes or transaction argument (optional)
     * @param value - The native token value to transfer or transaction argument
     * @returns Transaction result containing the receive operation
     */
    lzReceiveMoveCall(tx: Transaction, executorCallCap: TransactionArgument, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, guid: Uint8Array | TransactionArgument, message: Uint8Array | TransactionArgument, extraData: Uint8Array | TransactionArgument | undefined, value: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Send alert for failed LayerZero receive operation
     * @param tx - The transaction to add the move call to
     * @param executor - The executor object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     * @param receiver - Receiver address or transaction argument
     * @param guid - Globally unique identifier as bytes or transaction argument
     * @param gas - Gas amount for execution or transaction argument
     * @param value - Native token value or transaction argument
     * @param message - Message payload as bytes or transaction argument
     * @param extraData - Additional execution data as bytes or transaction argument
     * @param reason - Failure reason or transaction argument
     */
    lzReceiveAlertMoveCall(tx: Transaction, executor: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, receiver: string | TransactionArgument, guid: Uint8Array | TransactionArgument, gas: bigint | number | string | TransactionArgument, value: bigint | number | string | TransactionArgument, message: Uint8Array | TransactionArgument, extraData: Uint8Array | TransactionArgument, reason: string | TransactionArgument): void;
    /**
     * Register a composer with the endpoint
     * @param tx - The transaction to add the move call to
     * @param composerCap - The composer capability object ID or transaction argument
     * @param composerInfo - Composer information including lz_compose execution information as bytes
     * @returns Transaction result containing the compose queue address
     */
    registerComposerMoveCall(tx: Transaction, composerCap: string | TransactionArgument, composerInfo: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Set composer information for a composer
     * @param tx - The transaction to add the move call to
     * @param composerCap - The composer capability object ID or transaction argument
     * @param composerInfo - Composer information including lz_compose execution information as bytes or transaction argument
     */
    setComposerInfoMoveCall(tx: Transaction, composerCap: string | TransactionArgument, composerInfo: Uint8Array | TransactionArgument): void;
    /**
     * Send compose message to queue
     * @param tx - The transaction to add the move call to
     * @param from - The sender object ID or transaction argument
     * @param composeQueue - The compose queue object ID or transaction argument
     * @param guid - Globally unique identifier as bytes or transaction argument
     * @param index - Compose message index or transaction argument
     * @param message - Message payload as bytes or transaction argument
     */
    sendComposeMoveCall(tx: Transaction, from: string | TransactionArgument, composeQueue: string | TransactionArgument, guid: Uint8Array | TransactionArgument, index: number | TransactionArgument, message: Uint8Array | TransactionArgument): void;
    /**
     * Execute LayerZero compose operation
     * @param tx - The transaction to add the move call to
     * @param executorCallCap - The executor call capability
     * @param composeQueue - The compose queue object ID or transaction argument
     * @param from - Source address or transaction argument
     * @param guid - Globally unique identifier as bytes or transaction argument
     * @param index - Compose message index or transaction argument
     * @param message - Message payload as bytes or transaction argument
     * @param extraData - Additional execution data as bytes or transaction argument (optional)
     * @param value - Native token value to transfer or transaction argument
     * @returns Transaction result containing the compose operation
     */
    lzComposeMoveCall(tx: Transaction, executorCallCap: TransactionArgument, composeQueue: string | TransactionArgument, from: string | TransactionArgument, guid: Uint8Array | TransactionArgument, index: number | TransactionArgument, message: Uint8Array | TransactionArgument, extraData: Uint8Array | TransactionArgument | undefined, value: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Send alert for failed LayerZero compose operation
     * @param tx - The transaction to add the move call to
     * @param executor - The executor object ID or transaction argument
     * @param from - Source address or transaction argument
     * @param to - Destination address or transaction argument
     * @param guid - Globally unique identifier as bytes or transaction argument
     * @param index - Compose message index or transaction argument
     * @param gas - Gas amount for execution or transaction argument
     * @param value - Native token value or transaction argument
     * @param message - Message payload as bytes or transaction argument
     * @param extraData - Additional execution data as bytes or transaction argument
     * @param reason - Failure reason or transaction argument
     */
    lzComposeAlertMoveCall(tx: Transaction, executor: string | TransactionArgument, from: string | TransactionArgument, to: string | TransactionArgument, guid: Uint8Array | TransactionArgument, index: number | TransactionArgument, gas: bigint | number | string | TransactionArgument, value: bigint | number | string | TransactionArgument, message: Uint8Array | TransactionArgument, extraData: Uint8Array | TransactionArgument, reason: string | TransactionArgument): void;
    /**
     * Set the send library for an OApp to a specific destination
     * @param tx - The transaction to add the move call to
     * @param caller - The caller capability object ID or transaction argument
     * @param sender - The sender OApp address or transaction argument
     * @param dstEid - The destination endpoint ID or transaction argument
     * @param newLib - The new send library address or transaction argument
     */
    setSendLibraryMoveCall(tx: Transaction, caller: string | TransactionArgument, sender: string | TransactionArgument, dstEid: number | TransactionArgument, newLib: string | TransactionArgument): void;
    /**
     * Set the receive library for an OApp from a specific source
     * @param tx - The transaction to add the move call to
     * @param caller - The caller capability object ID or transaction argument
     * @param receiver - The receiver OApp address or transaction argument
     * @param srcEid - The source endpoint ID or transaction argument
     * @param newLib - The new receive library address or transaction argument
     * @param gracePeriod - The grace period in seconds or transaction argument
     */
    setReceiveLibraryMoveCall(tx: Transaction, caller: string | TransactionArgument, receiver: string | TransactionArgument, srcEid: number | TransactionArgument, newLib: string | TransactionArgument, gracePeriod: number | string | bigint | TransactionArgument): void;
    /**
     * Set timeout for receive library transition
     * @param tx - The transaction to add the move call to
     * @param caller - The caller capability object ID or transaction argument
     * @param receiver - The receiver OApp address or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param lib - The library address or transaction argument
     * @param expiry - Timeout expiry timestamp or transaction argument
     */
    setReceiveLibraryTimeoutMoveCall(tx: Transaction, caller: string | TransactionArgument, receiver: string | TransactionArgument, srcEid: number | TransactionArgument, lib: string | TransactionArgument, expiry: number | string | bigint | TransactionArgument): void;
    /**
     * Set configuration for an OApp's message library
     * @param tx - The transaction to add the move call to
     * @param caller - The caller object ID or transaction argument
     * @param oapp - The OApp address or transaction argument
     * @param lib - The message library address or transaction argument
     * @param eid - Endpoint ID or transaction argument
     * @param config_type - Configuration type identifier or transaction argument
     * @param config - Configuration data as bytes or transaction argument
     * @returns Transaction result containing the configuration operation
     */
    setConfigMoveCall(tx: Transaction, caller: string | TransactionArgument, oapp: string | TransactionArgument, lib: string | TransactionArgument, eid: number | TransactionArgument, config_type: number | TransactionArgument, config: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Register a message library with the endpoint (admin only)
     * @param tx - The transaction to add the move call to
     * @param messageLibCap - The message library capability address or transaction argument
     * @param messageLibType - The type of message library (Send, Receive, or SendAndReceive)
     */
    registerLibraryMoveCall(tx: Transaction, messageLibCap: string | TransactionArgument, messageLibType: MessageLibType): void;
    /**
     * Set default send library for a destination EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @param newLib - The new default send library address
     */
    setDefaultSendLibraryMoveCall(tx: Transaction, dstEid: number | TransactionArgument, newLib: string | TransactionArgument): void;
    /**
     * Set default receive library for a source EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param newLib - The new default receive library address
     * @param gracePeriod - Grace period in seconds for library transition
     */
    setDefaultReceiveLibraryMoveCall(tx: Transaction, srcEid: number | TransactionArgument, newLib: string | TransactionArgument, gracePeriod: number | string | bigint | TransactionArgument): void;
    /**
     * Set timeout for default receive library transition (admin only)
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param lib - The library address
     * @param expiry - Timeout expiry timestamp
     */
    setDefaultReceiveLibraryTimeoutMoveCall(tx: Transaction, srcEid: number | TransactionArgument, lib: string | TransactionArgument, expiry: number | string | bigint | TransactionArgument): void;
    /**
     * Create message library type move call
     * @param tx - The transaction to add the move call to
     * @param messageLibType - The message library type enum value
     * @returns Transaction result containing the library type
     */
    messageLibTypeMoveCall(tx: Transaction, messageLibType: MessageLibType): TransactionResult;
    /**
     * Get the Endpoint ID (EID) of the current chain
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the EID
     */
    eidMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the Endpoint ID (EID) of the current chain
     * @returns The endpoint ID, or 0 if not initialized
     */
    eid(): Promise<number>;
    /**
     * Check if an OApp is registered with the endpoint
     * @param tx - The transaction to add the move call to
     * @param oapp - The OApp address to check or transaction argument
     * @returns Transaction result containing the registration status
     */
    isOappRegisteredMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult;
    /**
     * Check if an OApp is registered with the endpoint
     * @param oapp - The OApp address to check
     * @returns True if the OApp is registered, false otherwise
     */
    isOappRegistered(oapp: string): Promise<boolean>;
    /**
     * Get messaging channel for an OApp
     * @param tx - The transaction to add the move call to
     * @param oapp - The OApp address or transaction argument
     * @returns Transaction result containing the messaging channel address
     */
    getMessagingChannelMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult;
    /**
     * Get the messaging channel for an OApp
     * @param oapp - The OApp address
     * @returns The messaging channel address
     */
    getMessagingChannel(oapp: string): Promise<string>;
    /**
     * Get OApp information for an OApp
     * @param tx - The transaction to add the move call to
     * @param oapp - The OApp address or transaction argument
     * @returns Transaction result containing the OApp information including lz_receive execution information
     */
    getOappInfoMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult;
    /**
     * Get OApp information for an OApp
     * @param oapp - The OApp address
     * @returns Promise<Uint8Array> - The OApp information including lz_receive execution information as bytes
     */
    getOappInfo(oapp: string): Promise<Uint8Array>;
    /**
     * Get delegate address for an OApp
     * @param tx - The transaction to add the move call to
     * @param oapp - The OApp address or transaction argument
     * @returns Transaction result containing the delegate address
     */
    getDelegateMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult;
    /**
     * Get delegate address for an OApp
     * @param oapp - The OApp address
     * @returns Promise<string> - The delegate address
     */
    getDelegate(oapp: string): Promise<string>;
    /**
     * Check if a composer is registered with the endpoint
     * @param tx - The transaction to add the move call to
     * @param composer - The composer address or transaction argument
     * @returns Transaction result containing the registration status
     */
    isComposerRegisteredMoveCall(tx: Transaction, composer: string | TransactionArgument): TransactionResult;
    /**
     * Check if a composer is registered with the endpoint
     * @param composer - The composer address
     * @returns Promise<boolean> - True if the composer is registered
     */
    isComposerRegistered(composer: string): Promise<boolean>;
    /**
     * Get compose queue address for a composer
     * @param tx - The transaction to add the move call to
     * @param composer - The composer address or transaction argument
     * @returns Transaction result containing the compose queue address
     */
    getComposeQueueMoveCall(tx: Transaction, composer: string | TransactionArgument): TransactionResult;
    /**
     * Get compose queue address for a composer
     * @param composer - The composer address
     * @returns Promise<string> - The compose queue address
     */
    getComposeQueue(composer: string): Promise<string>;
    /**
     * Get composer information for a registered composer
     * @param tx - The transaction to add the move call to
     * @param composer - The composer address or transaction argument
     * @returns Transaction result containing the composer information
     */
    getComposerInfoMoveCall(tx: Transaction, composer: string | TransactionArgument): TransactionResult;
    /**
     * Get composer information for a registered composer
     * @param composer - The composer address
     * @returns Promise<Uint8Array> - The composer information as bytes
     */
    getComposerInfo(composer: string): Promise<Uint8Array>;
    /**
     * Get composer address from compose queue
     * @param tx - The transaction to add the move call to
     * @param composeQueue - The compose queue object ID or transaction argument
     * @returns Transaction result containing the composer address
     */
    getComposerMoveCall(tx: Transaction, composeQueue: string | TransactionArgument): TransactionResult;
    /**
     * Get composer address from compose queue
     * @param composeQueue - The compose queue object ID
     * @returns Promise<string> - The composer address
     */
    getComposer(composeQueue: string): Promise<string>;
    /**
     * Check if compose message hash exists
     * @param tx - The transaction to add the move call to
     * @param composeQueue - The compose queue object ID
     * @param from - Sender address
     * @param guid - Globally unique identifier as bytes
     * @param index - Compose message index
     * @returns Transaction result containing the message hash existence status
     */
    hasComposeMessageHashMoveCall(tx: Transaction, composeQueue: string | TransactionArgument, from: string | TransactionArgument, guid: Uint8Array | TransactionArgument, index: number | TransactionArgument): TransactionResult;
    /**
     * Check if compose message hash exists
     * @param composeQueue - The compose queue object ID
     * @param from - Sender address
     * @param guid - Globally unique identifier as bytes
     * @param index - Compose message index
     * @returns Promise<boolean> - True if message hash exists
     */
    hasComposeMessageHash(composeQueue: string, from: string, guid: Uint8Array, index: number): Promise<boolean>;
    /**
     * Get compose message hash
     * @param tx - The transaction to add the move call to
     * @param composeQueue - The compose queue object ID
     * @param from - Sender address
     * @param guid - Globally unique identifier as bytes
     * @param index - Compose message index
     * @returns Transaction result containing the message hash
     */
    getComposeMessageHashMoveCall(tx: Transaction, composeQueue: string | TransactionArgument, from: string | TransactionArgument, guid: Uint8Array | TransactionArgument, index: number | TransactionArgument): TransactionResult;
    /**
     * Get compose message hash
     * @param composeQueue - The compose queue object ID
     * @param from - Sender address
     * @param guid - Globally unique identifier as bytes
     * @param index - Compose message index
     * @returns Promise<Uint8Array> - The message hash as bytes
     */
    getComposeMessageHash(composeQueue: string, from: string, guid: Uint8Array, index: number): Promise<Uint8Array>;
    /**
     * Get count of registered message libraries
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the count of registered libraries
     */
    registeredLibrariesCountMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get count of registered message libraries
     * @returns Promise<bigint> - The number of registered libraries
     */
    registeredLibrariesCount(): Promise<bigint>;
    /**
     * Get list of registered message libraries with pagination
     * @param tx - The transaction to add the move call to
     * @param start - Start index for pagination or transaction argument
     * @param maxCount - Maximum count to return or transaction argument
     * @returns Transaction result containing array of library addresses
     */
    registeredLibrariesMoveCall(tx: Transaction, start: bigint | TransactionArgument, maxCount: bigint | TransactionArgument): TransactionResult;
    /**
     * Get list of registered message libraries with pagination
     * @param start - Start index for pagination
     * @param maxCount - Maximum count to return
     * @returns Promise<string[]> - Array of registered library addresses
     */
    registeredLibraries(start: bigint, maxCount: bigint): Promise<string[]>;
    /**
     * Check if a message library is registered
     * @param tx - The transaction to add the move call to
     * @param messageLib - The message library address or transaction argument
     * @returns Transaction result containing the registration status
     */
    isLibraryRegisteredMoveCall(tx: Transaction, messageLib: string | TransactionArgument): TransactionResult;
    /**
     * Check if a message library is registered
     * @param lib - The message library address
     * @returns Promise<boolean> - True if the library is registered
     */
    isRegisteredLibrary(lib: string): Promise<boolean>;
    /**
     * Get message library type
     * @param tx - The transaction to add the move call to
     * @param lib - The message library address or transaction argument
     * @returns Transaction result containing the library type
     */
    getLibraryTypeMoveCall(tx: Transaction, lib: string | TransactionArgument): TransactionResult;
    /**
     * Get message library type
     * @param lib - The message library address
     * @returns Promise<MessageLibType> - The library type (Send, Receive, or SendAndReceive)
     */
    getLibraryType(lib: string): Promise<MessageLibType>;
    /**
     * Get default send library for a destination EID
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID or transaction argument
     * @returns Transaction result containing the default send library address
     */
    getDefaultSendLibraryMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get default send library for a destination EID
     * @param dstEid - Destination endpoint ID
     * @returns Promise<string> - The default send library address, empty string if unavailable
     */
    getDefaultSendLibrary(dstEid: number): Promise<string>;
    /**
     * Get default receive library for a source EID
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID or transaction argument
     * @returns Transaction result containing the default receive library address
     */
    getDefaultReceiveLibraryMoveCall(tx: Transaction, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get default receive library for a source EID
     * @param srcEid - Source endpoint ID
     * @returns Promise<string> - The default receive library address, empty string if unavailable
     */
    getDefaultReceiveLibrary(srcEid: number): Promise<string>;
    /**
     * Get timeout for default receive library transition
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID or transaction argument
     * @returns Transaction result containing the timeout information
     */
    getDefaultReceiveLibraryTimeoutMoveCall(tx: Transaction, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get timeout for default receive library transition
     * @param srcEid - Source endpoint ID
     * @returns Promise<Timeout | null> - The timeout information or null if not set
     */
    getDefaultReceiveLibraryTimeout(srcEid: number): Promise<Timeout | null>;
    /**
     * Check if an endpoint ID is supported
     * @param tx - The transaction to add the move call to
     * @param eid - Endpoint ID to check or transaction argument
     * @returns Transaction result containing the support status
     */
    isSupportedEidMoveCall(tx: Transaction, eid: number | TransactionArgument): TransactionResult;
    /**
     * Check if an endpoint ID is supported
     * @param eid - Endpoint ID to check
     * @returns Promise<boolean> - True if the endpoint ID is supported
     */
    isSupportedEid(eid: number): Promise<boolean>;
    /**
     * Get send library for an OApp and destination EID
     * @param tx - The transaction to add the move call to
     * @param sender - The sender OApp address or transaction argument
     * @param dstEid - Destination endpoint ID or transaction argument
     * @returns Transaction result containing the send library info
     */
    getSendLibraryMoveCall(tx: Transaction, sender: string | TransactionArgument, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get send library for an OApp and destination EID
     * @param sender - The sender OApp address
     * @param dstEid - Destination endpoint ID
     * @returns Promise<[string, boolean]> - Tuple of [library address, is default]
     */
    getSendLibrary(sender: string, dstEid: number): Promise<[string, boolean]>;
    /**
     * Get receive library for an OApp and source EID
     * @param tx - The transaction to add the move call to
     * @param receiver - The receiver OApp address or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @returns Transaction result containing the receive library info
     */
    getReceiveLibraryMoveCall(tx: Transaction, receiver: string | TransactionArgument, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get receive library for an OApp and source EID
     * @param receiver - The receiver OApp address
     * @param srcEid - Source endpoint ID
     * @returns Promise<[string, boolean]> - Tuple of [library address, is default]
     */
    getReceiveLibrary(receiver: string, srcEid: number): Promise<[string, boolean]>;
    /**
     * Get receive library timeout for an OApp and source EID
     * @param tx - The transaction to add the move call to
     * @param receiver - The receiver OApp address or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @returns Transaction result containing the timeout information
     */
    getReceiveLibraryTimeoutMoveCall(tx: Transaction, receiver: string | TransactionArgument, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get receive library timeout for an OApp and source EID
     * @param receiver - The receiver OApp address
     * @param srcEid - Source endpoint ID
     * @returns Promise<Timeout | null> - The timeout information or null if not set
     */
    getReceiveLibraryTimeout(receiver: string, srcEid: number): Promise<Timeout | null>;
    /**
     * Check if a receive library is valid for current time
     * @param tx - The transaction to add the move call to
     * @param receiver - The receiver OApp address or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param actualReceiveLib - The actual receive library address to validate or transaction argument
     * @returns Transaction result containing the validity status
     */
    isValidReceiveLibraryMoveCall(tx: Transaction, receiver: string | TransactionArgument, srcEid: number | TransactionArgument, actualReceiveLib: string | TransactionArgument): TransactionResult;
    /**
     * Check if a receive library is valid for current time
     * @param receiver - The receiver OApp address
     * @param srcEid - Source endpoint ID
     * @param actualReceiveLib - The actual receive library address to validate
     * @returns Promise<boolean> - True if the receive library is valid
     */
    isValidReceiveLibrary(receiver: string, srcEid: number, actualReceiveLib: string): Promise<boolean>;
    /**
     * Check if channel is initialized for remote OApp
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param remoteEid - Remote endpoint ID or transaction argument
     * @param remoteOapp - Remote OApp address as bytes or transaction argument
     * @returns Transaction result containing the initialization status
     */
    isChannelInitedMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, remoteEid: number | TransactionArgument, remoteOapp: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Check if channel is initialized for remote OApp
     * @param messagingChannel - The messaging channel object ID
     * @param remoteEid - Remote endpoint ID
     * @param remoteOapp - Remote OApp address as bytes
     * @returns Promise<boolean> - True if channel is initialized
     */
    isChannelInited(messagingChannel: string, remoteEid: number, remoteOapp: Uint8Array): Promise<boolean>;
    /**
     * Check if message path is initializable
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @returns Transaction result containing the initialization status
     */
    initializableMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Check if message path is initializable
     * @param messagingChannel - The messaging channel object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @returns Promise<boolean> - True if path is initializable
     */
    initializable(messagingChannel: string, srcEid: number, sender: Uint8Array): Promise<boolean>;
    /**
     * Get OApp address from messaging channel
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @returns Transaction result containing the OApp address
     */
    getOappMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument): TransactionResult;
    /**
     * Get OApp address from messaging channel
     * @param messagingChannel - The messaging channel object ID
     * @returns Promise<string> - The OApp address
     */
    getOapp(messagingChannel: string): Promise<string>;
    /**
     * Check if messaging channel is currently sending
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @returns Transaction result containing the sending status
     */
    isSendingMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument): TransactionResult;
    /**
     * Check if messaging channel is currently sending
     * @param messagingChannel - The messaging channel object ID
     * @returns Promise<boolean> - True if the channel is currently sending
     */
    isSending(messagingChannel: string): Promise<boolean>;
    /**
     * Get next GUID for outbound message
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param dstEid - Destination endpoint ID or transaction argument
     * @param receiver - Receiver address as bytes or transaction argument
     * @returns Transaction result containing the next GUID
     */
    getNextGuidMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, dstEid: number | TransactionArgument, receiver: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get next GUID for outbound message
     * @param messagingChannel - The messaging channel object ID
     * @param dstEid - Destination endpoint ID
     * @param receiver - Receiver address as bytes
     * @returns Promise<Uint8Array> - The next GUID as bytes
     */
    getNextGuid(messagingChannel: string, dstEid: number, receiver: Uint8Array): Promise<Uint8Array>;
    /**
     * Get outbound nonce for destination
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param dstEid - Destination endpoint ID or transaction argument
     * @param receiver - Receiver address as bytes or transaction argument
     * @returns Transaction result containing the outbound nonce
     */
    getOutboundNonceMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, dstEid: number | TransactionArgument, receiver: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get outbound nonce for destination
     * @param messagingChannel - The messaging channel object ID
     * @param dstEid - Destination endpoint ID
     * @param receiver - Receiver address as bytes
     * @returns Promise<bigint> - The outbound nonce value
     */
    getOutboundNonce(messagingChannel: string, dstEid: number, receiver: Uint8Array): Promise<bigint>;
    /**
     * Get lazy inbound nonce from source
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @returns Transaction result containing the lazy inbound nonce
     */
    getLazyInboundNonceMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get lazy inbound nonce from source
     * @param messagingChannel - The messaging channel object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @returns Promise<bigint> - The lazy inbound nonce value
     */
    getLazyInboundNonce(messagingChannel: string, srcEid: number, sender: Uint8Array): Promise<bigint>;
    /**
     * Get inbound nonce from source
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @returns Transaction result containing the inbound nonce
     */
    getInboundNonceMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get inbound nonce from source
     * @param messagingChannel - The messaging channel object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @returns Promise<bigint> - The inbound nonce value
     */
    getInboundNonce(messagingChannel: string, srcEid: number, sender: Uint8Array): Promise<bigint>;
    /**
     * Check if inbound payload hash exists
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     * @returns Transaction result containing the payload hash existence status
     */
    hasInboundPayloadHashMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Check if inbound payload hash exists
     * @param messagingChannel - The messaging channel object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @param nonce - Message nonce
     * @returns Promise<boolean> - True if payload hash exists
     */
    hasInboundPayloadHash(messagingChannel: string, srcEid: number, sender: Uint8Array, nonce: bigint): Promise<boolean>;
    /**
     * Get inbound payload hash
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     * @returns Transaction result containing the payload hash
     */
    getInboundPayloadHashMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Get inbound payload hash
     * @param messagingChannel - The messaging channel object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @param nonce - Message nonce
     * @returns Promise<Uint8Array | null> - The payload hash as bytes or null if not found
     */
    getInboundPayloadHash(messagingChannel: string, srcEid: number, sender: Uint8Array, nonce: bigint): Promise<Uint8Array | null>;
    /**
     * Check if message is verifiable
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param srcEid - Source endpoint ID or transaction argument
     * @param sender - Sender address as bytes or transaction argument
     * @param nonce - Message nonce or transaction argument
     * @returns Transaction result containing the verifiable status
     */
    verifiableMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Check if message is verifiable
     * @param messagingChannel - The messaging channel object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @param nonce - Message nonce
     * @returns Promise<boolean> - True if message is verifiable
     */
    verifiable(messagingChannel: string, srcEid: number, sender: Uint8Array, nonce: bigint): Promise<boolean>;
    /**
     * Quote the messaging fee for sending a message
     *
     * This method simulates the transaction to calculate the exact fees required
     * for sending a cross-chain message, including native and ZRO token fees.
     *
     * @param tx - The transaction containing the quote call
     * @param quoteCall - The quote call transaction result
     * @param sender - Optional sender address for simulation context
     * @param maxSimulationTimes - Maximum number of simulation iterations allowed
     * @returns Promise resolving to MessagingFee with nativeFee and zroFee
     * @throws Error if simulation fails or validation errors occur
     */
    quote(tx: Transaction, quoteCall: TransactionResult, sender?: string | undefined, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<MessagingFee>;
    /**
     * Populate a transaction with all necessary move calls for quoting a message
     * @param tx - The transaction to populate with move calls
     * @param quoteCall - The quote call transaction result
     * @param sender - Optional sender address for simulation context
     * @param maxSimulationTimes - Maximum number of simulation iterations allowed
     * @param validators - validators for simulation context (ShareObjectValidator + PackageWhitelistValidator are always ensured, additional validators can be provided)
     * @throws Error if simulation fails or validation errors occur
     * @returns Promise<MoveCall[]> - The final move calls that are built
     */
    populateQuoteTransaction(tx: Transaction, quoteCall: TransactionResult, sender?: string | undefined, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<MoveCall[]>;
    /**
     * Populate a transaction with all necessary move calls for sending a message
     *
     * This method builds the complete transaction by simulating and resolving all
     * required move calls, including worker assignments and fee calculations.
     * It validates all input objects to ensure PTB compatibility.
     *
     * @param tx - The transaction to populate with move calls
     * @param sendCall - The send call transaction result
     * @param sender - Optional sender address for simulation context
     * @param validators - validators for simulation context (ShareObjectValidator + PackageWhitelistValidator are always ensured, additional validators can be provided)
     * @param maxSimulationTimes - Maximum number of simulation iterations allowed
     * @throws Error if simulation fails, validation errors occur, or objects are not PTB-compatible
     * @returns Promise<MoveCall[]> - The final move calls that are built
     */
    populateSendTransaction(tx: Transaction, sendCall: TransactionResult, sender?: string | undefined, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<MoveCall[]>;
    /**
     * Populate a transaction with all necessary move calls for setting configuration
     *
     * This method builds the complete transaction for updating message library configuration
     * by simulating and resolving all required move calls.
     *
     * @param tx - The transaction to populate with move calls
     * @param setConfigCall - The set config call transaction result
     * @param sender - Optional sender address for simulation context
     * @param validators - validators for simulation context (ShareObjectValidator + PackageWhitelistValidator are always ensured, additional validators can be provided)
     * @param maxSimulationTimes - Maximum number of simulation iterations allowed
     * @throws Error if simulation fails or validation errors occur
     * @returns Promise<MoveCall[]> - The final move calls that are built
     */
    populateSetConfigTransaction(tx: Transaction, setConfigCall: TransactionResult, sender?: string | undefined, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<MoveCall[]>;
    /**
     * Populate a transaction with all necessary move calls for receiving a LayerZero message
     *
     * This method builds the complete transaction for processing an incoming cross-chain
     * message, including all required validations and state updates.
     *
     * @param tx - The transaction to populate with move calls
     * @param lzReceiveCall - The LayerZero receive call transaction result
     * @param oapp - The receiver OApp address
     * @param sender - Optional sender address for simulation context
     * @param maxSimulationTimes - Maximum number of simulation iterations allowed
     * @throws Error if simulation fails or validation errors occur
     * @returns Promise<MoveCall[]> - The final move calls that are built
     */
    populateLzReceiveTransaction(tx: Transaction, lzReceiveCall: TransactionResult, oapp: string | TransactionArgument, // receiver oapp
    sender?: string | undefined, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<MoveCall[]>;
    /**
     * Populate a transaction with all necessary move calls for LayerZero compose
     *
     * This method builds the complete transaction for processing a LayerZero compose
     * operation, including all required validations and state updates.
     *
     * @param tx - The transaction to populate with move calls
     * @param endpointLzComposeCall - The LayerZero compose call transaction result
     * @param composer - The composer address
     * @param sender - Optional sender address for simulation context
     * @param maxSimulationTimes - Maximum number of simulation iterations allowed
     * @throws Error if simulation fails or validation errors occur
     * @returns Promise<MoveCall[]> - The final move calls that are built
     */
    populateLzComposeTransaction(tx: Transaction, endpointLzComposeCall: TransactionResult, composer: string | TransactionArgument, sender?: string | undefined, validators?: IPTBValidator[], maxSimulationTimes?: number): Promise<MoveCall[]>;
}

declare const BlockedMessageLibErrorCode: {
    readonly BlockedMessageLib_ENotImplemented: 1;
};
declare class BlockedMessageLib {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Quote messaging fees (always throws not implemented error)
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result or transaction argument
     */
    quoteMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Send message (always throws not implemented error)
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result or transaction argument
     */
    sendMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Set configuration (always throws not implemented error)
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result or transaction argument
     */
    setConfigMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Get blocked message library version
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the version information
     */
    versionMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get blocked message library version
     * @returns Promise<[string, string, string]> - Tuple of [major, minor, endpoint] version strings
     */
    getVersion(): Promise<[string, string, string]>;
}

declare const SimpleMessageLibErrorCode: {
    readonly SimpleMessageLib_ENotImplemented: 1;
    readonly SimpleMessageLib_EZROFeeNotEnabled: 2;
    readonly SimpleMessageLib_EInvalidEid: 3;
};
declare class SimpleMessageLib {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Set messaging fees for simple message library (admin only)
     * @param tx - The transaction to add the move call to
     * @param zroFee - The ZRO token fee amount or transaction argument
     * @param nativeFee - The native token fee amount or transaction argument
     */
    setMessagingFeeMoveCall(tx: Transaction, zroFee: number | TransactionArgument, nativeFee: number | TransactionArgument): void;
    /**
     * Set fee recipient address (admin only)
     * @param tx - The transaction to add the move call to
     * @param feeRecipient - The new fee recipient address or transaction argument
     */
    setFeeRecipientMoveCall(tx: Transaction, feeRecipient: string | TransactionArgument): void;
    /**
     * Validate packet for simple message processing
     * @param tx - The transaction to add the move call to
     * @param messagingChannel - The messaging channel object ID or transaction argument
     * @param packetHeader - The packet header as bytes or transaction argument
     * @param payloadHash - The payload hash as bytes or transaction argument
     */
    validatePacketMoveCall(tx: Transaction, messagingChannel: string | TransactionArgument, packetHeader: Uint8Array | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): void;
    /**
     * Set configuration for simple message library
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing configuration or transaction argument
     */
    setConfigMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Quote messaging fees for simple message library
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing quote parameters or transaction argument
     */
    quoteMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Send message through simple message library
     * @param tx - The transaction to add the move call to
     * @param messageChannel - The messaging channel object ID or transaction argument
     * @param endpointCall - The endpoint call transaction result or transaction argument
     * @param messageLibCall - The message library call transaction result or transaction argument
     */
    sendMoveCall(tx: Transaction, messageChannel: string | TransactionArgument, endpointCall: TransactionArgument, messageLibCall: TransactionArgument): void;
    /**
     * Get native token fee amount
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the native fee
     */
    getNativeFeeMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get native token fee amount
     * @returns Promise<string> - The native token fee as string
     */
    getNativeFee(): Promise<string>;
    /**
     * Get ZRO token fee amount
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the ZRO fee
     */
    getZroFeeMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get ZRO token fee amount
     * @returns Promise<string> - The ZRO token fee as string
     */
    getZroFee(): Promise<string>;
    /**
     * Get fee recipient address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the fee recipient address
     */
    getFeeRecipientMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get fee recipient address
     * @returns Promise<string> - The fee recipient address
     */
    getFeeRecipient(): Promise<string>;
    /**
     * Get simple message library version
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the version information
     */
    versionMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get simple message library version
     * @returns Promise<[string, string, string]> - Tuple of [major, minor, endpoint] version strings
     */
    getVersion(): Promise<[string, string, string]>;
}

declare const Uln302ErrorCode: {
    readonly SendUln302_EDefaultExecutorConfigNotFound: 1;
    readonly SendUln302_EDefaultUlnConfigNotFound: 2;
    readonly SendUln302_EInvalidMessageSize: 3;
    readonly SendUln302_EOAppExecutorConfigNotFound: 4;
    readonly SendUln302_EOAppUlnConfigNotFound: 5;
    readonly ReceiveUln302_EConfirmationsNotFound: 1;
    readonly ReceiveUln302_EDefaultUlnConfigNotFound: 2;
    readonly ReceiveUln302_EInvalidEid: 3;
    readonly ReceiveUln302_EOAppUlnConfigNotFound: 4;
    readonly ReceiveUln302_EVerifying: 5;
    readonly Uln302_EInvalidConfigType: 1;
    readonly Uln302_EInvalidMessagingChannel: 2;
    readonly Uln302_EUnsupportedEid: 3;
    readonly UlnConfig_EAtLeastOneDVN: 1;
    readonly UlnConfig_EDuplicateOptionalDVNs: 2;
    readonly UlnConfig_EDuplicateRequiredDVNs: 3;
    readonly UlnConfig_EInvalidOptionalDVNCount: 4;
    readonly UlnConfig_EInvalidOptionalDVNThreshold: 5;
    readonly UlnConfig_EInvalidRequiredDVNCount: 6;
    readonly UlnConfig_EInvalidUlnConfigBytes: 7;
    readonly OAppUlnConfig_EInvalidConfirmations: 1;
    readonly OAppUlnConfig_EInvalidRequiredDVNs: 2;
    readonly OAppUlnConfig_EInvalidOptionalDVNs: 3;
    readonly ExecutorConfig_EInvalidExecutorAddress: 1;
    readonly ExecutorConfig_EInvalidExecutorBytes: 2;
    readonly ExecutorConfig_EZeroMessageSize: 3;
};
declare class Uln302 {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Create quote move call for message library
     * Note: This is typically called by the endpoint, not directly by users
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing quote parameters
     * @returns Transaction result containing the quote operation
     */
    quoteMoveCall(tx: Transaction, call: TransactionArgument): TransactionResult;
    /**
     * Confirm quote move call with worker fee calculations
     * Note: This is typically called by the endpoint, not directly by users
     * @param tx - The transaction to add the move call to
     * @param treasury - Treasury object address
     * @param messageLibCall - Message library call transaction result
     * @param executorCall - Executor call transaction result
     * @param dvnMultiCall - DVN multi-call transaction result
     */
    confirmQuoteMoveCall(tx: Transaction, treasury: string | TransactionArgument, messageLibCall: TransactionArgument, executorCall: TransactionArgument, dvnMultiCall: TransactionArgument): void;
    /**
     * Create send move call for message library
     * Note: This is typically called by the endpoint, not directly by users
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing send parameters
     * @returns Transaction result containing the send operation
     */
    sendMoveCall(tx: Transaction, call: TransactionArgument): TransactionResult;
    /**
     * Confirm send move call with treasury and worker integration
     * Note: This is typically called by the endpoint, not directly by users
     * @param tx - The transaction to add the move call to
     * @param treasury - Treasury object address
     * @param messagingChannel - The messaging channel object ID
     * @param endpointCall - The endpoint call transaction result
     * @param messageLibCall - The message library call transaction result
     * @param executorCall - The executor call transaction result
     * @param dvnMultiCall - The DVN multi-call transaction result
     */
    confirmSendMoveCall(tx: Transaction, treasury: string | TransactionArgument, messagingChannel: string | TransactionArgument, endpointCall: TransactionArgument, messageLibCall: TransactionArgument, executorCall: TransactionArgument, dvnMultiCall: TransactionArgument): void;
    /**
     * Set configuration move call for ULN302
     * Note: This is typically called by the endpoint, not directly by users
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing configuration
     */
    setConfigMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Verify packet move call with DVN call (new API)
     * Note: This is typically called by DVNs via Call objects, not directly by users
     * @param tx - The transaction to add the move call to
     * @param verification - The verification object address or transaction argument
     * @param call - The DVN verification call containing verification parameters
     */
    verifyMoveCall(tx: Transaction, verification: string | TransactionArgument, call: TransactionArgument): void;
    /**
     * Commit verification move call after all DVN verifications are complete
     * Note: This is typically called by relayers/executors, not directly by users
     * @param tx - The transaction to add the move call to
     * @param verification - The verification object address
     * @param messagingChannel - The messaging channel object ID
     * @param packetHeader - The packet header as bytes
     * @param payloadHash - The payload hash as bytes
     */
    commitVerificationMoveCall(tx: Transaction, verification: string | TransactionArgument, messagingChannel: string | TransactionArgument, packetHeader: Uint8Array | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): void;
    /**
     * Set default executor configuration for destination EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID or transaction argument
     * @param config - Executor configuration parameters
     */
    setDefaultExecutorConfigMoveCall(tx: Transaction, dstEid: number | TransactionArgument, config: ExecutorConfig): void;
    /**
     * Set default send ULN configuration for destination EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID or transaction argument
     * @param config - ULN configuration parameters
     */
    setDefaultSendUlnConfigMoveCall(tx: Transaction, dstEid: number | TransactionArgument, config: UlnConfig): void;
    /**
     * Set default receive ULN configuration for source EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID or transaction argument
     * @param config - ULN configuration parameters
     */
    setDefaultReceiveUlnConfigMoveCall(tx: Transaction, srcEid: number | TransactionArgument, config: UlnConfig): void;
    /**
     * Get ULN-302 version information
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing version information
     */
    versionMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get ULN-302 version information
     * @returns Promise<VersionInfo> - Version information with major, minor, and endpoint version
     */
    version(): Promise<VersionInfo>;
    /**
     * Check if endpoint ID is supported by ULN-302
     * @param tx - The transaction to add the move call to
     * @param eid - Endpoint ID to check
     * @returns Transaction result containing support status
     */
    isSupportedEidMoveCall(tx: Transaction, eid: number | TransactionArgument): TransactionResult;
    /**
     * Check if endpoint ID is supported by ULN-302
     * @param eid - Endpoint ID to check
     * @returns Promise<boolean> - True if the endpoint ID is supported
     */
    isSupportedEid(eid: number): Promise<boolean>;
    /**
     * Get default executor configuration for destination EID
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the executor configuration
     */
    getDefaultExecutorConfigMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get default executor configuration for destination EID
     */
    getDefaultExecutorConfig(dstEid: number): Promise<ExecutorConfig>;
    /**
     * Get OApp-specific executor configuration
     * @param tx - The transaction to add the move call to
     * @param sender - The sender OApp address
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the executor configuration
     */
    getOAppExecutorConfigMoveCall(tx: Transaction, sender: string | TransactionArgument, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get OApp-specific executor configuration
     */
    getOAppExecutorConfig(sender: string, dstEid: number): Promise<ExecutorConfig>;
    /**
     * Get effective executor configuration (OApp-specific or default)
     * @param tx - The transaction to add the move call to
     * @param sender - The sender OApp address
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the effective executor configuration
     */
    getEffectiveExecutorConfigMoveCall(tx: Transaction, sender: string | TransactionArgument, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get effective executor configuration (OApp-specific or default)
     */
    getEffectiveExecutorConfig(sender: string, dstEid: number): Promise<ExecutorConfig>;
    /**
     * Get default send ULN configuration for destination EID
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the default send ULN configuration
     */
    getDefaultSendUlnConfigMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get default ULN send configuration
     */
    getDefaultSendUlnConfig(dstEid: number): Promise<UlnConfig>;
    /**
     * Get OApp-specific send ULN configuration
     * @param tx - The transaction to add the move call to
     * @param sender - The sender OApp address
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the OApp send ULN configuration
     */
    getOAppSendUlnConfigMoveCall(tx: Transaction, sender: string | TransactionArgument, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get OApp-specific ULN send configuration
     */
    getOAppSendUlnConfig(sender: string, dstEid: number): Promise<OAppUlnConfig>;
    /**
     * Get effective send ULN configuration (OApp-specific or default)
     * @param tx - The transaction to add the move call to
     * @param sender - The sender OApp address
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the effective send ULN configuration
     */
    getEffectiveSendUlnConfigMoveCall(tx: Transaction, sender: string | TransactionArgument, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get effective ULN send configuration
     */
    getEffectiveSendUlnConfig(sender: string, dstEid: number): Promise<UlnConfig>;
    /**
     * Get default receive ULN configuration for source EID
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @returns Transaction result containing the default receive ULN configuration
     */
    getDefaultReceiveUlnConfigMoveCall(tx: Transaction, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get default ULN receive configuration
     */
    getDefaultReceiveUlnConfig(srcEid: number): Promise<UlnConfig>;
    /**
     * Get OApp-specific receive ULN configuration
     * @param tx - The transaction to add the move call to
     * @param receiver - The receiver OApp address
     * @param srcEid - Source endpoint ID
     * @returns Transaction result containing the OApp receive ULN configuration
     */
    getOAppReceiveUlnConfigMoveCall(tx: Transaction, receiver: string | TransactionArgument, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get OApp-specific ULN receive configuration
     */
    getOAppReceiveUlnConfig(receiver: string, srcEid: number): Promise<OAppUlnConfig>;
    /**
     * Get effective receive ULN configuration (OApp-specific or default)
     * @param tx - The transaction to add the move call to
     * @param receiver - The receiver OApp address
     * @param srcEid - Source endpoint ID
     * @returns Transaction result containing the effective receive ULN configuration
     */
    getEffectiveReceiveUlnConfigMoveCall(tx: Transaction, receiver: string | TransactionArgument, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get effective ULN receive configuration
     */
    getEffectiveReceiveUlnConfig(receiver: string, srcEid: number): Promise<UlnConfig>;
    /**
     * Get verification object address for ULN-302
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the verification object address
     */
    getVerificationMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get verification object address for ULN-302
     * @returns Promise<string> - The verification object address
     */
    getVerification(): Promise<string>;
    /**
     * Check if packet is verifiable through ULN-302
     * @param tx - The transaction to add the move call to
     * @param verification - The verification object address
     * @param packetHeader - The packet header as bytes
     * @param payloadHash - The payload hash as bytes
     * @returns Transaction result containing the verifiable status
     */
    verifiableMoveCall(tx: Transaction, verification: string | TransactionArgument, packetHeader: Uint8Array | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Check if packet is verifiable through ULN-302
     * @param verification - Verification object address
     * @param packetHeader - Packet header as bytes
     * @param payloadHash - Payload hash as bytes
     * @returns Promise<boolean> - True if packet is verifiable
     */
    verifiable(verification: string, packetHeader: Uint8Array, payloadHash: Uint8Array): Promise<boolean>;
    /**
     * Get confirmations for a specific DVN verification
     * @param tx - The transaction to add the move call to
     * @param verification - The verification object address
     * @param dvn - The DVN address
     * @param headerHash - The header hash as bytes
     * @param payloadHash - The payload hash as bytes
     * @returns Transaction result containing the confirmations count
     */
    getConfirmationsMoveCall(tx: Transaction, verification: string | TransactionArgument, dvn: string | TransactionArgument, headerHash: Uint8Array | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get confirmations for a specific DVN verification
     * @param verification - The verification object address
     * @param dvn - The DVN address
     * @param headerHash - The header hash as bytes
     * @param payloadHash - The payload hash as bytes
     * @returns Promise<bigint> - The confirmations count
     */
    getConfirmations(verification: string, dvn: string, headerHash: Uint8Array, payloadHash: Uint8Array): Promise<bigint>;
    /**
     * Create executor configuration move call
     * @param tx - The transaction to add the move call to
     * @param config - Executor configuration parameters
     * @returns Transaction result containing the executor configuration
     * @private
     */
    private createExecutorConfigMoveCall;
    /**
     * Create ULN configuration move call
     * @param tx - The transaction to add the move call to
     * @param config - ULN configuration parameters
     * @returns Transaction result containing the ULN configuration
     * @private
     */
    private createUlnConfigMoveCall;
    /**
     * Parse executor configuration from BCS data
     * @param data - Raw BCS data to parse
     * @returns ExecutorConfig - Parsed executor configuration
     * @private
     */
    private parseExecutorConfig;
    /**
     * Parse ULN configuration from BCS data
     * @param data - Raw BCS data to parse
     * @returns UlnConfig - Parsed ULN configuration
     * @private
     */
    private parseUlnConfig;
    /**
     * Parse OApp ULN configuration from BCS data
     * @param data - Raw BCS data to parse
     * @returns OAppUlnConfig - Parsed OApp ULN configuration
     * @private
     */
    private parseOAppUlnConfig;
}

declare const DVNErrorCode: {
    readonly DVN_EExpiredSignature: 1;
    readonly DVN_EEidNotSupported: 2;
    readonly DVN_EHashAlreadyUsed: 3;
    readonly DVN_EPtbBuilderAlreadyInitialized: 4;
    readonly Multisig_EDuplicatedSigner: 1;
    readonly Multisig_EInvalidSignatureLength: 2;
    readonly Multisig_EInvalidSignerLength: 3;
    readonly Multisig_EQuorumIsZero: 4;
    readonly Multisig_ESignaturesLessThanQuorum: 5;
    readonly Multisig_ESignerAlreadyExists: 6;
    readonly Multisig_ESignerNotFound: 7;
    readonly Multisig_ESignerNotInCommittee: 8;
    readonly Multisig_ESignersSizeIsLessThanQuorum: 9;
    readonly DVNInfoV1_EInvalidData: 1;
    readonly DVNInfoV1_EInvalidVersion: 2;
};
declare class DVN {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Set admin role for an address (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param admin - The admin address or transaction argument
     * @param active - Whether to activate or deactivate the admin role or transaction argument
     */
    setAdminMoveCall(tx: Transaction, adminCap: string | TransactionArgument, admin: string | TransactionArgument, active: boolean | TransactionArgument): void;
    /**
     * Set default multiplier basis points for fee calculation (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param multiplierBps - The multiplier in basis points or transaction argument
     */
    setDefaultMultiplierBpsMoveCall(tx: Transaction, adminCap: string | TransactionArgument, multiplierBps: number | TransactionArgument): void;
    /**
     * Set deposit address for DVN fees (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param depositAddress - The new deposit address or transaction argument
     */
    setDepositAddressMoveCall(tx: Transaction, adminCap: string | TransactionArgument, depositAddress: string | TransactionArgument): void;
    /**
     * Set price feed for DVN (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param priceFeed - The price feed address or transaction argument
     */
    setPriceFeedMoveCall(tx: Transaction, adminCap: string | TransactionArgument, priceFeed: string | TransactionArgument): void;
    /**
     * Set supported option types for a destination EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param dstEid - Destination endpoint ID
     * @param optionTypes - Array of supported option types
     */
    setSupportedOptionTypesMoveCall(tx: Transaction, adminCap: string | TransactionArgument, dstEid: number | TransactionArgument, optionTypes: Uint8Array | TransactionArgument): void;
    /**
     * Set worker fee library (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param workerFeeLib - The worker fee library address
     */
    setWorkerFeeLibMoveCall(tx: Transaction, adminCap: string | TransactionArgument, workerFeeLib: string | TransactionArgument): void;
    /**
     * Set destination configuration for DVN (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param dstEid - Destination endpoint ID
     * @param gas - Gas amount for verification
     * @param multiplierBps - Multiplier in basis points
     * @param floorMarginUsd - Floor margin in USD
     */
    setDstConfigMoveCall(tx: Transaction, adminCap: string | TransactionArgument, dstEid: number | TransactionArgument, gas: bigint | number | string | TransactionArgument, multiplierBps: number | TransactionArgument, floorMarginUsd: bigint | number | string | TransactionArgument): void;
    /**
     * Initialize PTB builder move calls for DVN worker operations (admin only) - can only be called once
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param targetPtbBuilder - Target PTB builder address
     * @param getFeeMoveCalls - Get fee move calls transaction argument
     * @param assignJobMoveCalls - Assign job move calls transaction argument
     * @returns Transaction result containing the init PTB builder call
     */
    initPtbBuilderMoveCallsMoveCall(tx: Transaction, adminCap: string | TransactionArgument, targetPtbBuilder: string | TransactionArgument, getFeeMoveCalls: TransactionArgument, assignJobMoveCalls: TransactionArgument): TransactionResult;
    /**
     * Set PTB builder move calls for DVN worker operations (admin with signatures)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param targetPtbBuilder - Target PTB builder address
     * @param getFeeMoveCalls - Get fee move calls transaction argument
     * @param assignJobMoveCalls - Assign job move calls transaction argument
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     * @returns Transaction result containing the set PTB builder call
     */
    setPtbBuilderMoveCallsMoveCall(tx: Transaction, adminCap: string | TransactionArgument, targetPtbBuilder: string | TransactionArgument, getFeeMoveCalls: TransactionArgument, assignJobMoveCalls: TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Set supported message library (admin with signatures)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param messageLib - The message library address
     * @param supported - Whether to support or remove support for the message library
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     */
    setSupportedMessageLibMoveCall(tx: Transaction, adminCap: string | TransactionArgument, messageLib: string | TransactionArgument, supported: boolean | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
    /**
     * Set allowlist status for an OApp sender (admin with signatures)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param oapp - The OApp address to allowlist/remove
     * @param allowed - Whether to allow or remove from allowlist
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     */
    setAllowlistMoveCall(tx: Transaction, adminCap: string | TransactionArgument, oapp: string | TransactionArgument, allowed: boolean | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
    /**
     * Set denylist status for an OApp sender (admin with signatures)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param oapp - The OApp address to denylist/remove
     * @param denied - Whether to deny or remove from denylist
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     */
    setDenylistMoveCall(tx: Transaction, adminCap: string | TransactionArgument, oapp: string | TransactionArgument, denied: boolean | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
    /**
     * Set paused state with multisig signatures (admin with signatures)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param paused - Whether to pause or unpause the DVN
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     */
    setPausedMoveCall(tx: Transaction, adminCap: string | TransactionArgument, paused: boolean | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
    /**
     * Set quorum threshold with multisig signatures (admin with signatures)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param quorum - The new quorum threshold
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     */
    setQuorumMoveCall(tx: Transaction, adminCap: string | TransactionArgument, quorum: bigint | number | string | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
    /**
     * Set DVN signer with multisig signatures (admin with signatures)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param signer - The signer public key as bytes
     * @param active - Whether to activate or deactivate the signer
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     */
    setDvnSignerMoveCall(tx: Transaction, adminCap: string | TransactionArgument, signer: Uint8Array | TransactionArgument, active: boolean | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
    /**
     * Change admin status using quorum signatures
     * @param tx - The transaction to add the move call to
     * @param admin - The admin address to change
     * @param active - Whether to activate or deactivate the admin
     * @param expiration - Signature expiration timestamp
     * @param signatures - Multisig signatures for authorization
     */
    quorumChangeAdminMoveCall(tx: Transaction, admin: string | TransactionArgument, active: boolean | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
    /**
     * Verify a packet with DVN signatures (admin with signatures) - returns Call object for ULN302
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param targetMessageLib - The target message library address (usually ULN302)
     * @param packetHeader - The packet header as bytes
     * @param payloadHash - The payload hash as bytes
     * @param confirmations - Required confirmations count
     * @param expiration - Signature expiration timestamp
     * @param signatures - DVN multisig signatures
     * @returns Transaction result containing the verification Call object
     */
    verifyMoveCall(tx: Transaction, adminCap: string | TransactionArgument, targetMessageLib: string | TransactionArgument, packetHeader: Uint8Array | TransactionArgument, payloadHash: Uint8Array | TransactionArgument, confirmations: bigint | number | string | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Assign verification job for DVN (called via PTB with MultiCall created by send function in ULN302)
     * @param tx - The transaction to add the move call to
     * @param dvnMultiCall - The DVN multi-call transaction result
     * @returns Transaction result containing a Call for fee calculation
     */
    assignJobMoveCall(tx: Transaction, dvnMultiCall: TransactionArgument): TransactionResult;
    /**
     * Confirm assign job operation with fee calculation
     * @param tx - The transaction to add the move call to
     * @param dvnMultiCall - The DVN multi-call transaction result
     * @param feelibCall - The fee library call transaction result
     */
    confirmAssignJobMoveCall(tx: Transaction, dvnMultiCall: TransactionArgument, feelibCall: TransactionArgument): void;
    /**
     * Get fee for verification (using MultiCall created by quote function in ULN302)
     * @param tx - The transaction to add the move call to
     * @param dvnMultiCall - The DVN multi-call transaction result
     * @returns Transaction result containing a Call for fee calculation
     */
    getFeeMoveCall(tx: Transaction, dvnMultiCall: TransactionArgument): TransactionResult;
    /**
     * Confirm get fee operation with fee calculation
     * @param tx - The transaction to add the move call to
     * @param dvnMultiCall - The DVN multi-call transaction result
     * @param feelibCall - The fee library call transaction result
     */
    confirmGetFeeMoveCall(tx: Transaction, dvnMultiCall: TransactionArgument, feelibCall: TransactionArgument): void;
    /**
     * Get the size of the allowlist
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the allowlist size
     */
    allowlistSizeMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the size of the allowlist
     * @returns Promise<bigint> - The number of addresses in the allowlist
     */
    allowlistSize(): Promise<bigint>;
    /**
     * Get default multiplier basis points
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the default multiplier bps
     */
    defaultMultiplierBpsMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get default multiplier basis points
     * @returns Promise<number> - The default multiplier in basis points
     */
    defaultMultiplierBps(): Promise<number>;
    /**
     * Get DVN deposit address for fee collection
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the deposit address
     */
    depositAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get DVN deposit address for fee collection
     * @returns Promise<string> - The deposit address
     */
    depositAddress(): Promise<string>;
    /**
     * Get destination configuration for DVN
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the destination configuration
     */
    dstConfigMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get destination configuration for DVN
     * @param dstEid - Destination endpoint ID
     * @returns Promise<DvnDstConfig> - The destination configuration
     */
    dstConfig(dstEid: number): Promise<DvnDstConfig>;
    /**
     * Check if an address has ACL (Access Control List) permission
     * @param tx - The transaction to add the move call to
     * @param account - The account address to check
     * @returns Transaction result containing the ACL permission status
     */
    hasAclMoveCall(tx: Transaction, account: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address has ACL (Access Control List) permission
     * @param account - The account address to check
     * @returns Promise<boolean> - True if the address has ACL permission
     */
    hasAcl(account: string): Promise<boolean>;
    /**
     * Get all registered DVN admins
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing array of admin addresses
     */
    adminsMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get all registered DVN admins
     * @returns Promise<string[]> - Array of admin addresses
     */
    admins(): Promise<string[]>;
    /**
     * Check if an admin cap is valid
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID to check
     * @returns Transaction result containing the admin status
     */
    isAdminMoveCall(tx: Transaction, adminCap: string | TransactionArgument): TransactionResult;
    /**
     * Check if an admin cap is valid
     * @param adminCap - The admin capability object ID to check
     * @returns Promise<boolean> - True if the admin cap is valid
     */
    isAdmin(adminCap: string): Promise<boolean>;
    /**
     * Check if an address is an admin
     * @param tx - The transaction to add the move call to
     * @param admin - The admin address to check
     * @returns Transaction result containing the admin status
     */
    isAdminAddressMoveCall(tx: Transaction, admin: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address is an admin
     * @param admin - The admin address to check
     * @returns Promise<boolean> - True if the address is an admin
     */
    isAdminAddress(admin: string): Promise<boolean>;
    /**
     * Check if a message library is supported by this DVN
     * @param tx - The transaction to add the move call to
     * @param messageLib - The message library address to check
     * @returns Transaction result containing the support status
     */
    isSupportedMessageLibMoveCall(tx: Transaction, messageLib: string | TransactionArgument): TransactionResult;
    /**
     * Check if a message library is supported by this DVN
     * @param messageLib - The message library address to check
     * @returns Promise<boolean> - True if the message library is supported
     */
    isSupportedMessageLib(messageLib: string): Promise<boolean>;
    /**
     * Check if an address is allowlisted
     * @param tx - The transaction to add the move call to
     * @param account - The account address to check
     * @returns Transaction result containing the allowlist status
     */
    isAllowlistedMoveCall(tx: Transaction, account: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address is in the allowlist
     * @param account - The account address to check
     * @returns Promise<boolean> - True if the address is allowlisted
     */
    isAllowlisted(account: string): Promise<boolean>;
    /**
     * Check if an address is denylisted
     * @param tx - The transaction to add the move call to
     * @param account - The account address to check
     * @returns Transaction result containing the denylist status
     */
    isDenylistedMoveCall(tx: Transaction, account: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address is in the denylist
     * @param account - The account address to check
     * @returns Promise<boolean> - True if the address is denylisted
     */
    isDenylisted(account: string): Promise<boolean>;
    /**
     * Check if DVN is paused
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the paused status
     */
    isPausedMoveCall(tx: Transaction): TransactionResult;
    /**
     * Check if DVN worker is paused
     * @returns Promise<boolean> - True if the worker is paused
     */
    isPaused(): Promise<boolean>;
    /**
     * Check if an address is a registered DVN signer
     * @param tx - The transaction to add the move call to
     * @param signer - The signer public key as bytes
     * @returns Transaction result containing the signer status
     */
    isSignerMoveCall(tx: Transaction, signer: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Check if an address is a registered DVN signer
     * @param signer - The signer public key as bytes
     * @returns Promise<boolean> - True if the address is a registered signer
     */
    isSigner(signer: Uint8Array): Promise<boolean>;
    /**
     * Get DVN price feed address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the price feed address
     */
    priceFeedMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get DVN price feed address
     * @returns Promise<string> - The price feed address
     */
    priceFeed(): Promise<string>;
    /**
     * Get DVN quorum threshold
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the quorum threshold
     */
    quorumMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get DVN quorum threshold
     * @returns Promise<bigint> - The quorum threshold
     */
    quorum(): Promise<bigint>;
    /**
     * Get the total count of registered DVN signers
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the signer count
     */
    signerCountMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the total count of registered DVN signers
     * @returns Promise<bigint> - The number of registered signers
     */
    signerCount(): Promise<bigint>;
    /**
     * Get all registered DVN signers
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing array of signer public keys
     */
    signersMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get all registered DVN signers
     * @returns Promise<Uint8Array[]> - Array of signer public keys as byte arrays
     */
    signers(): Promise<Uint8Array[]>;
    /**
     * Get supported option types for a destination EID
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing supported option types
     */
    supportedOptionTypesMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get supported option types for a destination EID
     * @param dstEid - Destination endpoint ID
     * @returns Promise<Uint8Array> - Array of supported option types as bytes
     */
    supportedOptionTypes(dstEid: number): Promise<Uint8Array>;
    /**
     * Get DVN Verifier ID (VID)
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the VID
     */
    vidMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get DVN VID (Verifier ID)
     * @returns Promise<number> - The DVN verifier ID
     */
    vid(): Promise<number>;
    /**
     * Get DVN worker capability address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the worker capability address
     */
    workerCapAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get DVN worker capability address
     * @returns Promise<string> - The worker capability address
     */
    workerCapAddress(): Promise<string>;
    /**
     * Get DVN worker fee library address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the worker fee library address
     */
    workerFeeLibMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get DVN worker fee library address
     * @returns Promise<string> - The worker fee library address
     */
    workerFeeLib(): Promise<string>;
    /**
     * Get admin capability ID from admin address
     * @param tx - The transaction to add the move call to
     * @param admin - The admin address
     * @returns Transaction result containing the admin capability ID
     */
    adminCapIdMoveCall(tx: Transaction, admin: string | TransactionArgument): TransactionResult;
    /**
     * Get admin capability ID from admin address
     * @param admin - The admin address
     * @returns Promise<string> - The admin capability ID
     */
    adminCapId(admin: string): Promise<string>;
    /**
     * Check if PTB builder has been initialized
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the PTB builder initialization status
     */
    isPtbBuilderInitializedMoveCall(tx: Transaction): TransactionResult;
    /**
     * Check if PTB builder has been initialized
     * @returns Promise<boolean> - True if the PTB builder has been initialized
     */
    isPtbBuilderInitialized(): Promise<boolean>;
    /**
     * Get DVN object address from worker registry using this DVN's worker capability (as a move call)
     * This function chains Move calls to decode worker info and extract the DVN object address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the DVN object address
     */
    getDvnObjectAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get DVN object address from worker registry using this DVN's worker capability
     * This function uses Move calls to decode worker info and extract the DVN object address
     * @returns Promise<string> - The DVN object address
     * @throws Will throw an error if worker info is not found or if decoding fails
     */
    getDvnObjectAddress(): Promise<string>;
    /**
     * Create a LayerZero witness for DVN package whitelist registration
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the LayerZero witness
     */
    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult;
    /**
     * Create a verify hash for packet verification
     * @param tx - The transaction to add the move call to
     * @param packetHeader - The packet header as bytes
     * @param payloadHash - The payload hash as bytes
     * @param confirmations - Required confirmations count
     * @param target - Target address for verification
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the verify hash
     */
    createVerifyHashMoveCall(tx: Transaction, packetHeader: Uint8Array | TransactionArgument, payloadHash: Uint8Array | TransactionArgument, confirmations: bigint | number | string | TransactionArgument, target: string | TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Create a verify hash for packet verification
     * @param packetHeader - The packet header as bytes
     * @param payloadHash - The payload hash as bytes
     * @param confirmations - Required confirmations count
     * @param target - Target address for verification
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Promise<Uint8Array> - The verify hash as bytes
     */
    createVerifyHash(packetHeader: Uint8Array, payloadHash: Uint8Array, confirmations: bigint, target: string, vid: number, expiration: bigint): Promise<Uint8Array>;
    /**
     * Create a set DVN signer hash for signature verification
     * @param tx - The transaction to add the move call to
     * @param signer - The signer public key as bytes
     * @param active - Whether to activate or deactivate the signer
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the set DVN signer hash
     */
    createSetDvnSignerHashMoveCall(tx: Transaction, signer: Uint8Array | TransactionArgument, active: boolean | TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Create a set DVN signer hash for signature verification
     * @param signer - The signer public key as bytes
     * @param active - Whether to activate or deactivate the signer
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Promise<Uint8Array> - The set DVN signer hash as bytes
     */
    createSetDvnSignerHash(signer: Uint8Array, active: boolean, vid: number, expiration: bigint): Promise<Uint8Array>;
    /**
     * Create a set quorum hash for signature verification
     * @param tx - The transaction to add the move call to
     * @param quorum - The new quorum threshold
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the set quorum hash
     */
    createSetQuorumHashMoveCall(tx: Transaction, quorum: bigint | number | string | TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Create a set quorum hash for signature verification
     * @param quorum - The new quorum threshold
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Promise<Uint8Array> - The set quorum hash as bytes
     */
    createSetQuorumHash(quorum: bigint, vid: number, expiration: bigint): Promise<Uint8Array>;
    /**
     * Create a quorum change admin hash for signature verification
     * @param tx - The transaction to add the move call to
     * @param admin - The admin address to change
     * @param active - Whether to activate or deactivate the admin
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the quorum change admin hash
     */
    createQuorumChangeAdminHashMoveCall(tx: Transaction, admin: string | TransactionArgument, active: boolean | TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Create a quorum change admin hash for signature verification
     * @param admin - The admin address to change
     * @param active - Whether to activate or deactivate the admin
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Promise<Uint8Array> - The quorum change admin hash as bytes
     */
    createQuorumChangeAdminHash(admin: string, active: boolean, vid: number, expiration: bigint): Promise<Uint8Array>;
    /**
     * Create a set allowlist hash for signature verification
     * @param tx - The transaction to add the move call to
     * @param oapp - The OApp address to allowlist/remove
     * @param allowed - Whether to allow or remove from allowlist
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the set allowlist hash
     */
    createSetAllowlistHashMoveCall(tx: Transaction, oapp: string | TransactionArgument, allowed: boolean | TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Create a set allowlist hash for signature verification
     * @param oapp - The OApp address to allowlist/remove
     * @param allowed - Whether to allow or remove from allowlist
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Promise<Uint8Array> - The set allowlist hash as bytes
     */
    createSetAllowlistHash(oapp: string, allowed: boolean, vid: number, expiration: bigint): Promise<Uint8Array>;
    /**
     * Create a set denylist hash for signature verification
     * @param tx - The transaction to add the move call to
     * @param oapp - The OApp address to denylist/remove
     * @param denied - Whether to deny or remove from denylist
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the set denylist hash
     */
    createSetDenylistHashMoveCall(tx: Transaction, oapp: string | TransactionArgument, denied: boolean | TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Create a set denylist hash for signature verification
     * @param oapp - The OApp address to denylist/remove
     * @param denied - Whether to deny or remove from denylist
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Promise<Uint8Array> - The set denylist hash as bytes
     */
    createSetDenylistHash(oapp: string, denied: boolean, vid: number, expiration: bigint): Promise<Uint8Array>;
    /**
     * Create a set pause hash for signature verification
     * @param tx - The transaction to add the move call to
     * @param paused - Whether to pause or unpause the DVN
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the set pause hash
     */
    createSetPauseHashMoveCall(tx: Transaction, paused: boolean | TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Create a set pause hash for signature verification
     * @param paused - Whether to pause or unpause the DVN
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Promise<Uint8Array> - The set pause hash as bytes
     */
    createSetPauseHash(paused: boolean, vid: number, expiration: bigint): Promise<Uint8Array>;
    /**
     * Create a set PTB builder move calls hash for signature verification
     * @param tx - The transaction to add the move call to
     * @param targetPtbBuilder - Target PTB builder address
     * @param getFeeMoveCalls - Get fee move calls transaction argument
     * @param assignJobMoveCalls - Assign job move calls transaction argument
     * @param vid - Verifier ID
     * @param expiration - Signature expiration timestamp
     * @returns Transaction result containing the set PTB builder move calls hash
     */
    createSetPtbBuilderMoveCallsHashMoveCall(tx: Transaction, targetPtbBuilder: string | TransactionArgument, getFeeMoveCalls: TransactionArgument, assignJobMoveCalls: TransactionArgument, vid: number | TransactionArgument, expiration: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Populate verify with DVN verification and ULN verify call
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param targetMessageLib - The target message library address (usually ULN302)
     * @param targetVerification - The verification object address for the target message library
     * @param packetHeader - The packet header as bytes
     * @param payloadHash - The payload hash as bytes
     * @param confirmations - Required confirmations count
     * @param expiration - Signature expiration timestamp
     * @param signatures - DVN multisig signatures
     */
    populateVerify(tx: Transaction, adminCap: string | TransactionArgument, targetMessageLib: string, targetVerification: string, packetHeader: Uint8Array | TransactionArgument, payloadHash: Uint8Array | TransactionArgument, confirmations: bigint | number | string | TransactionArgument, expiration: bigint | number | string | TransactionArgument, signatures: Uint8Array | TransactionArgument): void;
}

declare const DVNFeeLibErrorCode: {
    readonly EEidNotSupported: 1;
    readonly EInvalidDVNOptions: 2;
};
declare class DVNFeeLib {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Create a LayerZero witness for DVN Fee Lib package whitelist registration
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the LayerZero witness
     */
    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult;
    /**
     * Create get fee call for DVN fee calculation
     * Note: This is typically called by the DVN, not directly by users
     * This initiates the fee calculation process by creating a child call to the price feed
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing fee parameters
     * @returns Transaction result containing the fee calculation call
     */
    getFeeMoveCall(tx: Transaction, call: TransactionArgument): TransactionResult;
    /**
     * Confirm get fee call with price feed integration
     * Note: This is typically called by the DVN, not directly by users
     * This completes the fee calculation by processing the price feed result and applying premium
     * @param tx - The transaction to add the move call to
     * @param feelibCall - The fee library call transaction result
     * @param priceFeedCall - The price feed call transaction result
     */
    confirmGetFeeMoveCall(tx: Transaction, feelibCall: TransactionArgument, priceFeedCall: TransactionArgument): void;
}

declare const DVNLayerzeroErrorCode: {
    readonly DVNLayerzero_EWorkerCapNotFromPackage: 1;
};
declare class DvnLayerZero {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    constructor(packageId: string, client: SuiClient, moduleManager: ModuleManager);
    /**
     * Initialize DVN LayerZero instance
     * Creates and shares a new DVN with the specified configuration
     * @param tx - The transaction to add the move call to
     * @param workerCap - Worker capability object ID or transaction argument
     * @param vid - Verifier ID for the DVN or transaction argument
     * @param depositAddress - Address for fee deposits or transaction argument
     * @param supportedMessageLibs - Array of supported message library addresses or transaction argument
     * @param priceFeed - Price feed object address or transaction argument
     * @param workerFeeLib - Worker fee library address or transaction argument
     * @param defaultMultiplierBps - Default multiplier in basis points or transaction argument
     * @param admins - Array of admin addresses or transaction argument
     * @param signers - Array of signer public keys as bytes or transaction argument
     * @param quorum - Required signature threshold or transaction argument
     */
    initDvnMoveCall(tx: Transaction, workerCap: string | TransactionArgument, vid: number | TransactionArgument, depositAddress: string | TransactionArgument, supportedMessageLibs: string[] | TransactionArgument, priceFeed: string | TransactionArgument, workerFeeLib: string | TransactionArgument, defaultMultiplierBps: number | TransactionArgument, admins: string[] | TransactionArgument, signers: Uint8Array[] | TransactionArgument, quorum: bigint | number | string | TransactionArgument): void;
}

declare const ExecutorErrorCode: {
    readonly Executor_EEidNotSupported: 1;
    readonly Executor_EInvalidNativeDropAmount: 2;
    readonly ExecutorInfoV1_EInvalidData: 1;
    readonly ExecutorInfoV1_EInvalidVersion: 2;
};
declare class Executor {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Create a LayerZero witness for Executor package whitelist registration
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the LayerZero witness
     */
    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult;
    /**
     * Assign execution job for Executor (called via PTB with Call created by send function in ULN302)
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result from ULN302
     * @returns Transaction result containing the job assignment call
     */
    assignJobMoveCall(tx: Transaction, call: TransactionArgument): TransactionResult;
    /**
     * Confirm assign job operation with fee calculation
     * @param tx - The transaction to add the move call to
     * @param executorCall - The executor call transaction result
     * @param feelibCall - The fee library call transaction result
     */
    confirmAssignJobMoveCall(tx: Transaction, executorCall: TransactionArgument, feelibCall: TransactionArgument): void;
    /**
     * Get fee for execution (using Call created by quote function in ULN302)
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result from ULN302
     * @returns Transaction result containing the fee calculation call
     */
    getFeeMoveCall(tx: Transaction, call: TransactionArgument): TransactionResult;
    /**
     * Confirm get fee operation with fee library
     * @param tx - The transaction to add the move call to
     * @param executorCall - The executor call transaction result
     * @param feelibCall - The fee library call transaction result
     */
    confirmGetFeeMoveCall(tx: Transaction, executorCall: TransactionArgument, feelibCall: TransactionArgument): void;
    /**
     * Execute LayerZero receive operation (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param messagingChannel - The messaging channel object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @param nonce - Message nonce
     * @param guid - Globally unique identifier as bytes
     * @param message - Message payload as bytes
     * @param extraData - Additional execution data (optional)
     * @param value - Native token value to transfer
     * @returns Transaction result containing the execution call capability
     */
    executeLzReceiveMoveCall(tx: Transaction, adminCap: string | TransactionArgument, messagingChannel: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, guid: Uint8Array | TransactionArgument, message: Uint8Array | TransactionArgument, extraData?: Uint8Array | TransactionArgument, value?: bigint): TransactionResult;
    /**
     * Execute LayerZero compose operation (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param composeQueue - The compose queue object ID
     * @param from - Source address
     * @param guid - Globally unique identifier as bytes
     * @param index - Compose message index
     * @param message - Message payload as bytes
     * @param extraData - Additional execution data (optional)
     * @param value - Native token value to transfer
     * @returns Transaction result containing the execution call capability
     */
    executeLzComposeMoveCall(tx: Transaction, adminCap: string | TransactionArgument, composeQueue: string | TransactionArgument, from: string | TransactionArgument, guid: Uint8Array | TransactionArgument, index: number | TransactionArgument, message: Uint8Array | TransactionArgument, extraData?: Uint8Array | TransactionArgument, value?: bigint): TransactionResult;
    /**
     * Record a failed lz_receive execution for off-chain processing (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @param nonce - Message nonce
     * @param receiver - Receiver address
     * @param guid - Globally unique identifier as bytes
     * @param gas - Gas limit used for the execution attempt
     * @param value - Native token value included with the message
     * @param message - Message payload as bytes
     * @param extraData - Additional execution data
     * @param reason - Error message or failure reason
     */
    lzReceiveAlertMoveCall(tx: Transaction, adminCap: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: bigint | number | string | TransactionArgument, receiver: string | TransactionArgument, guid: Uint8Array | TransactionArgument, gas: bigint | number | string | TransactionArgument, value: bigint | number | string | TransactionArgument, message: Uint8Array | TransactionArgument, extraData: Uint8Array | TransactionArgument, reason: string | TransactionArgument): void;
    /**
     * Record a failed lz_compose execution for off-chain processing (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param from - Source address
     * @param to - Destination address
     * @param guid - Globally unique identifier as bytes
     * @param index - Compose message index
     * @param gas - Gas limit used for the execution attempt
     * @param value - Native token value included with the compose
     * @param message - Compose message payload as bytes
     * @param extraData - Additional execution data
     * @param reason - Error message or failure reason
     */
    lzComposeAlertMoveCall(tx: Transaction, adminCap: string | TransactionArgument, from: string | TransactionArgument, to: string | TransactionArgument, guid: Uint8Array | TransactionArgument, index: number | TransactionArgument, gas: bigint | number | string | TransactionArgument, value: bigint | number | string | TransactionArgument, message: Uint8Array | TransactionArgument, extraData: Uint8Array | TransactionArgument, reason: string | TransactionArgument): void;
    /**
     * Native drop function (admin only)
     * Takes a Coin<SUI> from caller and distributes it to recipients according to params
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes
     * @param dstEid - Destination endpoint ID
     * @param oapp - OApp address
     * @param nonce - Message nonce
     * @param nativeDropParams - Array of native drop parameters
     * @param paymentCoin - Payment coin for the drop
     */
    nativeDropMoveCall(tx: Transaction, adminCap: string | TransactionArgument, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, dstEid: number | TransactionArgument, oapp: string | TransactionArgument, nonce: bigint | number | string | TransactionArgument, nativeDropParams: NativeDropParams[], paymentCoin: TransactionArgument): void;
    /**
     * Set default multiplier basis points for fee calculation (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param multiplierBps - The multiplier in basis points
     */
    setDefaultMultiplierBpsMoveCall(tx: Transaction, adminCap: string | TransactionArgument, multiplierBps: number | TransactionArgument): void;
    /**
     * Set deposit address for executor fees (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param depositAddress - The new deposit address
     */
    setDepositAddressMoveCall(tx: Transaction, adminCap: string | TransactionArgument, depositAddress: string | TransactionArgument): void;
    /**
     * Set destination configuration for executor (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param dstEid - Destination endpoint ID
     * @param config - Destination configuration parameters
     */
    setDstConfigMoveCall(tx: Transaction, adminCap: string | TransactionArgument, dstEid: number | TransactionArgument, config: DstConfig): void;
    /**
     * Set price feed for executor (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param priceFeed - The price feed address
     */
    setPriceFeedMoveCall(tx: Transaction, adminCap: string | TransactionArgument, priceFeed: string | TransactionArgument): void;
    /**
     * Set PTB builder move calls for executor worker operations (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param targetPtbBuilder - Target PTB builder address
     * @param getFeeMoveCalls - Get fee move calls transaction argument
     * @param assignJobMoveCalls - Assign job move calls transaction argument
     * @returns Transaction result containing the set PTB builder call
     */
    setPtbBuilderMoveCallsMoveCall(tx: Transaction, targetPtbBuilder: string | TransactionArgument, getFeeMoveCalls: TransactionArgument, assignJobMoveCalls: TransactionArgument): TransactionResult;
    /**
     * Set supported option types for a destination EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param dstEid - Destination endpoint ID
     * @param optionTypes - Array of supported option type values
     */
    setSupportedOptionTypesMoveCall(tx: Transaction, adminCap: string | TransactionArgument, dstEid: number | TransactionArgument, optionTypes: number[]): void;
    /**
     * Set worker fee library for executor (admin only)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID
     * @param workerFeeLib - The worker fee library address
     */
    setWorkerFeeLibMoveCall(tx: Transaction, adminCap: string | TransactionArgument, workerFeeLib: string | TransactionArgument): void;
    /**
     * Set admin role (grant or revoke) (owner only)
     * @param tx - The transaction to add the move call to
     * @param ownerCap - The owner capability object ID
     * @param admin - The admin address
     * @param active - Whether to grant or revoke admin role
     */
    setAdminMoveCall(tx: Transaction, ownerCap: string | TransactionArgument, admin: string | TransactionArgument, active: boolean | TransactionArgument): void;
    /**
     * Set supported message library (owner only)
     * @param tx - The transaction to add the move call to
     * @param ownerCap - The owner capability object ID
     * @param messageLib - The message library address
     * @param supported - Whether to support or remove support for the message library
     */
    setSupportedMessageLibMoveCall(tx: Transaction, ownerCap: string | TransactionArgument, messageLib: string | TransactionArgument, supported: boolean | TransactionArgument): void;
    /**
     * Set allowlist status for an OApp sender (owner only)
     * @param tx - The transaction to add the move call to
     * @param ownerCap - The owner capability object ID
     * @param oapp - The OApp address
     * @param allowed - Whether to allow or remove from allowlist
     */
    setAllowlistMoveCall(tx: Transaction, ownerCap: string | TransactionArgument, oapp: string | TransactionArgument, allowed: boolean | TransactionArgument): void;
    /**
     * Set denylist status for an OApp sender (owner only)
     * @param tx - The transaction to add the move call to
     * @param ownerCap - The owner capability object ID
     * @param oapp - The OApp address
     * @param denied - Whether to deny or remove from denylist
     */
    setDenylistMoveCall(tx: Transaction, ownerCap: string | TransactionArgument, oapp: string | TransactionArgument, denied: boolean | TransactionArgument): void;
    /**
     * Set worker paused state (owner only)
     * @param tx - The transaction to add the move call to
     * @param ownerCap - The owner capability object ID
     * @param paused - Whether to pause or unpause the worker
     */
    setPausedMoveCall(tx: Transaction, ownerCap: string | TransactionArgument, paused: boolean | TransactionArgument): void;
    /**
     * Get the size of the allowlist
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the allowlist size
     */
    allowlistSizeMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the size of the allowlist
     * @returns Promise<bigint> - The number of addresses in the allowlist
     */
    allowlistSize(): Promise<bigint>;
    /**
     * Get default multiplier basis points
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the default multiplier bps
     */
    defaultMultiplierBpsMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get default multiplier basis points
     * @returns Promise<number> - The default multiplier in basis points
     */
    defaultMultiplierBps(): Promise<number>;
    /**
     * Get executor deposit address for fee collection
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the deposit address
     */
    depositAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get executor deposit address for fee collection
     * @returns Promise<string> - The deposit address
     */
    depositAddress(): Promise<string>;
    /**
     * Get destination configuration for executor
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the destination configuration
     */
    dstConfigMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get destination configuration for executor
     * @param dstEid - Destination endpoint ID
     * @returns Promise<DstConfig> - The destination configuration
     */
    dstConfig(dstEid: number): Promise<DstConfig>;
    /**
     * Check if an address has ACL (Access Control List) permission
     * @param tx - The transaction to add the move call to
     * @param account - The account address to check
     * @returns Transaction result containing the ACL permission status
     */
    hasAclMoveCall(tx: Transaction, account: string): TransactionResult;
    /**
     * Check if an address has ACL (Access Control List) permission
     * @param account - The account address to check
     * @returns Promise<boolean> - True if the address has ACL permission
     */
    hasAcl(account: string): Promise<boolean>;
    /**
     * Get all registered executor admins
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing array of admin addresses
     */
    adminsMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get all registered executor admins
     * @returns Promise<string[]> - Array of admin addresses
     */
    admins(): Promise<string[]>;
    /**
     * Check if an admin cap is valid (sync Move call)
     * @param tx - The transaction to add the move call to
     * @param adminCap - The admin capability object ID to check
     * @returns TransactionResult - Result containing admin status
     */
    isAdminMoveCall(tx: Transaction, adminCap: string | TransactionArgument): TransactionResult;
    /**
     * Check if an admin cap is valid (async simulation)
     * @param adminCap - The admin capability object ID to check
     * @returns Promise<boolean> - True if the admin cap is valid
     */
    isAdmin(adminCap: string): Promise<boolean>;
    /**
     * Check if an address is an admin
     * @param tx - The transaction to add the move call to
     * @param admin - The admin address to check
     * @returns Transaction result containing the admin status
     */
    isAdminAddressMoveCall(tx: Transaction, admin: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address is an admin
     * @param admin - The admin address to check
     * @returns Promise<boolean> - True if the address is an admin
     */
    isAdminAddress(admin: string): Promise<boolean>;
    /**
     * Check if a message library is supported by this executor
     * @param tx - The transaction to add the move call to
     * @param messageLib - The message library address to check
     * @returns Transaction result containing the support status
     */
    isSupportedMessageLibMoveCall(tx: Transaction, messageLib: string | TransactionArgument): TransactionResult;
    /**
     * Check if a message library is supported by this executor
     * @param messageLib - The message library address to check
     * @returns Promise<boolean> - True if the message library is supported
     */
    isSupportedMessageLib(messageLib: string): Promise<boolean>;
    /**
     * Check if an address is allowlisted
     * @param tx - The transaction to add the move call to
     * @param account - The account address to check
     * @returns Transaction result containing the allowlist status
     */
    isAllowlistedMoveCall(tx: Transaction, account: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address is in the allowlist
     * @param account - The account address to check
     * @returns Promise<boolean> - True if the address is allowlisted
     */
    isAllowlisted(account: string): Promise<boolean>;
    /**
     * Check if an address is denylisted
     * @param tx - The transaction to add the move call to
     * @param account - The account address to check
     * @returns Transaction result containing the denylist status
     */
    isDenylistedMoveCall(tx: Transaction, account: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address is in the denylist
     * @param account - The account address to check
     * @returns Promise<boolean> - True if the address is denylisted
     */
    isDenylisted(account: string): Promise<boolean>;
    /**
     * Check if executor worker is paused
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the paused status
     */
    isPausedMoveCall(tx: Transaction): TransactionResult;
    /**
     * Check if executor worker is paused
     * @returns Promise<boolean> - True if the worker is paused
     */
    isPaused(): Promise<boolean>;
    /**
     * Get executor price feed address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the price feed address
     */
    priceFeedMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get executor price feed address
     * @returns Promise<string> - The price feed address
     */
    priceFeed(): Promise<string>;
    /**
     * Get supported option types for a destination EID
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing supported option types
     */
    supportedOptionTypesMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get supported option types for a destination EID
     * @param dstEid - Destination endpoint ID
     * @returns Promise<number[]> - Array of supported option types as bytes
     */
    supportedOptionTypes(dstEid: number): Promise<number[]>;
    /**
     * Get executor worker capability address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the worker capability address
     */
    workerCapAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get executor worker capability address
     * @returns Promise<string> - The worker capability address
     */
    workerCapAddress(): Promise<string>;
    /**
     * Get executor worker fee library address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the worker fee library address
     */
    workerFeeLibMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get executor worker fee library address
     * @returns Promise<string> - The worker fee library address
     */
    workerFeeLib(): Promise<string>;
    /**
     * Get admin capability ID from admin address
     * @param tx - The transaction to add the move call to
     * @param admin - The admin address
     * @returns Transaction result containing the admin capability ID
     */
    adminCapIdMoveCall(tx: Transaction, admin: string | TransactionArgument): TransactionResult;
    /**
     * Get admin capability ID from admin address
     * @param admin - The admin address
     * @returns Promise<string> - The admin capability ID
     */
    adminCapId(admin: string): Promise<string>;
    /**
     * Get Executor object address from worker registry using this Executor's worker capability (as a move call)
     * This function chains Move calls to decode worker info and extract the Executor object address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the Executor object address
     */
    getExecutorObjectAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get Executor object address from worker registry using this Executor's worker capability
     * This function uses Move calls to decode worker info and extract the Executor object address
     * @returns Promise<string> - The Executor object address
     * @throws Will throw an error if worker info is not found or if decoding fails
     */
    getExecutorObjectAddress(): Promise<string>;
    private parseDstConfig;
}

declare const ExecutorFeeLibErrorCode: {
    readonly ExecutorFeeLib_EEidNotSupported: 1;
    readonly ExecutorOption_ENoOptions: 1;
    readonly ExecutorOption_EUnsupportedOptionType: 2;
    readonly ExecutorOption_EZeroLzReceiveGasProvided: 3;
    readonly ExecutorOption_EZeroLzComposeGasProvided: 4;
    readonly ExecutorOption_ENativeAmountExceedsCap: 5;
    readonly ExecutorOption_EInvalidLzReceiveOption: 6;
    readonly ExecutorOption_EInvalidNativeDropOption: 7;
    readonly ExecutorOption_EInvalidLzComposeOption: 8;
};
declare class ExecutorFeeLib {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Create a LayerZero witness for Executor Fee Lib package whitelist registration
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the LayerZero witness
     */
    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult;
    /**
     * Create get fee move call for executor fee calculation
     * Note: This is typically called by the Executor, not directly by users
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing fee parameters
     * @returns Transaction result containing the fee calculation call
     */
    getFeeMoveCall(tx: Transaction, call: TransactionArgument): TransactionResult;
    /**
     * Confirm get fee move call with price feed integration
     * Note: This is typically called by the Executor, not directly by users
     * @param tx - The transaction to add the move call to
     * @param feelibCall - The fee library call transaction result
     * @param priceFeedCall - The price feed call transaction result
     */
    confirmGetFeeMoveCall(tx: Transaction, feelibCall: TransactionArgument, priceFeedCall: TransactionArgument): void;
}

declare const ExecutorLayerzeroErrorCode: {
    readonly ExecutorLayerzero_EWorkerCapNotFromPackage: 1;
};
declare class ExecutorLayerZero {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    constructor(packageId: string, client: SuiClient, moduleManager: ModuleManager);
    /**
     * Initialize Executor LayerZero instance
     * Creates and shares a new Executor with the specified configuration
     * @param tx - The transaction to add the move call to
     * @param workerCap - Worker capability object ID or transaction argument
     * @param depositAddress - Address for fee deposits or transaction argument
     * @param supportedMessageLibs - Array of supported message library addresses or transaction argument
     * @param priceFeed - Price feed object address or transaction argument
     * @param workerFeeLib - Worker fee library address or transaction argument
     * @param defaultMultiplierBps - Default multiplier in basis points or transaction argument
     * @param owner - Owner address for the executor or transaction argument
     * @param admins - Array of admin addresses or transaction argument
     */
    initExecutorMoveCall(tx: Transaction, workerCap: string | TransactionArgument, depositAddress: string | TransactionArgument, supportedMessageLibs: string[] | TransactionArgument, priceFeed: string | TransactionArgument, workerFeeLib: string | TransactionArgument, defaultMultiplierBps: number | TransactionArgument, owner: string | TransactionArgument, admins: string[] | TransactionArgument): void;
}

declare const PriceFeedErrorCode: {
    readonly PRICE_FEED_EInvalidDenominator: 1;
    readonly PRICE_FEED_ENoPrice: 2;
    readonly PRICE_FEED_ENotAnOPStack: 3;
    readonly PRICE_FEED_EOnlyPriceUpdater: 4;
    readonly PRICE_FEED_EPriceUpdaterCapNotFound: 5;
};
declare class PriceFeed {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Create price configuration object
     * @param tx - The transaction to add the move call to
     * @param priceRatio - Price ratio value or transaction argument
     * @param gasPriceInUnit - Gas price in unit or transaction argument
     * @param gasPerByte - Gas per byte value or transaction argument
     * @returns Transaction result containing the price object
     */
    createPriceMoveCall(tx: Transaction, priceRatio: bigint | number | string | TransactionArgument, gasPriceInUnit: bigint | number | string | TransactionArgument, gasPerByte: number | TransactionArgument): TransactionResult;
    /**
     * Create Arbitrum price extension object
     * @param tx - The transaction to add the move call to
     * @param gasPerL2Tx - Gas per L2 transaction or transaction argument
     * @param gasPerL1CallDataByte - Gas per L1 call data byte or transaction argument
     * @returns Transaction result containing the Arbitrum price extension object
     */
    createArbitrumPriceExtMoveCall(tx: Transaction, gasPerL2Tx: bigint | number | string | TransactionArgument, gasPerL1CallDataByte: number | TransactionArgument): TransactionResult;
    /**
     * Get price model type move call result
     * @param tx - The transaction to add the move call to
     * @param modelType - The price model type enum value
     * @returns Transaction result containing the model type
     */
    getModelTypeMoveCall(tx: Transaction, modelType: ModelType): TransactionResult;
    /**
     * Set price updater role for an address (admin only)
     * Note: This function will automatically create a price updater capability for new updaters
     * @param tx - The transaction to add the move call to
     * @param updater - The updater address or transaction argument
     * @param active - Whether to activate or deactivate the updater role or transaction argument
     */
    setPriceUpdaterMoveCall(tx: Transaction, updater: string | TransactionArgument, active: boolean | TransactionArgument): void;
    /**
     * Set price ratio denominator for price calculations (admin only)
     * Note: denominator must be greater than 0, otherwise the transaction will fail
     * @param tx - The transaction to add the move call to
     * @param denominator - The price ratio denominator value or transaction argument (must be > 0)
     */
    setPriceRatioDenominatorMoveCall(tx: Transaction, denominator: bigint | number | string | TransactionArgument): void;
    /**
     * Set Arbitrum compression percentage (admin only)
     * @param tx - The transaction to add the move call to
     * @param compressionPercent - The compression percentage for Arbitrum or transaction argument
     */
    setArbitrumCompressionPercentMoveCall(tx: Transaction, compressionPercent: bigint | number | string | TransactionArgument): void;
    /**
     * Set price model type for a destination EID (admin only)
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID or transaction argument
     * @param modelType - The price model type to set
     */
    setEidToModelTypeMoveCall(tx: Transaction, dstEid: number | TransactionArgument, modelType: ModelType): void;
    /**
     * Set price for a destination EID (price updater capability required)
     * @param tx - The transaction to add the move call to
     * @param updaterCap - The price updater capability object or transaction argument
     * @param dstEid - Destination endpoint ID or transaction argument
     * @param price - The price configuration to set
     */
    setPriceMoveCall(tx: Transaction, updaterCap: string | TransactionArgument, dstEid: number | TransactionArgument, price: Price): void;
    /**
     * Set price for Arbitrum with additional extension parameters (price updater capability required)
     * @param tx - The transaction to add the move call to
     * @param updaterCap - The price updater capability object or transaction argument
     * @param dstEid - Destination endpoint ID
     * @param price - The base price configuration
     * @param arbitrumPriceExt - Additional Arbitrum-specific price parameters
     */
    setPriceForArbitrumMoveCall(tx: Transaction, updaterCap: string | TransactionArgument, dstEid: number | TransactionArgument, price: Price, arbitrumPriceExt: ArbitrumPriceExt): void;
    /**
     * Set native token price in USD (price updater capability required)
     * @param tx - The transaction to add the move call to
     * @param updaterCap - The price updater capability object or transaction argument
     * @param nativeTokenPriceUsd - The native token price in USD
     */
    setNativeTokenPriceUsdMoveCall(tx: Transaction, updaterCap: string | TransactionArgument, nativeTokenPriceUsd: bigint | number | string | TransactionArgument): void;
    /**
     * Create a LayerZero witness for PriceFeed package whitelist registration
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the LayerZero witness
     */
    createLayerZeroWitnessMoveCall(tx: Transaction): TransactionResult;
    /**
     * Estimate fee by endpoint ID using a call result
     * @param tx - The transaction to add the move call to
     * @param call - The call transaction result containing fee parameters
     */
    estimateFeeByEidMoveCall(tx: Transaction, call: TransactionResult): void;
    /**
     * Get owner capability address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the owner capability address
     */
    getOwnerCapMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get price updater capability address for a specific updater
     * @param tx - The transaction to add the move call to
     * @param updater - The updater address to get capability for
     * @returns Transaction result containing the price updater capability address
     */
    getPriceUpdaterCapMoveCall(tx: Transaction, updater: string | TransactionArgument): TransactionResult;
    /**
     * Get the owner capability address of this PriceFeed
     * @returns Promise<string> - The owner capability address
     */
    ownerCap(): Promise<string>;
    /**
     * Get price updater capability address for a specific updater
     * @param updater - The updater address to get capability for
     * @returns Promise<string> - The price updater capability address
     */
    priceUpdaterCap(updater: string): Promise<string>;
    /**
     * Check if an address is a price updater
     * @param tx - The transaction to add the move call to
     * @param updater - The updater address to check
     * @returns Transaction result containing the price updater status
     */
    isPriceUpdaterMoveCall(tx: Transaction, updater: string | TransactionArgument): TransactionResult;
    /**
     * Check if an address is a price updater
     * @param updater - The updater address to check
     * @returns Promise<boolean> - True if the address is a price updater
     */
    isPriceUpdater(updater: string): Promise<boolean>;
    /**
     * Get price ratio denominator
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the price ratio denominator
     */
    priceRatioDenominatorMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get price ratio denominator
     * @returns Promise<bigint> - The price ratio denominator value
     */
    priceRatioDenominator(): Promise<bigint>;
    /**
     * Get Arbitrum compression percentage
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the compression percentage
     */
    arbitrumCompressionPercentMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get Arbitrum compression percentage
     * @returns Promise<bigint> - The compression percentage value
     */
    arbitrumCompressionPercent(): Promise<bigint>;
    /**
     * Get model type for a destination EID
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the model type
     */
    modelTypeMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get model type for a destination EID
     * @param dstEid - Destination endpoint ID
     * @returns Promise<PriceModelType> - The price model type
     */
    modelType(dstEid: number): Promise<ModelType>;
    /**
     * Get native token price in USD
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the native token price in USD
     */
    nativeTokenPriceUsdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get native token price in USD
     * @returns Promise<bigint> - The native token price in USD
     */
    nativeTokenPriceUsd(): Promise<bigint>;
    /**
     * Get Arbitrum price extension parameters
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing Arbitrum price extension
     */
    arbitrumPriceExtMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get Arbitrum price extension parameters
     * @returns Promise<ArbitrumPriceExt> - The Arbitrum price extension configuration
     */
    arbitrumPriceExt(): Promise<ArbitrumPriceExt>;
    /**
     * Get price for a specific destination EID
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the price configuration
     */
    priceMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get price for a specific destination EID
     * @param dstEid - Destination endpoint ID
     * @returns Promise<Price> - The price configuration for the destination
     */
    price(dstEid: number): Promise<Price>;
}

declare const TreasuryErrorCode: {
    readonly TREASURY_EInvalidFeeRecipient: 1;
    readonly TREASURY_EInvalidNativeFeeBp: 2;
    readonly TREASURY_EZroNotEnabled: 3;
};
declare class Treasury {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Set fee recipient address for treasury (admin only)
     * @param tx - The transaction to add the move call to
     * @param feeRecipient - The new fee recipient address or transaction argument
     */
    setFeeRecipientMoveCall(tx: Transaction, feeRecipient: string | TransactionArgument): void;
    /**
     * Set native fee basis points for treasury (admin only)
     * @param tx - The transaction to add the move call to
     * @param nativeFeeBp - The native fee in basis points or transaction argument
     */
    setNativeFeeBpMoveCall(tx: Transaction, nativeFeeBp: bigint | number | string | TransactionArgument): void;
    /**
     * Set ZRO token fee for treasury (admin only)
     * @param tx - The transaction to add the move call to
     * @param zroFee - The ZRO token fee amount or transaction argument
     */
    setZroFeeMoveCall(tx: Transaction, zroFee: bigint | number | string | TransactionArgument): void;
    /**
     * Enable or disable ZRO token fees (admin only)
     * @param tx - The transaction to add the move call to
     * @param zroEnabled - Whether ZRO token fees are enabled or transaction argument
     */
    setZroEnabledMoveCall(tx: Transaction, zroEnabled: boolean | TransactionArgument): void;
    /**
     * Enable or disable treasury fees (admin only)
     * @param tx - The transaction to add the move call to
     * @param feeEnabled - Whether treasury fees are enabled or transaction argument
     */
    setFeeEnabledMoveCall(tx: Transaction, feeEnabled: boolean | TransactionArgument): void;
    /**
     * Calculate treasury fees for a transaction
     * @param tx - The transaction to add the move call to
     * @param totalNativeFee - Total native fee amount or transaction argument
     * @param payInZro - Whether to pay in ZRO tokens or transaction argument
     * @returns Transaction result containing calculated fees
     */
    getFeeMoveCall(tx: Transaction, totalNativeFee: bigint | number | string | TransactionArgument, payInZro: boolean | TransactionArgument): TransactionResult;
    /**
     * Calculate treasury fees for a transaction
     * @param totalNativeFee - Total native fee amount
     * @param payInZro - Whether to pay in ZRO tokens
     * @returns Promise<[bigint, bigint]> - Tuple of [nativeFee, zroFee]
     */
    getFee(totalNativeFee: bigint, payInZro: boolean): Promise<[bigint, bigint]>;
    /**
     * Get treasury fee recipient address
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the fee recipient address
     */
    feeRecipientMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get treasury fee recipient address
     * @returns Promise<string> - The fee recipient address
     */
    feeRecipient(): Promise<string>;
    /**
     * Get native fee basis points
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the native fee basis points
     */
    nativeFeeBpMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get native fee basis points
     * @returns Promise<bigint> - The native fee in basis points
     */
    nativeFeeBp(): Promise<bigint>;
    /**
     * Get ZRO token fee amount
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the ZRO fee
     */
    zroFeeMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get ZRO token fee amount
     * @returns Promise<bigint> - The ZRO token fee
     */
    zroFee(): Promise<bigint>;
    /**
     * Check if ZRO token fees are enabled
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the ZRO enabled status
     */
    zroEnabledMoveCall(tx: Transaction): TransactionResult;
    /**
     * Check if ZRO token fees are enabled
     * @returns Promise<boolean> - True if ZRO fees are enabled
     */
    zroEnabled(): Promise<boolean>;
    /**
     * Check if treasury fees are enabled
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the fee enabled status
     */
    feeEnabledMoveCall(tx: Transaction): TransactionResult;
    /**
     * Check if treasury fees are enabled
     * @returns Promise<boolean> - True if treasury fees are enabled
     */
    feeEnabled(): Promise<boolean>;
}

declare const WorkerRegistryErrorCode: {
    readonly EWorkerInfoInvalid: 1;
    readonly EWorkerInfoNotFound: 2;
};
/**
 * WorkerRegistry provides access to the worker registry contract functionality
 * This module maintains mappings between worker addresses and their associated information.
 */
declare class WorkerRegistry {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    /**
     * Create a new WorkerRegistry instance
     * @param packageId - The package ID of the worker registry contract
     * @param client - The Sui client instance
     * @param objects - Object options containing contract object IDs
     * @param moduleManager - Module manager for handling dependencies
     */
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Get worker info for a specific worker address (as a move call)
     * This creates a move call that can be used in a PTB (Programmable Transaction Block)
     * @param tx - The transaction to add the move call to
     * @param worker - The worker address or transaction argument
     * @returns TransactionResult - The move call result containing worker info bytes
     * @throws Will throw an error if worker info is not found (EWorkerInfoNotFound)
     */
    getWorkerInfoMoveCall(tx: Transaction, worker: string | TransactionArgument): TransactionResult;
    /**
     * Get worker info for a specific worker address
     * Executes the get_worker_info function and returns the worker information bytes
     * @param worker - The worker address to get info for
     * @returns Promise<Uint8Array> - The worker information bytes containing encoded worker data
     * @throws Will throw an error if worker info is not found (EWorkerInfoNotFound)
     */
    getWorkerInfo(worker: string): Promise<Uint8Array>;
    /**
     * Check if worker info exists for a specific worker address
     * This is a convenience method that catches EWorkerInfoNotFound errors
     * @param worker - The worker address to check
     * @returns Promise<boolean> - True if worker info exists, false if not found
     * @throws Will re-throw any errors other than EWorkerInfoNotFound
     */
    hasWorkerInfo(worker: string): Promise<boolean>;
}

declare class DvnPtbBuilder {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Creates a transaction to build DVN PTB
     * @param tx - The transaction to add the move call to
     * @param dvnAddress - DVN object address or transaction argument
     * @param feelibAddress - DVN fee lib object address or transaction argument
     * @param priceFeedAddress - Price feed object address or transaction argument
     * @returns Transaction result containing get_fee and assign_job move calls
     */
    buildDvnPtbMoveCall(tx: Transaction, dvnAddress: string | TransactionArgument, feelibAddress: string | TransactionArgument, priceFeedAddress: string | TransactionArgument): TransactionResult;
}

declare const EndpointPtbBuilderErrorCode: {
    readonly EndpointPtbBuilder_EBuilderNotFound: 1;
    readonly EndpointPtbBuilder_EBuilderRegistered: 2;
    readonly EndpointPtbBuilder_EBuilderUnsupported: 3;
    readonly EndpointPtbBuilder_EInvalidBounds: 4;
    readonly EndpointPtbBuilder_EInvalidBuilderAddress: 5;
    readonly EndpointPtbBuilder_EInvalidLibrary: 6;
    readonly EndpointPtbBuilder_EUnauthorized: 7;
};
declare class EndpointPtbBuilder {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Creates a transaction to register a message library PTB builder
     * @param tx - The transaction to add the move call to
     * @param builderInfo - PTB builder info result from getPtbBuilderInfoMoveCall or transaction argument
     */
    registerMsglibPtbBuilderMoveCall(tx: Transaction, builderInfo: TransactionArgument): void;
    /**
     * Creates a transaction to set the default message library PTB builder
     * @param tx - The transaction to add the move call to
     * @param messageLib - Target message library address
     * @param ptbBuilder - PTB builder address
     */
    setDefaultMsglibPtbBuilderMoveCall(tx: Transaction, messageLib: string | TransactionArgument, ptbBuilder: string | TransactionArgument): void;
    /**
     * Creates a transaction to set message library PTB builder for an OApp
     * @param tx - The transaction to add the move call to
     * @param call - Call object for setting msglib PTB builder
     */
    setMsglibPtbBuilderMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Build quote PTB by call for fee calculation
     * @param tx - The transaction to add the move call to
     * @param endpointQuoteCall - Endpoint quote call result
     * @returns Transaction result containing the quote PTB
     */
    buildQuotePtbByCallMoveCall(tx: Transaction, endpointQuoteCall: TransactionArgument): TransactionResult;
    /**
     * Build send PTB by call for message transmission
     * @param tx - The transaction to add the move call to
     * @param endpointSendCall - Endpoint send call result
     * @returns Transaction result containing the send PTB
     */
    buildSendPtbByCallMoveCall(tx: Transaction, endpointSendCall: TransactionArgument): TransactionResult;
    /**
     * Build set config PTB by call for configuration updates
     * @param tx - The transaction to add the move call to
     * @param messageLibSetConfigCall - Endpoint set config call result
     * @returns Transaction result containing the set config PTB
     */
    buildSetConfigPtbByCallMoveCall(tx: Transaction, messageLibSetConfigCall: TransactionArgument): TransactionResult;
    /**
     * Build quote PTB for on-chain composition
     * @param tx - The transaction to add the move call to
     * @param sender - Sender address
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the quote PTB
     */
    buildQuotePtbMoveCall(tx: Transaction, sender: string | TransactionArgument, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Build send PTB for on-chain composition
     * @param tx - The transaction to add the move call to
     * @param sender - Sender address
     * @param dstEid - Destination endpoint ID
     * @param refund - Whether to include refund step
     * @returns Transaction result containing the send PTB
     */
    buildSendPtbMoveCall(tx: Transaction, sender: string | TransactionArgument, dstEid: number | TransactionArgument, refund: boolean | TransactionArgument): TransactionResult;
    /**
     * Build set config PTB for on-chain composition
     * @param tx - The transaction to add the move call to
     * @param sender - Sender address
     * @param lib - Message library address
     * @returns Transaction result containing the set config PTB
     */
    buildSetConfigPtbMoveCall(tx: Transaction, sender: string | TransactionArgument, lib: string | TransactionArgument): TransactionResult;
    /**
     * Get endpoint quote call ID
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the endpoint quote call ID
     */
    endpointQuoteCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get endpoint quote call ID as a hex string
     * @returns Promise<string> - The endpoint quote call ID in hex format
     */
    endpointQuoteCallId(): Promise<string>;
    /**
     * Get endpoint send call ID
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the endpoint send call ID
     */
    endpointSendCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get endpoint send call ID as a hex string
     * @returns Promise<string> - The endpoint send call ID in hex format
     */
    endpointSendCallId(): Promise<string>;
    /**
     * Get message lib quote call ID
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the message lib quote call ID
     */
    messageLibQuoteCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get message lib quote call ID as a hex string
     * @returns Promise<string> - The message lib quote call ID in hex format
     */
    messageLibQuoteCallId(): Promise<string>;
    /**
     * Get message lib send call ID
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the message lib send call ID
     */
    messageLibSendCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get message lib send call ID as a hex string
     * @returns Promise<string> - The message lib send call ID in hex format
     */
    messageLibSendCallId(): Promise<string>;
    /**
     * Get message lib set config call ID
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the message lib set config call ID
     */
    messageLibSetConfigCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get message lib set config call ID as a hex string
     * @returns Promise<string> - The message lib set config call ID in hex format
     */
    messageLibSetConfigCallId(): Promise<string>;
    /**
     * Get the default message library PTB builder for a given library
     * @param tx - The transaction to add the move call to
     * @param lib - Message library address
     * @returns Transaction result containing the default PTB builder address
     */
    getDefaultMsglibPtbBuilderMoveCall(tx: Transaction, lib: string | TransactionArgument): TransactionResult;
    /**
     * Get the default message library PTB builder
     * @param lib - Message library address
     * @returns Promise<string> - The default PTB builder address
     */
    getDefaultMsglibPtbBuilder(lib: string): Promise<string>;
    /**
     * Get the OApp-specific message library PTB builder
     * @param tx - The transaction to add the move call to
     * @param oapp - OApp address or transaction argument
     * @param lib - Message library address or transaction argument
     * @returns Transaction result containing the OApp-specific PTB builder address
     */
    getOappMsglibPtbBuilderMoveCall(tx: Transaction, oapp: string | TransactionArgument, lib: string | TransactionArgument): TransactionResult;
    /**
     * Get the OApp-specific message library PTB builder
     * @param oapp - OApp address
     * @param lib - Message library address
     * @returns Promise<string> - The OApp PTB builder address
     */
    getOappMsglibPtbBuilder(oapp: string, lib: string): Promise<string>;
    /**
     * Get the effective message library PTB builder (OApp-specific or default)
     * @param tx - The transaction to add the move call to
     * @param oapp - OApp address
     * @param lib - Message library address
     * @returns Transaction result containing the effective PTB builder address
     */
    getEffectiveMsglibPtbBuilderMoveCall(tx: Transaction, oapp: string | TransactionArgument, lib: string | TransactionArgument): TransactionResult;
    /**
     * Get the effective message library PTB builder
     * @param oapp - OApp address
     * @param lib - Message library address
     * @returns Promise<string> - The effective PTB builder address
     */
    getEffectiveMsglibPtbBuilder(oapp: string, lib: string): Promise<string>;
    /**
     * Get detailed information about a registered message library PTB builder
     * @param tx - The transaction to add the move call to
     * @param builder - PTB builder address
     * @returns Transaction result containing the PTB builder information
     */
    getMsglibPtbBuilderInfoMoveCall(tx: Transaction, builder: string | TransactionArgument): TransactionResult;
    /**
     * Check if a message library PTB builder is registered
     * @param tx - The transaction to add the move call to
     * @param builder - PTB builder address
     * @returns Transaction result containing boolean registration status
     */
    isMsglibPtbBuilderRegisteredMoveCall(tx: Transaction, builder: string | TransactionArgument): TransactionResult;
    /**
     * Checks if a PTB builder is registered
     * @param builder - PTB builder address
     * @returns Promise<boolean> - Whether the builder is registered
     */
    isMsglibPtbBuilderRegistered(builder: string): Promise<boolean>;
    /**
     * Get the count of registered message library PTB builders
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the count of registered builders
     */
    registeredMsglibPtbBuildersCountMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the total number of registered PTB builders
     * @returns Promise<number> - The count of registered builders
     */
    registeredMsglibPtbBuildersCount(): Promise<number>;
}

declare class ExecutorPtbBuilder {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Creates a transaction to build Executor PTB
     * @param tx - The transaction to add the move call to
     * @param executorAddress - Executor object address or transaction argument
     * @param feelibAddress - Executor fee lib object address or transaction argument
     * @param priceFeedAddress - Price feed object address or transaction argument
     * @returns Transaction result containing get_fee and assign_job move calls
     */
    buildExecutorPtbMoveCall(tx: Transaction, executorAddress: string | TransactionArgument, feelibAddress: string | TransactionArgument, priceFeedAddress: string | TransactionArgument): TransactionResult;
}

declare const ValidatorErrorCode: {
    readonly EInvalidWitness: 1;
};
declare class PackageWhitelistValidator {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Add a package to the whitelist using a LayerZero witness
     * This function is permissionless and allows packages to self-register
     * by providing a valid LayerZeroWitness type
     * @param tx - The transaction to add the move call to
     * @param witness - The LayerZero witness from the package
     * @template T - The witness type that must be named "_witness::LayerZeroWitness"
     */
    addWhitelistMoveCall(tx: Transaction, witness: TransactionArgument, witnessType: string): void;
    /**
     * Check if a package is whitelisted
     * @param tx - The transaction to add the move call to
     * @param packageAddress - The package address to check
     * @returns Transaction result containing the whitelist status
     */
    isWhitelistedMoveCall(tx: Transaction, packageAddress: string | TransactionArgument): TransactionResult;
    /**
     * Validate multiple packages at once
     * @param tx - The transaction to add the move call to
     * @param packageAddresses - Array of package addresses to validate
     * @returns Transaction result containing the validation status
     */
    validateMoveCall(tx: Transaction, packageAddresses: string[]): TransactionResult;
    /**
     * Check if a package is whitelisted
     * @param packageAddress - The package address to check
     * @returns Promise<boolean> - True if the package is whitelisted
     */
    isWhitelisted(packageAddress: string): Promise<boolean>;
    /**
     * Extract package ID from a witness type name
     * @param witnessTypeName - The full type name of the witness
     * @returns string | null - The package ID if extraction is successful
     */
    extractPackageFromWitness(witnessTypeName: string): string | null;
    /**
     * Validate multiple packages at once using the contract's validate function
     * @param packageAddresses - Array of package addresses to validate
     * @returns Promise<boolean> - True if all packages are whitelisted
     */
    validate(packageAddresses: string[]): Promise<boolean>;
}

declare const PtbBuilderErrorCode: {
    readonly MoveCallsBuilder_EInvalidMoveCallResult: 1;
    readonly MoveCallsBuilder_EResultIDNotFound: 2;
    readonly Argument_EInvalidArgument: 1;
};
declare class PtbBuilder {
    #private;
    packageId: string;
    readonly client: SuiClient;
    constructor(packageId: string, client: SuiClient);
    /**
     * Simulate a transaction and decode the resulting move calls
     * @param tx - The transaction to simulate
     * @param sender - Optional sender address for simulation context
     * @returns Promise resolving to array of decoded move calls
     */
    simulatePtb(tx: Transaction, sender?: string): Promise<MoveCall[]>;
    /**
     * Simulate a LayerZero receive transaction and decode the move calls
     * Handles versioned receive data and decodes based on version
     * @param tx - The transaction to simulate
     * @param sender - Optional sender address for simulation context
     * @returns Promise resolving to array of decoded move calls
     * @throws Error if unsupported version is encountered
     */
    simulateLzReceivePtb(tx: Transaction, sender?: string): Promise<MoveCall[]>;
    /**
     * Simulate a LayerZero compose transaction and decode the move calls
     * Handles versioned compose data and decodes based on version
     * @param tx - The transaction to simulate
     * @param sender - Optional sender address for simulation context
     * @returns Promise resolving to array of decoded move calls
     * @throws Error if unsupported version is encountered
     */
    simulateLzComposePtb(tx: Transaction, sender?: string): Promise<MoveCall[]>;
    /**
     * Builds PTB with move-calls simulated from the transaction
     *
     * This method processes an array of move calls, handling both regular calls and builder calls
     * (which require simulation to expand into actual move calls). It ensures all object arguments
     * are properly validated for PTB compatibility.
     *
     * @param tx - The transaction to append move calls to
     * @param moveCalls - Array of move calls to process and build
     * @param resolutionIDs - Cache mapping call IDs to their transaction results for argument resolution (defaults to empty Map)
     * @param sender - Optional sender address for simulation context (defaults to undefined)
     * @param maxSimulationTimes - Maximum number of simulations allowed for builder calls (defaults to DEFAULT_SIMULATION_TIMES)
     * @param nestedResult - Array storing results from previous calls for NestedResult argument resolution (internal use, defaults to empty array)
     * @param baseOffset - Base offset for calculating nested result indices (internal use, defaults to 0)
     *
     * @returns Promise<[number, MoveCall[]]> - [moveCallCount, finalMoveCalls] tuple
     *
     * @throws Error if simulation limit is exceeded, nested results are unavailable, or objects are not PTB-compatible
     */
    buildPtb(tx: Transaction, moveCalls: MoveCall[], resolutionIDs?: Map<string, TransactionResult>, // ID -> TransactionResult
    sender?: string | undefined, maxSimulationTimes?: number, nestedResult?: TransactionResult[], baseOffset?: number): Promise<[number, MoveCall[]]>;
}

declare class SimpleMessageLibPtbBuilder {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Creates a transaction to get PTB builder info
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing PTB builder information
     */
    getPtbBuilderInfoMoveCall(tx: Transaction): TransactionResult;
}

declare const Uln302PtbBuilderErrorCode: {
    readonly Uln302PtbBuilder_EWorkerPtbsNotFound: 1;
};
declare class Uln302PtbBuilder {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Set worker PTBs for ULN302 PTB builder
     * @param tx - The transaction to add the move call to
     * @param call - Call object from worker's set_worker_ptbs or transaction argument
     */
    setWorkerPtbsMoveCall(tx: Transaction, call: TransactionArgument): void;
    /**
     * Creates a transaction to get PTB builder info
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing PTB builder information
     */
    getPtbBuilderInfoMoveCall(tx: Transaction): TransactionResult;
    /**
     * Check if worker PTBs are set for a specific worker capability
     * @param tx - The transaction to add the move call to
     * @param workerCap - Worker capability address to check or transaction argument
     * @returns Transaction result containing boolean indicating if PTBs are set
     */
    isWorkerPtbsSetMoveCall(tx: Transaction, workerCap: string | TransactionArgument): TransactionResult;
    /**
     * Check if worker PTBs are set for a specific worker capability
     * @param workerCap - Worker capability address to check
     * @returns Promise<boolean> - True if worker PTBs are set
     */
    isWorkerPtbsSet(workerCap: string): Promise<boolean>;
    /**
     * Get worker PTBs for a specific worker capability
     * @param tx - The transaction to add the move call to
     * @param workerCap - Worker capability address or transaction argument
     * @returns Transaction result containing the worker PTBs
     */
    getWorkerPtbsMoveCall(tx: Transaction, workerCap: string | TransactionArgument): TransactionResult;
    /**
     * Get the call ID for executor get fee operations
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the executor get fee call ID
     */
    executorGetFeeCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the executor get fee call ID as a hex string
     * @returns Promise<string> - The executor get fee call ID in hex format
     */
    executorGetFeeCallId(): Promise<string>;
    /**
     * Get the call ID for DVN get fee multi-call operations
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the DVN get fee multi-call ID
     */
    dvnGetFeeMultiCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the DVN get fee multi-call ID as a hex string
     * @returns Promise<string> - The DVN get fee multi-call ID in hex format
     */
    dvnGetFeeMultiCallId(): Promise<string>;
    /**
     * Get the call ID for executor assign job operations
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the executor assign job call ID
     */
    executorAssignJobCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the executor assign job call ID as a hex string
     * @returns Promise<string> - The executor assign job call ID in hex format
     */
    executorAssignJobCallId(): Promise<string>;
    /**
     * Get the call ID for DVN assign job multi-call operations
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the DVN assign job multi-call ID
     */
    dvnAssignJobMultiCallIdMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the DVN assign job multi-call ID as a hex string
     * @returns Promise<string> - The DVN assign job multi-call ID in hex format
     */
    dvnAssignJobMultiCallId(): Promise<string>;
}

declare class BlockedMessageLibPtbBuilder {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Creates a transaction to get PTB builder info
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing PTB builder information
     */
    getPtbBuilderInfoMoveCall(tx: Transaction): TransactionResult;
}

/**
 * Type guard to check if a value is already a TransactionArgument
 * TransactionArgument can be:
 * 1. Argument object with $kind property
 * 2. Synchronous function: (tx: Transaction) => Argument
 * 3. Asynchronous function: AsyncTransactionThunk
 */
declare function isTransactionArgument(value: unknown): value is TransactionArgument;
/**
 * Convert value to TransactionArgument using a simple converter function
 * @param value - The value to convert (primitive type or TransactionArgument)
 * @param converter - Function to convert primitive type to TransactionArgument
 * @returns TransactionArgument
 */
declare function asArg<T>(value: T | TransactionArgument, converter: (val: T) => TransactionArgument): TransactionArgument;
/**
 * Convert value to TransactionArgument using a converter that requires Transaction
 * @param tx - The transaction
 * @param value - The value to convert
 * @param converter - Function to convert value using transaction
 * @returns TransactionArgument
 */
declare function asArgWithTx<T>(tx: Transaction, value: T | TransactionArgument, converter: (tx: Transaction, val: T) => TransactionArgument): TransactionArgument;
/**
 * Async version: Convert value to TransactionArgument using an async converter that requires Transaction
 * @param tx - The transaction
 * @param value - The value to convert
 * @param converter - Async function to convert value using transaction
 * @returns Promise<TransactionArgument>
 */
declare function asArgWithTxAsync<T>(tx: Transaction, value: T | TransactionArgument, converter: (tx: Transaction, val: T) => Promise<TransactionArgument>): Promise<TransactionArgument>;
/**
 * Convert to object reference TransactionArgument
 */
declare function asObject(tx: Transaction, value: string | TransactionArgument): TransactionArgument;
/**
 * Convert to address TransactionArgument
 */
declare function asAddress(tx: Transaction, value: string | TransactionArgument): TransactionArgument;
/**
 * Convert to u8 TransactionArgument
 */
declare function asU8(tx: Transaction, value: number | TransactionArgument): TransactionArgument;
/**
 * Convert to u16 TransactionArgument
 */
declare function asU16(tx: Transaction, value: number | TransactionArgument): TransactionArgument;
/**
 * Convert to u32 TransactionArgument
 */
declare function asU32(tx: Transaction, value: number | TransactionArgument): TransactionArgument;
/**
 * Convert to u64 TransactionArgument (supports bigint, number, or string)
 */
declare function asU64(tx: Transaction, value: bigint | number | string | TransactionArgument): TransactionArgument;
/**
 * Convert to u128 TransactionArgument (supports bigint, number, or string)
 */
declare function asU128(tx: Transaction, value: bigint | number | string | TransactionArgument): TransactionArgument;
/**
 * Convert to u256 TransactionArgument (supports bigint, number, or string)
 */
declare function asU256(tx: Transaction, value: bigint | number | string | TransactionArgument): TransactionArgument;
/**
 * Convert Uint8Array to Bytes32 using moduleManager's fromBytesMoveCall
 * @param tx - The transaction
 * @param value - Uint8Array or TransactionArgument
 * @param utils - utils Module
 * @returns TransactionArgument
 */
declare function asBytes32(tx: Transaction, value: Uint8Array | TransactionArgument, utils: Utils): TransactionArgument;
/**
 * Convert Uint8Array to serialized bytes vector TransactionArgument
 * @param tx - The transaction
 * @param value - Uint8Array or TransactionArgument
 * @returns TransactionArgument
 */
declare function asBytes(tx: Transaction, value: Uint8Array | TransactionArgument): TransactionArgument;
/**
 * Convert Uint8Array Vector to serialized bytes vector TransactionArgument
 * @param tx - The transaction
 * @param value - Uint8Array or TransactionArgument
 * @returns TransactionArgument
 */
declare function asBytesVector(tx: Transaction, value: Uint8Array[] | TransactionArgument): TransactionArgument;
/**
 * Convert string to string TransactionArgument
 * @param tx - The transaction
 * @param value - string or TransactionArgument
 * @returns TransactionArgument
 */
declare function asString(tx: Transaction, value: string | TransactionArgument): TransactionArgument;
/**
 * Convert address array to serialized vector<address> TransactionArgument
 * @param tx - The transaction
 * @param value - string[] or TransactionArgument
 * @returns TransactionArgument
 */
declare function asAddressVector(tx: Transaction, value: string[] | TransactionArgument): TransactionArgument;
/**
 * Convert boolean to boolean TransactionArgument
 * @param tx - The transaction
 * @param value - boolean or TransactionArgument
 * @returns TransactionArgument
 */
declare function asBool(tx: Transaction, value: boolean | TransactionArgument): TransactionArgument;

declare function simulateTransaction(suiClient: SuiClient, tx: Transaction, sender?: string): Promise<SimulateResult[]>;
declare function simulateTransactionMultiResult(suiClient: SuiClient, tx: Transaction, resultIndex: number[], sender?: string): Promise<SimulateResult[][]>;
declare function validateTransaction(client: SuiClient, signer: Keypair, tx: Transaction): Promise<SuiTransactionBlockResponse>;
/**
 * Execute simulate using a moveCall function
 * @param client - The Sui client
 * @param moveCallFn - Function that adds moveCall to the transaction (supports both sync and async, any return type)
 * @param parser - Function to parse the result
 * @returns The parsed result
 */
declare function executeSimulate<T>(client: SuiClient, moveCallFn: (tx: Transaction) => unknown, parser: (result: {
    value: Uint8Array;
}[]) => T): Promise<T>;
declare function handleError(e: string): unknown;

/**
 * PackageAllowlistValidator ensures all function calls and objects belong to allowlisted packages
 * This validator checks that:
 * 1. All function calls target approved packages
 * 2. All object arguments come from approved packages
 *
 * If local packageWhitelist is empty, it will use the PTB whitelist contract for validation
 * If local packageWhitelist is provided, it will use only the local whitelist (contract is ignored)
 */
declare class PackageAllowlistValidator implements IPTBValidator {
    private packageWhitelist;
    private validator?;
    constructor(packageWhitelist?: string[], validator?: PackageWhitelistValidator);
    /**
     * Validates that all function calls and object arguments belong to whitelisted packages
     * @param moveCallsWithDetails - Array of move calls with object details
     * @throws Error if any function call or object belongs to a non-whitelisted package
     */
    validate(moveCallsWithDetails: MoveCallWithObjectDetails[]): Promise<void>;
    /**
     * Validate multiple packages at once
     * @param packages - Array of package IDs to validate
     * @returns Object mapping package ID to validation result
     */
    private validatePackages;
    /**
     * Extracts package ID from object type string
     * Object types are in format: "packageId::module::struct<generics>"
     * @param objectType - The object type string
     * @returns The package ID or null if extraction fails
     */
    private extractPackageIdFromType;
    /**
     * Get available packages for error messages
     */
    private getAvailablePackagesList;
}

/**
 * NonSenderObjectValidator ensures objects are not owned by the transaction sender
 *
 * In Sui, this validator checks that objects are:
 * - Shared: globally accessible, mutations require consensus
 * - Immutable: can't change after creation
 * - Owned by another address (not the sender)
 *
 * This prevents the sender from using their own owned objects in the transaction
 */
declare class NonSenderObjectValidator implements IPTBValidator {
    private sender;
    constructor(sender: string);
    /**
     * Validates that objects are not owned by the sender
     * @param moveCallsWithDetails - Array of move calls with object details
     * @throws Error if any object is owned by the sender
     */
    validate(moveCallsWithDetails: MoveCallWithObjectDetails[]): void;
    /**
     * Checks if the ownership is valid (not owned by sender)
     * @param owner - The object owner to check
     * @returns true if ownership is valid (Shared, Immutable, or owned by another address)
     */
    private isValidOwnership;
    /**
     * Gets a human-readable description of the ownership type
     * @param owner - The object owner
     * @returns String description of ownership type
     */
    private getOwnershipType;
}

/**
 * ShareObjectValidator ensures all object arguments are Shared or Immutable
 * This is the default validator for PTB operations
 */
declare class ShareObjectValidator implements IPTBValidator {
    /**
     * Validates move calls with pre-fetched object details
     * @param moveCallsWithDetails - Array of move calls with object details
     * @throws Error if any object is not Shared/Immutable
     */
    validate(moveCallsWithDetails: MoveCallWithObjectDetails[]): void;
    /**
     * Checks if an object owner is Shared or Immutable
     * @param owner - The object owner to check
     * @returns true if the owner is Shared or Immutable, false otherwise
     */
    protected isSharedOrImmutable(owner: ObjectOwner): boolean;
}

/**
 * Validates move calls using multiple validators with a single object fetch
 * @param client - SuiClient instance
 * @param moveCalls - Array of move calls to validate
 * @param validators - Array of validators to run
 * @param options - Options for what object data to fetch
 * @param batchSize - Batch size for object fetching
 */
declare function validateWithDetails(client: SuiClient, moveCalls: MoveCall[], validators: IPTBValidator[], sender?: string, userOptions?: ObjectFetchOptions, batchSize?: number): Promise<void>;

declare const CounterErrorCode: {
    readonly Counter_EInvalidMsgType: 0;
    readonly Counter_EInvalidValue: 1;
    readonly Counter_EInvalidNonce: 2;
    readonly Counter_EOnlyEndpoint: 3;
    readonly Counter_ESelfComposeOnly: 4;
    readonly Counter_EInvalidOApp: 5;
    readonly OptionsBuilder_EInvalidSize: 1;
};
declare class Counter {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Initialize counter with LayerZero receive and compose information
     * @param tx - The transaction to add the move call to
     * @param lzReceiveInfo - LayerZero receive information transaction argument
     * @param lzComposeInfo - LayerZero compose information transaction argument
     */
    initCounterMoveCall(tx: Transaction, lzReceiveInfo: TransactionArgument, lzComposeInfo: TransactionArgument): void;
    /**
     * Quote messaging fees for sending counter increment
     * @param dstEid - Destination endpoint ID
     * @param msgType - Message type (SEND or SEND_AND_CALL)
     * @param options - Execution options as bytes
     * @param payInZero - Whether to pay in ZRO tokens
     * @returns Promise<MessagingFee> - The calculated messaging fees
     */
    quote(dstEid: EndpointId | TransactionArgument, msgType: number | TransactionArgument, options: Uint8Array | TransactionArgument, payInZero: boolean | TransactionArgument, validators?: IPTBValidator[]): Promise<MessagingFee>;
    /**
     * Increment counter on destination chain
     * @param tx - The transaction to add the move call to
     * @param sender - Sender address for ZRO token operations
     * @param dstEid - Destination endpoint ID
     * @param msgType - Message type (SEND or SEND_AND_CALL)
     * @param options - Execution options as bytes
     * @param nativeFee - Native token fee amount
     * @param zroFee - ZRO token fee amount
     * @param refundAddress - Address for fee refunds
     */
    incrementMoveCall(tx: Transaction, sender: string, dstEid: EndpointId | TransactionArgument, msgType: number | TransactionArgument, options: Uint8Array | TransactionArgument, nativeFee: bigint | TransactionArgument, zroFee: bigint | TransactionArgument, refundAddress: string | TransactionArgument, validators?: IPTBValidator[]): Promise<void>;
    /**
     * Set composer information for counter
     * @param tx - The transaction to add the move call to
     * @param composerInfo - Composer information including lz_compose execution information as bytes
     */
    setComposerInfoMoveCall(tx: Transaction, composerInfo: Uint8Array | TransactionArgument): void;
    /**
     * Get counter EID
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the counter EID
     */
    getEidMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get counter EID
     * @returns Promise<number> - The counter EID
     */
    getEid(): Promise<number>;
    /**
     * Get call capability address for counter
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the call capability address
     */
    getCallCapAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get call capability address for counter
     * @returns Promise<string> - The call capability address
     */
    getCallCapAddress(): Promise<string>;
    /**
     * Get composer address for counter
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the composer address
     */
    getComposerAddressMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get composer address for counter
     * @returns Promise<string> - The composer address
     */
    getComposerAddress(): Promise<string>;
    /**
     * Get current counter value
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the counter value
     */
    getCountMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get current counter value
     * @returns Promise<number> - The current counter value
     */
    getCount(): Promise<number>;
    /**
     * Get composed counter value
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the composed counter value
     */
    getComposedCountMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get composed counter value
     * @returns Promise<number> - The composed counter value
     */
    getComposedCount(): Promise<number>;
    /**
     * Get outbound counter value for a destination
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @returns Transaction result containing the outbound counter value
     */
    getOutboundCountMoveCall(tx: Transaction, dstEid: number | TransactionArgument): TransactionResult;
    /**
     * Get outbound counter value for a destination
     * @param dstEid - Destination endpoint ID
     * @returns Promise<number> - The outbound counter value
     */
    getOutboundCount(dstEid: number): Promise<number>;
    /**
     * Get inbound counter value from a source
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @returns Transaction result containing the inbound counter value
     */
    getInboundCountMoveCall(tx: Transaction, srcEid: number | TransactionArgument): TransactionResult;
    /**
     * Get inbound counter value from a source
     * @param srcEid - Source endpoint ID
     * @returns Promise<number> - The inbound counter value
     */
    getInboundCount(srcEid: number): Promise<number>;
    nextNonceMoveCall(tx: Transaction, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument): TransactionResult;
    nextNonce(srcEid: number, sender: Uint8Array): Promise<number>;
    getMaxReceivedNonceMoveCall(tx: Transaction, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument): TransactionResult;
    getMaxReceivedNonce(srcEid: number, sender: Uint8Array): Promise<number>;
    isOrderedNonceMoveCall(tx: Transaction): TransactionResult;
    isOrderedNonce(): Promise<boolean>;
    lzReceiveInfoMoveCall(tx: Transaction): TransactionResult;
    lzComposeInfoMoveCall(tx: Transaction): TransactionResult;
}

interface OAppInfoV1 {
    oapp_object: string;
    next_nonce_info: number[];
    lz_receive_info: number[];
    extra_info: number[];
}

declare const OAppErrorCode: {
    readonly OApp_EInvalidAdminCap: 1;
    readonly OApp_EInvalidOAppCap: 2;
    readonly OApp_EInvalidRefundAddress: 3;
    readonly OApp_EInvalidSendingCall: 4;
    readonly OApp_EOnlyEndpoint: 5;
    readonly OApp_EOnlyPeer: 6;
    readonly OApp_ESendingInProgress: 7;
    readonly OAppPeer_EPeerNotFound: 0;
    readonly OAppPeer_EInvalidPeer: 1;
    readonly EnforcedOptions_EEnforcedOptionsNotFound: 1;
    readonly EnforcedOptions_EInvalidOptionsLength: 2;
    readonly EnforcedOptions_EInvalidOptionsType: 3;
    readonly OAppInfoV1_EInvalidData: 1;
    readonly OAppInfoV1_EInvalidVersion: 2;
};
declare class OApp {
    #private;
    private readonly moduleManager;
    packageId: string;
    oappCallCapId: string;
    readonly client: SuiClient;
    oappInfo: OAppInfoV1 | null;
    private readonly objects;
    constructor(packageId: string, oappCallCapId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Set enforced options for OApp messaging
     * @param tx - The transaction to add the move call to
     * @param eid - Endpoint ID or transaction argument
     * @param msgType - Message type or transaction argument
     * @param options - Enforced options as bytes or transaction argument
     */
    setEnforcedOptionsMoveCall(tx: Transaction, eid: number | TransactionArgument, msgType: number | TransactionArgument, options: Uint8Array | TransactionArgument): Promise<void>;
    /**
     * Set peer OApp on another chain
     * @param tx - The transaction to add the move call to
     * @param eid - Peer endpoint ID or transaction argument
     * @param peer - Peer OApp address as bytes or transaction argument
     */
    setPeerMoveCall(tx: Transaction, eid: number | TransactionArgument, peer: Uint8Array | TransactionArgument): Promise<void>;
    /**
     * Get admin capability address for OApp
     * @param tx - The transaction to add the move call to
     * @param oapp - The OApp object ID or transaction argument
     * @returns Transaction result containing the admin capability address
     */
    getAdminCapMoveCall(tx: Transaction, oapp: string | TransactionArgument): TransactionResult;
    /**
     * Get admin capability address for OApp
     * @param oapp - The OApp object ID
     * @returns Promise<string> - The admin capability address
     */
    getAdminCap(oapp: string): Promise<string>;
    /**
     * Get OApp CallCap identifier
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the OApp CallCap identifier
     */
    getOAppCapIdMoveCall(tx: Transaction): Promise<TransactionResult>;
    /**
     * Get OApp CallCap identifier
     * @returns Promise<string> - The OApp CallCap identifier
     */
    getOAppCapId(): Promise<string>;
    /**
     * Combine enforced options with extra options for message execution
     * @param tx - The transaction to add the move call to
     * @param eid - Destination endpoint ID or transaction argument
     * @param msgType - Message type or transaction argument
     * @param extraOptions - Extra options to combine with enforced options or transaction argument
     * @returns Transaction result containing combined options
     */
    combineOptionsMoveCall(tx: Transaction, eid: number | TransactionArgument, msgType: number | TransactionArgument, extraOptions: Uint8Array | TransactionArgument): Promise<TransactionResult>;
    /**
     * Combine enforced options with extra options for message execution
     * @param eid - Destination endpoint ID
     * @param msgType - Message type
     * @param extraOptions - Extra options to combine with enforced options
     * @returns Promise<Uint8Array> - Combined options as bytes
     */
    combineOptions(eid: number, msgType: number, extraOptions: Uint8Array): Promise<Uint8Array>;
    /**
     * Get enforced options for a specific destination and message type
     * @param tx - The transaction to add the move call to
     * @param eid - Destination endpoint ID or transaction argument
     * @param msgType - Message type or transaction argument
     * @returns Transaction result containing enforced options
     */
    getEnforcedOptionsMoveCall(tx: Transaction, eid: number | TransactionArgument, msgType: number | TransactionArgument): Promise<TransactionResult>;
    /**
     * Get enforced options for a specific destination and message type
     * @param eid - Destination endpoint ID
     * @param msgType - Message type
     * @returns Promise<Uint8Array> - Enforced options as bytes
     */
    getEnforcedOptions(eid: number, msgType: number): Promise<Uint8Array>;
    /**
     * Check if a peer is configured for a specific destination chain
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID or transaction argument
     * @returns Transaction result containing boolean result
     */
    hasPeerMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult>;
    /**
     * Check if a peer is configured for a specific destination chain
     * @param dstEid - Destination endpoint ID
     * @returns Promise<boolean> - True if peer is configured, false otherwise
     */
    hasPeer(dstEid: number): Promise<boolean>;
    /**
     * Get the configured peer address for a specific destination chain
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID or transaction argument
     * @returns Transaction result containing peer address
     */
    getPeerMoveCall(tx: Transaction, dstEid: number | TransactionArgument): Promise<TransactionResult>;
    /**
     * Get the configured peer address for a specific destination chain
     * @param dstEid - Destination endpoint ID
     * @returns Promise<Uint8Array> - Peer address as bytes32
     */
    getPeer(dstEid: number): Promise<Uint8Array>;
    /**
     * Get OApp information V1 structure
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the OApp information V1
     */
    getOAppInfoV1MoveCall(tx: Transaction): TransactionResult;
    /**
     * Get OApp information V1 structure
     * @returns Promise<OAppInfoV1> - The OApp information V1
     */
    getOAppInfoV1(): Promise<OAppInfoV1>;
    getOAppInfoV1ExtraInfoMoveCall(tx: Transaction, oappInfo: TransactionArgument): TransactionResult;
    /**
     * Register OApp with the endpoint
     * @param tx - The transaction to add the move call to
     * @param oappObjectId - The OApp object ID
     * @param oappInfo - OApp information as bytes (optional)
     * @returns Transaction result containing the messaging channel address
     */
    registerOAppMoveCall(tx: Transaction, oappObjectId: string, oappInfo?: Uint8Array | TransactionArgument): Promise<TransactionResult>;
    /**
     * Set delegate for OApp
     * @param tx - The transaction to add the move call to
     * @param newDelegate - New delegate address
     */
    setDelegateMoveCall(tx: Transaction, newDelegate: string | TransactionArgument): Promise<void>;
    /**
     * Set OApp information in the endpoint
     * @param tx - The transaction to add the move call to
     * @param oappInfo - OApp information as bytes
     * @param oappObjectId - Optional OApp object ID (uses configured oapp if not provided)
     */
    setOAppInfoMoveCall(tx: Transaction, oappInfo: Uint8Array | TransactionArgument, oappObjectId?: string): Promise<void>;
    /**
     * Initialize channel with remote OApp
     * @param tx - The transaction to add the move call to
     * @param remoteEid - Remote endpoint ID
     * @param remoteOApp - Remote OApp address as bytes32
     */
    initChannelMoveCall(tx: Transaction, remoteEid: number | TransactionArgument, remoteOApp: Uint8Array | TransactionArgument): Promise<void>;
    /**
     * Clear a message from the messaging channel
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes32
     * @param nonce - Message nonce
     * @param guid - Message GUID as bytes32
     * @param message - Message payload
     */
    clearMoveCall(tx: Transaction, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: number | bigint | TransactionArgument, guid: Uint8Array | TransactionArgument, message: Uint8Array | TransactionArgument): Promise<void>;
    /**
     * Skip a message in the messaging channel
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes32
     * @param nonce - Message nonce
     */
    skipMoveCall(tx: Transaction, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: number | bigint | TransactionArgument): Promise<void>;
    /**
     * Nilify a message in the messaging channel
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes32
     * @param nonce - Message nonce
     * @param payloadHash - Payload hash as bytes32
     */
    nilifyMoveCall(tx: Transaction, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: number | bigint | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): Promise<void>;
    /**
     * Burn a message in the messaging channel
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param sender - Sender address as bytes32
     * @param nonce - Message nonce
     * @param payloadHash - Payload hash as bytes32
     */
    burnMoveCall(tx: Transaction, srcEid: number | TransactionArgument, sender: Uint8Array | TransactionArgument, nonce: number | bigint | TransactionArgument, payloadHash: Uint8Array | TransactionArgument): Promise<void>;
    /**
     * Set send library for a destination chain
     * @param tx - The transaction to add the move call to
     * @param dstEid - Destination endpoint ID
     * @param sendLibrary - Send library address
     */
    setSendLibraryMoveCall(tx: Transaction, dstEid: number | TransactionArgument, sendLibrary: string | TransactionArgument): Promise<void>;
    /**
     * Set receive library for a source chain
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param receiveLibrary - Receive library address
     * @param gracePeriod - Grace period in seconds
     */
    setReceiveLibraryMoveCall(tx: Transaction, srcEid: number | TransactionArgument, receiveLibrary: string | TransactionArgument, gracePeriod: number | bigint | TransactionArgument): Promise<void>;
    /**
     * Set receive library timeout for a source chain
     * @param tx - The transaction to add the move call to
     * @param srcEid - Source endpoint ID
     * @param receiveLibrary - Receive library address
     * @param expiry - Expiry timestamp in seconds
     */
    setReceiveLibraryTimeoutMoveCall(tx: Transaction, srcEid: number | TransactionArgument, receiveLibrary: string | TransactionArgument, expiry: number | bigint | TransactionArgument): Promise<void>;
    /**
     * Set configuration for a message library
     * @param tx - The transaction to add the move call to
     * @param lib - Library address
     * @param eid - Endpoint ID
     * @param configType - Configuration type
     * @param config - Configuration data as bytes
     * @returns Transaction result containing Call<MessageLibSetConfigParam, Void>
     */
    setConfigMoveCall(tx: Transaction, lib: string | TransactionArgument, eid: number | TransactionArgument, configType: number | TransactionArgument, config: Uint8Array | TransactionArgument): Promise<TransactionResult>;
    /**
     * Refresh the cached OApp information by fetching the latest data
     * @returns Promise<void> - Completes when the OApp info is refreshed
     */
    refreshOAppInfo(): Promise<void>;
}

/**
 * LayerZero Views SDK
 *
 * Provides view functions for checking the state of LayerZero messages
 * and their executability/verification status without modifying state.
 */
declare class LayerZeroViews {
    #private;
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    private readonly objects;
    constructor(packageId: string, client: SuiClient, objects: ObjectOptions, moduleManager: ModuleManager);
    /**
     * Checks if a message path is initializable (channel exists).
     *
     * @param params - Parameters containing messaging channel, source EID, and sender
     * @returns Promise<boolean> - True if the path is initializable
     */
    initializable(params: InitializableParams): Promise<boolean>;
    /**
     * Checks if a message is verifiable by the endpoint.
     *
     * @param params - Parameters containing messaging channel, source EID, sender, and nonce
     * @returns Promise<boolean> - True if the message is verifiable
     */
    verifiable(params: VerifiableParams): Promise<boolean>;
    /**
     * Determines the execution state of a message.
     *
     * @param params - Parameters containing messaging channel, source EID, sender, and nonce
     * @returns Promise<EndpointExecutionStateType> - The current execution state
     */
    executable(params: ExecutableParams): Promise<EndpointExecutionStateType>;
    /**
     * Checks the verification state of a message through the ULN 302.
     *
     * @param params - Parameters containing ULN, verification, messaging channel, packet header, and payload hash
     * @returns Promise<UlnVerificationStateType> - The current verification state
     */
    ulnVerifiable(params: UlnVerifiableParams): Promise<UlnVerificationStateType>;
    /**
     * Gets the human-readable name for an endpoint execution state
     * @param state - The endpoint execution state enum value
     * @returns Human-readable string representation of the execution state
     */
    static getExecutionStateName(state: EndpointExecutionStateType): string;
    /**
     * Gets the human-readable name for a ULN verification state
     * @param state - The ULN verification state enum value
     * @returns Human-readable string representation of the verification state
     */
    static getVerificationStateName(state: UlnVerificationStateType): string;
}

declare const CallErrorCode: {
    readonly Call_ECallNotActive: 1;
    readonly Call_ECallNotCompleted: 2;
    readonly Call_ECallNotCreating: 3;
    readonly Call_ECallNotRoot: 4;
    readonly Call_ECallNotWaiting: 5;
    readonly Call_EInvalidChild: 6;
    readonly Call_EInvalidNonce: 7;
    readonly Call_EInvalidParent: 8;
    readonly Call_EParameterNotMutable: 9;
    readonly Call_EUnauthorized: 10;
    readonly CallCap_EBadWitness: 1;
    readonly MultiCall_ENoMoreCalls: 1;
    readonly MultiCall_EUnauthorized: 2;
};
declare class Call {
    #private;
    packageId: string;
    readonly client: SuiClient;
    constructor(packageId: string, client: SuiClient);
    /**
     * Create a new CallCap for a user (direct interaction)
     * Creates a user-based CallCap that uses its own UID as the identifier
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the new individual CallCap
     */
    newIndividualCapMoveCall(tx: Transaction): TransactionResult;
    /**
     * Create a void result for calls with no meaningful return value
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing a void result
     */
    voidMoveCall(tx: Transaction): TransactionResult;
    /**
     * Get the result from a call
     * @param tx - The transaction to add the move call to
     * @param paramType - The parameter type for the call
     * @param resultType - The result type for the call
     * @param call - The call transaction result or transaction argument
     * @returns Transaction result containing the call result
     */
    resultMoveCall(tx: Transaction, paramType: string, resultType: string, call: TransactionArgument): TransactionResult;
    /**
     * Get the recipient from a call
     * @param tx - The transaction to add the move call to
     * @param paramType - The parameter type for the call
     * @param resultType - The result type for the call
     * @param call - The call transaction result or transaction argument
     * @returns Transaction result containing the call recipient
     */
    recipientMoveCall(tx: Transaction, paramType: string, resultType: string, call: TransactionArgument): TransactionResult;
    /**
     * Get the unique identifier for a CallCap
     * Returns the appropriate identifier based on the source type
     * @param tx - The transaction to add the move call to
     * @param callCap - The CallCap object ID or transaction argument
     * @returns Transaction result containing the CallCap identifier
     */
    callCapIdMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult;
    /**
     * Get the unique identifier for a CallCap
     * Returns the appropriate identifier based on the source type
     * @param callCap - The CallCap object ID
     * @returns Promise resolving to the CallCap identifier as a string
     */
    getCallCapId(callCap: string): Promise<string>;
    /**
     * Check if this is an Individual CallCap
     * @param tx - The transaction to add the move call to
     * @param callCap - The CallCap object ID or transaction argument
     * @returns Transaction result containing a boolean indicating if it's an Individual CallCap
     */
    isIndividualCapMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult;
    /**
     * Check if this is an Individual CallCap
     * @param callCap - The CallCap object ID
     * @returns Promise resolving to true if it's an Individual CallCap
     */
    isIndividualCap(callCap: string): Promise<boolean>;
    /**
     * Check if this is a Package CallCap
     * @param tx - The transaction to add the move call to
     * @param callCap - The CallCap object ID or transaction argument
     * @returns Transaction result containing a boolean indicating if it's a Package CallCap
     */
    isPackageCapMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult;
    /**
     * Check if this is a Package CallCap
     * @param callCap - The CallCap object ID
     * @returns Promise resolving to true if it's a Package CallCap
     */
    isPackageCap(callCap: string): Promise<boolean>;
    /**
     * Get the package address for a Package CallCap
     * Returns None if this is a User CallCap
     * @param tx - The transaction to add the move call to
     * @param callCap - The CallCap object ID or transaction argument
     * @returns Transaction result containing the package address option
     */
    packageAddressMoveCall(tx: Transaction, callCap: string | TransactionArgument): TransactionResult;
    /**
     * Get the package address for a Package CallCap
     * Returns null if this is an Individual CallCap
     * @param callCap - The CallCap object ID
     * @returns Promise resolving to the package address or null if Individual CallCap
     */
    getPackageAddress(callCap: string): Promise<string | null>;
}

declare const UtilsErrorCode: {
    readonly Utils_EInvalidLength: 1;
};
declare class Utils {
    #private;
    packageId: string;
    readonly client: SuiClient;
    constructor(packageId: string, client: SuiClient);
    /**
     * Create a bytes32 from a byte array
     * @param tx - The transaction to add the move call to
     * @param peer - The byte array to convert to bytes32 or transaction argument
     * @returns Transaction result containing the bytes32 value
     */
    fromBytesMoveCall(tx: Transaction, peer: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Create a bytes32 from a byte array with left padding
     * @param tx - The transaction to add the move call to
     * @param bytes - The byte array to convert with left padding or transaction argument
     * @returns Transaction result containing the left-padded bytes32 value
     */
    fromBytesLeftPaddedMoveCall(tx: Transaction, bytes: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Create a bytes32 from a byte array with right padding
     * @param tx - The transaction to add the move call to
     * @param bytes - The byte array to convert with right padding or transaction argument
     * @returns Transaction result containing the right-padded bytes32 value
     */
    fromBytesRightPaddedMoveCall(tx: Transaction, bytes: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Create a bytes32 from an address
     * @param tx - The transaction to add the move call to
     * @param address - The address to convert to bytes32 or transaction argument
     * @returns Transaction result containing the bytes32 representation of the address
     */
    fromAddressMoveCall(tx: Transaction, address: string | TransactionArgument): TransactionResult;
    /**
     * Create a bytes32 from an object ID
     * @param tx - The transaction to add the move call to
     * @param id - The object ID to convert to bytes32 or transaction argument
     * @returns Transaction result containing the bytes32 representation of the ID
     */
    fromIdMoveCall(tx: Transaction, id: string | TransactionArgument): TransactionResult;
    /**
     * Create a zero bytes32 value (all zeros)
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing a zero bytes32
     */
    zeroBytes32MoveCall(tx: Transaction): TransactionResult;
    /**
     * Create a bytes32 with all bits set to 1 (0xff...)
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing a bytes32 with all bits set
     */
    ffBytes32MoveCall(tx: Transaction): TransactionResult;
    /**
     * Check if a bytes32 value is zero (all zeros)
     * @param tx - The transaction to add the move call to
     * @param bytes32 - The bytes32 value to check or transaction argument
     * @returns Transaction result containing a boolean indicating if the value is zero
     */
    isZeroMoveCall(tx: Transaction, bytes32: TransactionArgument): TransactionResult;
    /**
     * Check if a bytes32 value has all bits set to 1
     * @param tx - The transaction to add the move call to
     * @param bytes32 - The bytes32 value to check or transaction argument
     * @returns Transaction result containing a boolean indicating if all bits are set
     */
    isFfMoveCall(tx: Transaction, bytes32: TransactionArgument): TransactionResult;
    /**
     * Convert a bytes32 to a byte array
     * @param tx - The transaction to add the move call to
     * @param bytes32 - The bytes32 value to convert or transaction argument
     * @returns Transaction result containing the byte array representation
     */
    toBytesMoveCall(tx: Transaction, bytes32: TransactionArgument): TransactionResult;
    /**
     * Convert a bytes32 to an address
     * @param tx - The transaction to add the move call to
     * @param bytes32 - The bytes32 value to convert or transaction argument
     * @returns Transaction result containing the address representation
     */
    toAddressMoveCall(tx: Transaction, bytes32: TransactionArgument): TransactionResult;
    /**
     * Convert a bytes32 to an object ID
     * @param tx - The transaction to add the move call to
     * @param bytes32 - The bytes32 value to convert or transaction argument
     * @returns Transaction result containing the object ID representation
     */
    toIdMoveCall(tx: Transaction, bytes32: TransactionArgument): TransactionResult;
    /**
     * Create a new buffer reader from a byte array
     * @param tx - The transaction to add the move call to
     * @param buffer - The byte array to create the reader from or transaction argument
     * @returns Transaction result containing the buffer reader
     */
    newReaderMoveCall(tx: Transaction, buffer: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get the current position of the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @returns Transaction result containing the current position
     */
    positionMoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Get the remaining length of data in the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @returns Transaction result containing the remaining length
     */
    remainingLengthMoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Skip a specified number of bytes in the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @param len - The number of bytes to skip or transaction argument
     * @returns Transaction result containing the updated reader
     */
    skipMoveCall(tx: Transaction, reader: TransactionArgument, len: number | TransactionArgument): TransactionResult;
    /**
     * Set the position of the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @param position - The position to set or transaction argument
     * @returns Transaction result containing the updated reader
     */
    setPositionMoveCall(tx: Transaction, reader: TransactionArgument, position: number | TransactionArgument): TransactionResult;
    /**
     * Rewind the buffer reader by a specified number of bytes
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @param len - The number of bytes to rewind or transaction argument
     * @returns Transaction result containing the updated reader
     */
    rewindMoveCall(tx: Transaction, reader: TransactionArgument, len: number | TransactionArgument): TransactionResult;
    /**
     * Read a boolean value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the boolean value
     */
    readBoolMoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a u8 value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the u8 value
     */
    readU8MoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a u16 value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the u16 value
     */
    readU16MoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a u32 value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the u32 value
     */
    readU32MoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a u64 value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the u64 value
     */
    readU64MoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a u128 value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the u128 value
     */
    readU128MoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a u256 value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the u256 value
     */
    readU256MoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a bytes32 value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the bytes32 value
     */
    readBytes32MoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read an address value from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance
     * @returns Transaction result containing the address value
     */
    readAddressMoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Read a fixed-length byte array from the buffer reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @param len - The length of bytes to read or transaction argument
     * @returns Transaction result containing the byte array
     */
    readFixedLenBytesMoveCall(tx: Transaction, reader: TransactionArgument, len: number | TransactionArgument): TransactionResult;
    /**
     * Read all remaining bytes from the buffer reader until the end
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @returns Transaction result containing the remaining bytes
     */
    readBytesUntilEndMoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Get the total buffer length of the reader
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @returns Transaction result containing the total buffer length
     */
    readerBufferLengthMoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Convert the buffer reader to a byte array
     * @param tx - The transaction to add the move call to
     * @param reader - The buffer reader instance or transaction argument
     * @returns Transaction result containing the byte array representation
     */
    readerToBytesMoveCall(tx: Transaction, reader: TransactionArgument): TransactionResult;
    /**
     * Create a new empty buffer writer
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing the buffer writer
     */
    newWriterMoveCall(tx: Transaction): TransactionResult;
    /**
     * Create a buffer writer with initial data
     * @param tx - The transaction to add the move call to
     * @param buffer - The initial byte array data for the writer or transaction argument
     * @returns Transaction result containing the buffer writer
     */
    createWriterMoveCall(tx: Transaction, buffer: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get the total buffer length of the writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance
     * @returns Transaction result containing the total buffer length
     */
    writerBufferLengthMoveCall(tx: Transaction, writer: TransactionArgument): TransactionResult;
    /**
     * Convert the buffer writer to a byte array
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance
     * @returns Transaction result containing the byte array representation
     */
    writerToBytesMoveCall(tx: Transaction, writer: TransactionArgument): TransactionResult;
    /**
     * Write a boolean value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param value - The boolean value to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeBoolMoveCall(tx: Transaction, writer: TransactionArgument, value: boolean | TransactionArgument): TransactionResult;
    /**
     * Write a u8 value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param value - The u8 value to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeU8MoveCall(tx: Transaction, writer: TransactionArgument, value: number | TransactionArgument): TransactionResult;
    /**
     * Write a u16 value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param value - The u16 value to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeU16MoveCall(tx: Transaction, writer: TransactionArgument, value: number | TransactionArgument): TransactionResult;
    /**
     * Write a u32 value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param value - The u32 value to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeU32MoveCall(tx: Transaction, writer: TransactionArgument, value: number | TransactionArgument): TransactionResult;
    /**
     * Write a u64 value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param value - The u64 value to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeU64MoveCall(tx: Transaction, writer: TransactionArgument, value: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Write a u128 value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param value - The u128 value to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeU128MoveCall(tx: Transaction, writer: TransactionArgument, value: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Write a u256 value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param value - The u256 value to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeU256MoveCall(tx: Transaction, writer: TransactionArgument, value: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Write a byte array to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param bytes - The byte array to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeBytesMoveCall(tx: Transaction, writer: TransactionArgument, bytes: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Write an address to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param address - The address to write or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeAddressMoveCall(tx: Transaction, writer: TransactionArgument, address: string | TransactionArgument): TransactionResult;
    /**
     * Write a bytes32 value to the buffer writer
     * @param tx - The transaction to add the move call to
     * @param writer - The buffer writer instance or transaction argument
     * @param bytes32 - The bytes32 value to write (as Uint8Array) or transaction argument
     * @returns Transaction result containing the updated writer
     */
    writeBytes32MoveCall(tx: Transaction, writer: TransactionArgument, bytes32: Uint8Array | TransactionArgument): TransactionResult;
    /**
     * Get the original package address where a type was first defined
     * @param tx - The transaction to add the move call to
     * @param typeArgument - The type to get the original package address for
     * @returns Transaction result containing the original package address
     */
    originalPackageOfTypeMoveCall(tx: Transaction, typeArgument: string): TransactionResult;
    /**
     * Get the current package address where a type is defined
     * @param tx - The transaction to add the move call to
     * @param typeArgument - The type to get the current package address for
     * @returns Transaction result containing the current package address
     */
    packageOfTypeMoveCall(tx: Transaction, typeArgument: string): TransactionResult;
    /**
     * Create an Option<Coin<SUI>> from a value
     * @param tx - The transaction to add the move call to
     * @param value - The amount of SUI to wrap in the option
     * @returns Transaction result containing option::none for zero values, option::some otherwise
     * @note TransactionArguments always create option::some (runtime values cannot be evaluated)
     */
    createOptionSuiMoveCall(tx: Transaction, value: bigint | number | string | TransactionArgument): TransactionResult;
    /**
     * Check if a static value (non-TransactionArgument) is zero
     */
    private isZeroValue;
    /**
     * Check if a primitive value equals zero
     */
    private _isZeroValue;
    /**
     * Create option::none for Coin<SUI>
     */
    private _createOptionNone;
    /**
     * Create option::some for Coin<SUI>
     */
    private _createOptionSome;
    /**
     * Splits specified amount of coins from user's wallet
     * @param tx - The transaction to add the move call to
     * @param coinType - The type of coin to split
     * @param owner - Address of the user whose coins to split
     * @param amount - Amount of coins to split (in smallest units)
     * @param limit - Maximum total number of coins to collect across all pages (default: 200)
     * @param pageSize - Maximum number of coins to fetch per page (default: 50)
     * @returns Promise resolving to split coin as TransactionResult
     * @throws Error if insufficient coins balance or no coins found
     */
    splitCoinMoveCall(tx: Transaction, coinType: string, owner: string, amount: bigint, limit?: number, pageSize?: number): Promise<TransactionResult>;
}

declare class Zro {
    private readonly moduleManager;
    packageId: string;
    readonly client: SuiClient;
    zroType: string;
    constructor(packageId: string, client: SuiClient, moduleManager: ModuleManager);
    /**
     * Split ZRO tokens and wrap in an Option type for use in LayerZero operations
     * If value is 0, returns Option::None, otherwise returns Option::Some with the split tokens
     * @param tx - The transaction to add the move call to
     * @param userAddress - Address of the user whose ZRO tokens to split
     * @param value - Amount of ZRO tokens to split (0 for None option)
     * @param maxCoins - Maximum total number of coins to collect across all pages (default: 200)
     * @param maxCoinsPerPage - Maximum number of coins to fetch per page (default: 50)
     * @returns Promise resolving to transaction result containing Option<Coin<ZRO>>
     * @throws Error if insufficient ZRO balance
     */
    splitOptionZroTokenMoveCall(tx: Transaction, userAddress: string, value: bigint, maxCoins?: number, maxCoinsPerPage?: number): Promise<TransactionResult>;
    /**
     * Splits specified amount of ZRO tokens from user's wallet
     * This method fetches coins and merges them as needed to get sufficient balance
     * @param tx - The transaction to add the move call to
     * @param owner - Address of the user whose ZRO coins to split
     * @param amount - Amount of ZRO tokens to split (in smallest units, considering 9 decimals)
     * @param limit - Maximum total number of coins to collect across all pages (default: 200)
     * @param pageSize - Maximum number of coins to fetch per page (default: 50)
     * @returns Promise resolving to split ZRO coin as TransactionResult
     * @throws Error if insufficient ZRO balance or no coins found
     */
    splitZroTokenMoveCall(tx: Transaction, owner: string, amount: bigint, limit?: number, pageSize?: number): Promise<TransactionResult>;
    /**
     * Creates an Option::Some moveCall containing a ZRO coin
     * @param tx - The transaction to add the move call to
     * @param zroCoin - ZRO coin to wrap in Option or transaction argument
     * @returns Transaction result containing Option<Coin<ZRO>> type with Some value
     */
    someOptionMoveCall(tx: Transaction, zroCoin: TransactionArgument): TransactionResult;
    /**
     * Creates an Option::None moveCall for ZRO coin type
     * @param tx - The transaction to add the move call to
     * @returns Transaction result containing Option<Coin<ZRO>> type with None value
     */
    noneOptionMoveCall(tx: Transaction): TransactionResult;
}

declare const PACKAGE_UTILS_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_ENDPOINT_V2_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_COUNTER_V2_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_SIMPLE_MESSAGE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_ULN_302_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_ULN_302_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_DVN_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_EXECUTOR_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_EXECUTOR_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_ZRO_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_CALL_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_ENDPOINT_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_SIMPLE_MESSAGE_LIB_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_PTB_MOVE_CALL_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_DVN_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_DVN_FEE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_EXECUTOR_FEE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_PRICE_FEED_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_TREASURY_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_OAPP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_LAYERZERO_VIEWS_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_DVN_LAYERZERO_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_EXECUTOR_LAYERZERO_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_PACKAGE_WHITELIST_VALIDATOR_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_BLOCKED_MESSAGE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_BLOCKED_MESSAGE_LIB_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_WORKER_REGISTRY_ADDRESS: {
    [stage in Stage]?: string;
};
declare const PACKAGE_WORKER_COMMON_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ENDPOINT_V2_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_SIMPLE_MESSAGE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_SIMPLE_MESSAGE_LIB_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_SIMPLE_MESSAGE_LIB_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ULN_302_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ULN_302_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ULN_302_VERIFICATION_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ULN_302_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_TREASURY_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_TREASURY_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_BLOCKED_MESSAGE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_BLOCKED_MESSAGE_LIB_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_DISCOVERY_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_COUNTER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_COUNTER_OAPP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_COUNTER_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ENDPOINT_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ENDPOINT_PTB_BUILDER_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_ENDPOINT_PTB_BUILDER_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_DVN_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_DVN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_DVN_FEE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_DVN_FEE_LIB_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_EXECUTOR_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_EXECUTOR_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_EXECUTOR_OWNER_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_EXECUTOR_FEE_LIB_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_EXECUTOR_FEE_LIB_ADMIN_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_PRICE_FEED_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_PRICE_FEED_OWNER_CAP_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_PACKAGE_WHITELIST_VALIDATOR_ADDRESS: {
    [stage in Stage]?: string;
};
declare const OBJECT_WORKER_REGISTRY_ADDRESS: {
    [stage in Stage]?: string;
};

/**
 * The SDK class provides methods to interact with LayerZero on Sui.
 * Uses ModuleManager for centralized module management.
 */
declare class SDK {
    chain: Chain;
    stage: Stage;
    client: SuiClient;
    packages: PackageOptions;
    objects: ObjectOptions;
    private moduleManager;
    /**
     * Creates an instance of the SDK.
     */
    constructor(options: SdkOptions);
    getEndpoint(): Endpoint;
    getSimpleMessageLib(): SimpleMessageLib;
    getBlockedMessageLib(): BlockedMessageLib;
    getUln302(): Uln302;
    getUtils(): Utils;
    getZro(): Zro;
    getCall(): Call;
    getPtbBuilder(): PtbBuilder;
    getTreasury(): Treasury;
    getLayerZeroViews(): LayerZeroViews;
    getOApp(callCapId: string, options?: ModuleOptions): OApp;
    getCounter(options?: ModuleOptions): Counter;
    getExecutor(options?: ModuleOptions): Executor;
    getDvn(options?: ModuleOptions): DVN;
    getDvnFeeLib(options?: ModuleOptions): DVNFeeLib;
    getExecutorFeeLib(options?: ModuleOptions): ExecutorFeeLib;
    getPriceFeed(options?: ModuleOptions): PriceFeed;
    getDvnLayerZero(options?: ModuleOptions): DvnLayerZero;
    getExecutorLayerZero(options?: ModuleOptions): ExecutorLayerZero;
    getDvnPtbBuilder(options?: ModuleOptions): DvnPtbBuilder;
    getExecutorPtbBuilder(options?: ModuleOptions): ExecutorPtbBuilder;
    getPackageWhitelistValidator(options?: ModuleOptions): PackageWhitelistValidator;
    getUln302PtbBuilder(options?: ModuleOptions): Uln302PtbBuilder;
    getEndpointPtbBuilder(options?: ModuleOptions): EndpointPtbBuilder;
    getSimpleMessageLibPtbBuilder(options?: ModuleOptions): SimpleMessageLibPtbBuilder;
    getBlockedMessageLibPtbBuilder(options?: ModuleOptions): BlockedMessageLibPtbBuilder;
    getWorkerRegistry(options?: ModuleOptions): WorkerRegistry;
    getOrCreateModule<T>(moduleName: string, options: ModuleOptions | undefined, factory: () => T): T;
}

declare const DvnDstConfigBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    gas: string;
    multiplier_bps: number;
    floor_margin_usd: string;
}, {
    gas: string | number | bigint;
    multiplier_bps: number;
    floor_margin_usd: string | number | bigint;
}>;

declare const TimeoutBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    expiry: string;
    fallback_lib: string;
}, {
    expiry: string | number | bigint;
    fallback_lib: any;
}>;

declare const Bytes32Bcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    bytes: number[];
}, {
    bytes: Iterable<number> & {
        length: number;
    };
}>;
declare const ExecutorConfigBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    max_message_size: string;
    executor: string;
}, {
    max_message_size: string | number | bigint;
    executor: any;
}>;
declare const DstConfigBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    lz_receive_base_gas: string;
    lz_compose_base_gas: string;
    multiplier_bps: number;
    floor_margin_usd: string;
    native_cap: string;
}, {
    lz_receive_base_gas: string | number | bigint;
    lz_compose_base_gas: string | number | bigint;
    multiplier_bps: number;
    floor_margin_usd: string | number | bigint;
    native_cap: string | number | bigint;
}>;
declare const NativeDropParamsBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    receiver: string;
    amount: string;
}, {
    receiver: any;
    amount: string | number | bigint;
}>;

declare const MessagingFeeBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    native_fee: string;
    zro_fee: string;
}, {
    native_fee: string | number | bigint;
    zro_fee: string | number | bigint;
}>;

declare const FunctionBCS: _mysten_sui_dist_cjs_bcs.BcsType<{
    package: string;
    module_name: string;
    name: string;
}, {
    package: any;
    module_name: string;
    name: string;
}>;
declare const ArgumentBCS: _mysten_sui_dist_cjs_bcs.BcsType<_store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumOutputShapeWithKeys<{
    ID: number[];
    Object: string;
    Pure: number[];
    NestedResult: {
        call_index: number;
        result_index: number;
    };
}, "ID" | "Object" | "Pure" | "NestedResult">, _store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumInputShape<{
    ID: Iterable<number> & {
        length: number;
    };
    Object: any;
    Pure: Iterable<number> & {
        length: number;
    };
    NestedResult: {
        call_index: number;
        result_index: number;
    };
}>>;
declare const MoveCallBCS: _mysten_sui_dist_cjs_bcs.BcsType<{
    function: {
        package: string;
        module_name: string;
        name: string;
    };
    arguments: _store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumOutputShapeWithKeys<{
        ID: number[];
        Object: string;
        Pure: number[];
        NestedResult: {
            call_index: number;
            result_index: number;
        };
    }, "ID" | "Object" | "Pure" | "NestedResult">[];
    type_arguments: string[];
    is_builder_call: boolean;
    result_ids: number[][];
}, {
    function: {
        package: any;
        module_name: string;
        name: string;
    };
    arguments: Iterable<_store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumInputShape<{
        ID: Iterable<number> & {
            length: number;
        };
        Object: any;
        Pure: Iterable<number> & {
            length: number;
        };
        NestedResult: {
            call_index: number;
            result_index: number;
        };
    }>> & {
        length: number;
    };
    type_arguments: Iterable<string> & {
        length: number;
    };
    is_builder_call: boolean;
    result_ids: Iterable<Iterable<number> & {
        length: number;
    }> & {
        length: number;
    };
}>;
declare const VectorMoveCallBCS: _mysten_sui_dist_cjs_bcs.BcsType<{
    function: {
        package: string;
        module_name: string;
        name: string;
    };
    arguments: _store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumOutputShapeWithKeys<{
        ID: number[];
        Object: string;
        Pure: number[];
        NestedResult: {
            call_index: number;
            result_index: number;
        };
    }, "ID" | "Object" | "Pure" | "NestedResult">[];
    type_arguments: string[];
    is_builder_call: boolean;
    result_ids: number[][];
}[], Iterable<{
    function: {
        package: any;
        module_name: string;
        name: string;
    };
    arguments: Iterable<_store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumInputShape<{
        ID: Iterable<number> & {
            length: number;
        };
        Object: any;
        Pure: Iterable<number> & {
            length: number;
        };
        NestedResult: {
            call_index: number;
            result_index: number;
        };
    }>> & {
        length: number;
    };
    type_arguments: Iterable<string> & {
        length: number;
    };
    is_builder_call: boolean;
    result_ids: Iterable<Iterable<number> & {
        length: number;
    }> & {
        length: number;
    };
}> & {
    length: number;
}>;

declare const OAppInfoV1Bcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    oapp_object: string;
    next_nonce_info: number[];
    lz_receive_info: number[];
    extra_info: number[];
}, {
    oapp_object: any;
    next_nonce_info: Iterable<number> & {
        length: number;
    };
    lz_receive_info: Iterable<number> & {
        length: number;
    };
    extra_info: Iterable<number> & {
        length: number;
    };
}>;

declare const PriceBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    price_ratio: string;
    gas_price_in_unit: string;
    gas_per_byte: number;
}, {
    price_ratio: string | number | bigint;
    gas_price_in_unit: string | number | bigint;
    gas_per_byte: number;
}>;
declare const ArbitrumPriceExtBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    gas_per_l2_tx: string;
    gas_per_l1_call_data_byte: number;
}, {
    gas_per_l2_tx: string | number | bigint;
    gas_per_l1_call_data_byte: number;
}>;
declare const ModelTypeBcs: _mysten_sui_dist_cjs_bcs.BcsType<_store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumOutputShapeWithKeys<{
    DEFAULT: true;
    ARB_STACK: true;
    OP_STACK: true;
}, "DEFAULT" | "ARB_STACK" | "OP_STACK">, _store__mysten_bcs_npm_1_6_3_20c656f643_package.EnumInputShape<{
    DEFAULT: boolean | object | null;
    ARB_STACK: boolean | object | null;
    OP_STACK: boolean | object | null;
}>>;

declare const UlnConfigBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    confirmations: string;
    required_dvns: string[];
    optional_dvns: string[];
    optional_dvn_threshold: number;
}, {
    confirmations: string | number | bigint;
    required_dvns: Iterable<any> & {
        length: number;
    };
    optional_dvns: Iterable<any> & {
        length: number;
    };
    optional_dvn_threshold: number;
}>;
declare const OAppUlnConfigBcs: _mysten_sui_dist_cjs_bcs.BcsType<{
    use_default_confirmations: boolean;
    use_default_required_dvns: boolean;
    use_default_optional_dvns: boolean;
    uln_config: {
        confirmations: string;
        required_dvns: string[];
        optional_dvns: string[];
        optional_dvn_threshold: number;
    };
}, {
    use_default_confirmations: boolean;
    use_default_required_dvns: boolean;
    use_default_optional_dvns: boolean;
    uln_config: {
        confirmations: string | number | bigint;
        required_dvns: Iterable<any> & {
            length: number;
        };
        optional_dvns: Iterable<any> & {
            length: number;
        };
        optional_dvn_threshold: number;
    };
}>;

export { ALL_EXECUTOR_OPTION_TYPES, type ArbitrumPriceExt, ArbitrumPriceExtBcs, type Argument, ArgumentBCS, BlockedMessageLib, BlockedMessageLibErrorCode, BlockedMessageLibPtbBuilder, type BuilderPlaceholderInfo, Bytes32Bcs, CONFIG_TYPE, Call, CallErrorCode, CallTypeName, Counter, CounterErrorCode, DEFAULT_SIMULATION_TIMES, DVN, DVNErrorCode, DVNFeeLib, DVNFeeLibErrorCode, DVNLayerzeroErrorCode, type DstConfig, DstConfigBcs, type DvnDstConfig, DvnDstConfigBcs, DvnLayerZero, DvnPtbBuilder, Endpoint, EndpointErrorCode, EndpointExecutionState, type EndpointExecutionStateType, EndpointPtbBuilder, EndpointPtbBuilderErrorCode, type ExecutableParams, Executor, type ExecutorConfig, ExecutorConfigBcs, ExecutorErrorCode, ExecutorFeeLib, ExecutorFeeLibErrorCode, ExecutorLayerZero, ExecutorLayerzeroErrorCode, ExecutorOptionType, ExecutorPtbBuilder, type Function, FunctionBCS, type IPTBValidator, type InitializableParams, LayerZeroViews, LzComposeVersion, LzReceiveVersion, LzTypeName, MAX_BATCH_SIZE, MessageLibType, type MessagingFee, MessagingFeeBcs, ModelType, ModelTypeBcs, type ModuleOptions, Modules, MoveAbortError, type MoveCall, MoveCallBCS, type NativeDropParams, NativeDropParamsBcs, NonSenderObjectValidator, OApp, OAppErrorCode, OAppInfoV1Bcs, OAppInfoVersion, type OAppUlnConfig, OAppUlnConfigBcs, OBJECT_BLOCKED_MESSAGE_LIB_ADDRESS, OBJECT_BLOCKED_MESSAGE_LIB_PTB_BUILDER_ADDRESS, OBJECT_COUNTER_ADDRESS, OBJECT_COUNTER_ADMIN_CAP_ADDRESS, OBJECT_COUNTER_OAPP_ADDRESS, OBJECT_DISCOVERY_ADDRESS, OBJECT_DVN_ADDRESS, OBJECT_DVN_CAP_ADDRESS, OBJECT_DVN_FEE_LIB_ADDRESS, OBJECT_DVN_FEE_LIB_ADMIN_CAP_ADDRESS, OBJECT_ENDPOINT_ADMIN_CAP_ADDRESS, OBJECT_ENDPOINT_PTB_BUILDER_ADDRESS, OBJECT_ENDPOINT_PTB_BUILDER_ADMIN_CAP_ADDRESS, OBJECT_ENDPOINT_V2_ADDRESS, OBJECT_EXECUTOR_ADDRESS, OBJECT_EXECUTOR_CAP_ADDRESS, OBJECT_EXECUTOR_FEE_LIB_ADDRESS, OBJECT_EXECUTOR_FEE_LIB_ADMIN_CAP_ADDRESS, OBJECT_EXECUTOR_OWNER_CAP_ADDRESS, OBJECT_PACKAGE_WHITELIST_VALIDATOR_ADDRESS, OBJECT_PRICE_FEED_ADDRESS, OBJECT_PRICE_FEED_OWNER_CAP_ADDRESS, OBJECT_SIMPLE_MESSAGE_LIB_ADDRESS, OBJECT_SIMPLE_MESSAGE_LIB_ADMIN_CAP_ADDRESS, OBJECT_SIMPLE_MESSAGE_LIB_PTB_BUILDER_ADDRESS, OBJECT_TREASURY_ADDRESS, OBJECT_TREASURY_ADMIN_CAP_ADDRESS, OBJECT_ULN_302_ADDRESS, OBJECT_ULN_302_ADMIN_CAP_ADDRESS, OBJECT_ULN_302_PTB_BUILDER_ADDRESS, OBJECT_ULN_302_VERIFICATION_ADDRESS, OBJECT_WORKER_REGISTRY_ADDRESS, type ObjectFetchOptions, type ObjectOptions, PACKAGE_BLOCKED_MESSAGE_LIB_ADDRESS, PACKAGE_BLOCKED_MESSAGE_LIB_PTB_BUILDER_ADDRESS, PACKAGE_CALL_ADDRESS, PACKAGE_COUNTER_V2_ADDRESS, PACKAGE_DVN_ADDRESS, PACKAGE_DVN_FEE_LIB_ADDRESS, PACKAGE_DVN_LAYERZERO_ADDRESS, PACKAGE_DVN_PTB_BUILDER_ADDRESS, PACKAGE_ENDPOINT_PTB_BUILDER_ADDRESS, PACKAGE_ENDPOINT_V2_ADDRESS, PACKAGE_EXECUTOR_ADDRESS, PACKAGE_EXECUTOR_FEE_LIB_ADDRESS, PACKAGE_EXECUTOR_LAYERZERO_ADDRESS, PACKAGE_EXECUTOR_PTB_BUILDER_ADDRESS, PACKAGE_LAYERZERO_VIEWS_ADDRESS, PACKAGE_OAPP_ADDRESS, PACKAGE_PACKAGE_WHITELIST_VALIDATOR_ADDRESS, PACKAGE_PRICE_FEED_ADDRESS, PACKAGE_PTB_MOVE_CALL_ADDRESS, PACKAGE_SIMPLE_MESSAGE_LIB_ADDRESS, PACKAGE_SIMPLE_MESSAGE_LIB_PTB_BUILDER_ADDRESS, PACKAGE_TREASURY_ADDRESS, PACKAGE_ULN_302_ADDRESS, PACKAGE_ULN_302_PTB_BUILDER_ADDRESS, PACKAGE_UTILS_ADDRESS, PACKAGE_WORKER_COMMON_ADDRESS, PACKAGE_WORKER_REGISTRY_ADDRESS, PACKAGE_ZRO_ADDRESS, PackageAllowlistValidator, type PackageOptions, PackageWhitelistValidator, type Price, PriceBcs, PriceFeed, PriceFeedErrorCode, PtbBuilder, PtbBuilderErrorCode, SDK, type SdkOptions, type SetDstConfigEvent, ShareObjectValidator, SimpleMessageLib, SimpleMessageLibErrorCode, SimpleMessageLibPtbBuilder, type SimulateResult, type Timeout, TimeoutBcs, Treasury, TreasuryErrorCode, Uln302, Uln302ErrorCode, Uln302PtbBuilder, Uln302PtbBuilderErrorCode, type UlnConfig, UlnConfigBcs, type UlnVerifiableParams, UlnVerificationState, type UlnVerificationStateType, UnclassifiedError, Utils, UtilsErrorCode, ValidatorErrorCode, VectorMoveCallBCS, type VerifiableParams, type VerifierFeePaid, type VersionInfo, WorkerRegistry, WorkerRegistryErrorCode, Zro, asAddress, asAddressVector, asArg, asArgWithTx, asArgWithTxAsync, asBool, asBytes, asBytes32, asBytesVector, asObject, asString, asU128, asU16, asU256, asU32, asU64, asU8, executeSimulate, handleError, isTransactionArgument, simulateTransaction, simulateTransactionMultiResult, validateTransaction, validateWithDetails };