import type { Hex } from "viem";
import type { Instruction, MeeAuthorization } from "../clients/decorators/mee/getQuote";
import type { ComposabilityVersion, MEEVersion, PolicyData } from "../constants";
import type { ModularSmartAccount } from "../modules/utils/Types";
import { type BuildComposableInstructionTypes, type BuildInstructionTypes } from "./decorators/build";
import { type BuildActionPolicyParamTypes } from "./decorators/buildActionPolicy";
import { type BridgingInstructions, type MultichainBridgingParams } from "./decorators/buildBridgeInstructions";
import { type BuildSessionActionTypes, type SessionAction } from "./decorators/buildSessionAction";
import { type UnifiedERC20Balance } from "./decorators/getUnifiedERC20Balance";
import { type IsDelegatedParameters, type IsDelegatedPayload } from "./decorators/isDelegated";
import { type MultichainReadParameters, type MultiChainReadPayload } from "./decorators/multichainRead";
import { type OwnershipParams, type OwnershipParamsWithData, type OwnershipResult } from "./decorators/ownership";
import { type BridgeQueryResult, type QueryBridgeParams } from "./decorators/queryBridge";
import { type UnDelegateParameters, type UnDelegatePayload } from "./decorators/unDelegate";
import { type WaitForTransactionReceiptParameters, type WaitForTransactionReceiptPayload } from "./decorators/waitForTransactionReceipts";
import { type ChainConfiguration, type DelegationParams, type ToNexusSmartAccountParameters } from "./toNexusAccount";
import type { MultichainToken } from "./utils/Types";
import type { Signer } from "./utils/toSigner";
/**
 * Parameters required to create a multichain Nexus account
 */
export type MultichainNexusParams = Partial<Omit<ToNexusSmartAccountParameters, "signer" | "nexusContracts">> & {
    /** The signer instance used for account creation */
    signer: ToNexusSmartAccountParameters["signer"];
    /** Array of chain configuration */
    chainConfigurations: ChainConfiguration[];
};
/**
 * Represents a smart account deployed across multiple chains
 */
export type BaseMultichainSmartAccount = {
    /** Array of minimal MEE smart account instances across different chains */
    deployments: ModularSmartAccount[];
    /** The signer associated with this multichain account */
    signer: Signer;
    /**
     * Function to retrieve deployment information for a specific chain
     * @param chainId - The ID of the chain to query
     * @param strictMode - Whether to throw an error if no deployment exists for the specified chain
     * @returns The smart account deployment for the specified chain
     * @throws Error if no deployment exists for the specified chain and strictMode is true
     */
    deploymentOn: {
        (chainId: number, strictMode: true): ModularSmartAccount;
        (chainId: number, strictMode?: false): ModularSmartAccount | undefined;
    };
    /**
     * Function to retrieve the address of the account on a specific chain
     * @param chainId - The ID of the chain to query
     * @param strictMode - Whether to throw an error if no deployment exists for the specified chain
     * @returns The address of the account on the specified chain
     * @throws Error if no deployment exists for the specified chain and strictMode is true
     */
    addressOn: {
        (chainId: number, strictMode: true): Hex;
        (chainId: number, strictMode?: false): Hex | undefined;
    };
};
export type MultichainSmartAccount = BaseMultichainSmartAccount & {
    /**
     * Function to retrieve the unified ERC20 balance across all deployments
     * @param mcToken - The multichain token to query
     * @returns The unified ERC20 balance across all deployments
     * @example
     * const balance = await mcAccount.getUnifiedERC20Balance(mcUSDC)
     */
    getUnifiedERC20Balance: (mcToken: MultichainToken) => Promise<UnifiedERC20Balance>;
    /**
     * Function to build instructions for bridging a token across all deployments
     * @param params - The parameters for the balance requirement
     * @returns Instructions for any required bridging operations
     * @example
     * const instructions = await mcAccount.build({
     *   amount: BigInt(1000),
     *   mcToken: mcUSDC,
     *   toChain: base
     * })
     */
    build: (params: BuildInstructionTypes, currentInstructions?: Instruction[]) => Promise<Instruction[]>;
    /**
     * Function to build composable instructions
     * @param params - The parameters for the composable instruction
     * @returns Returns composable instructions
     * @example
     * const instructions = await mcAccount.build({
     *   amount: BigInt(1000),
     *   mcToken: mcUSDC,
     *   toChain: base
     * })
     */
    buildComposable: (params: BuildComposableInstructionTypes, currentInstructions?: Instruction[]) => Promise<Instruction[]>;
    /**
     * Function to build action policy for smart sessions
     * @param params - The parameters for the smart session action policies
     * @returns Action policy
     * @example
     * const actionPolicy = await mcAccount.buildActionPolicy({
     *   type: "sudo"
     * })
     */
    buildActionPolicy: (params: BuildActionPolicyParamTypes) => PolicyData;
    /**
     * Function to build actions for smart sessions
     * @param params - The parameters for the smart session actions
     * @returns Action
     * @example
     * const action = await mcAccount.buildSessionAction({
     *   type: "transfer",
     *   data: { chainIds: [1, 10], contractAddress: "0x...", policies: [{ type: "sudo" }] }
     * })
     */
    buildSessionAction: (params: BuildSessionActionTypes) => SessionAction[];
    /**
     * Function to build instructions for bridging a token across all deployments
     * @param params - The parameters for the balance requirement
     * @returns Instructions for any required bridging operations
     * @example
     * const instructions = await mcAccount.buildBridgeInstructions({
     *   amount: BigInt(1000),
     *   mcToken: mcUSDC,
     *   toChain: base
     * })
     */
    buildBridgeInstructions: (params: Omit<MultichainBridgingParams, "account">) => Promise<BridgingInstructions>;
    /**
     * Function to query the bridge
     * @param params - The parameters for the bridge query
     * @returns The bridge query result
     * @example
     * const result = await mcAccount.queryBridge({
     *   amount: BigInt(1000),
     *   mcToken: mcUSDC,
     *   toChain: base
     * })
     */
    queryBridge: (params: QueryBridgeParams) => Promise<BridgeQueryResult | null>;
    /**
     * Function to check if the account is delegated
     * @returns True if the account is delegated, false otherwise
     * @example
     * const isDelegated = await mcAccount.isDelegated()
     */
    isDelegated: (parameter?: IsDelegatedParameters) => Promise<IsDelegatedPayload>;
    /**
     * Function to get the composability version for a specific chain
     * @param chainId - The ID of the chain to query
     * @returns The composability version of a given multichain account on the specified chain
     * @example
     * const composabilityVersion = await mcAccount.getComposabilityVersion(1)
     */
    getComposabilityVersion: (chainId: number) => ComposabilityVersion;
    /**
     * Function to get the MEE version for a specific chain
     * @param chainId - The ID of the chain to query
     * @returns The MEE version of a given multichain account on the specified chain
     * @example
     * const meeVersion = await mcAccount.getMeeVersion(1)
     */
    getMeeVersion: (chainId: number) => MEEVersion;
    /**
     * Function to undelegate the account
     * @returns The transaction hashes of the undelegate transactions
     * @example
     * const receipts = await mcAccount.unDelegate()
     */
    unDelegate: (parameters?: UnDelegateParameters) => Promise<UnDelegatePayload>;
    /**
     * Function to wait for transaction receipts
     * @param hashes - The transaction hashes to wait for
     * @returns The transaction receipts
     * @example
     * const receipts = await mcAccount.waitForTransactionReceipts([hash1, hash2])
     */
    waitForTransactionReceipts: (parameters: WaitForTransactionReceiptParameters) => Promise<WaitForTransactionReceiptPayload>;
    /**
     * Function to read data across all deployments
     * @param params - The parameters for the read
     * @returns The read data
     */
    read: <T>(params: MultichainReadParameters) => Promise<MultiChainReadPayload<T>[]>;
    /**
     * Function to get the delegation data for the account.
     * The chainId will be 0 for multi-chain authorization.
     * @returns The delegation data.
     * @example
     * const delegation = await mcAccount.toDelegation()
     */
    toDelegation: (params?: DelegationParams) => Promise<MeeAuthorization>;
    /**
     * Creates instructions to set ownership data on the StxValidator across all chains.
     * Use this when no ownership data exists yet for the given ownership type.
     * @param params - Ownership type and optional ownership data override
     * @returns Instructions calling setOwnershipData on every configured chain
     */
    addOwnership: (params: OwnershipParamsWithData) => Instruction[];
    /**
     * Creates instructions to change existing ownership data on the StxValidator across all chains.
     * Reads current ownership data first and throws if none exists (use addOwnership instead).
     * @param params - Ownership type and optional ownership data override
     * @returns Instructions calling setOwnershipData on every configured chain
     */
    changeOwnership: (params: OwnershipParamsWithData) => Promise<Instruction[]>;
    /**
     * Creates instructions to remove ownership data from the StxValidator across all chains.
     * @param params - Ownership type to clean, with optional chainIds filter
     * @returns Instructions calling cleanOwnershipData on every configured chain
     */
    cleanOwnership: (params: OwnershipParams) => Instruction[];
    /**
     * Reads ownership data from the StxValidator across all chains.
     * @param params - Ownership type to query, with optional chainIds filter
     * @returns Ownership data per chain
     */
    getOwnership: (params: OwnershipParams) => Promise<OwnershipResult[]>;
};
/**
 * Creates a multichain Nexus account across specified chains
 *
 * @param parameters - {@link MultichainNexusParams} Configuration for multichain account creation
 * @param parameters.signer - The signer instance used for account creation
 * @param parameters.chainConfigurations - Array of chain configuration objects where the account will be deployed
 *
 * @returns Promise resolving to {@link MultichainSmartAccount} instance
 *
 * @throws Error if account creation fails on any chain
 *
 * @example
 * const account = await toMultichainNexusAccount({
 *   signer: mySigner,
 *   chainConfigurations: [
 *     {
 *       chain: optimism,
 *       transport: http(),
 *       version: getMEEVersion(MEEversion.V2_1_0)
 *     },
 *     {
 *       chain: base,
 *       transport: http(),
 *       version: getMEEVersion(MEEversion.V2_1_0)
 *     }
 *   ]
 * });
 *
 * // Get deployment on specific chain
 * const optimismDeployment = account.deploymentOn(10);
 *
 * // Check token balance across chains
 * const balance = await account.getUnifiedERC20Balance(mcUSDC);
 *
 * // Build bridge transaction
 * const bridgeInstructions = await account.buildBridgeInstructions({
 *   amount: BigInt("1000000"), // 1 USDC
 *   mcToken: mcUSDC,
 *   toChain: base
 * });
 */
export declare function toMultichainNexusAccount(multiChainNexusParams: MultichainNexusParams): Promise<MultichainSmartAccount>;
//# sourceMappingURL=toMultiChainNexusAccount.d.ts.map