import { type Address } from "viem";
import type { LucidlyClient } from "./client.js";
import type { TxResult } from "./types.js";
export interface StrategyAction {
    protocol: string;
    action: "approve" | "supply" | "withdraw" | "swap";
    asset: Address | string;
    /** For swaps: the output token. */
    tokenOut?: Address | string;
    amount: bigint;
    /** For swaps: minimum acceptable output (amountOutMinimum). */
    minOut?: bigint;
}
export interface StrategyIntent {
    protocol: string;
    action: "approve" | "supply" | "withdraw" | "swap";
    asset: Address | string;
    tokenOut?: Address | string;
}
export declare class StrategyModule {
    private readonly c;
    constructor(c: LucidlyClient);
    private state;
    private resolve;
    /** Execute a batch of whitelisted actions atomically in one manageVaultWithMerkleVerification tx. */
    execute(vault: Address, actions: StrategyAction[]): Promise<TxResult>;
    /** Check (the agent safety guard) whether a matching leaf exists for an intent. */
    hasLeaf(vault: Address, intent: StrategyIntent): boolean;
    /**
     * Swap `amount` of `from` into `to` via Uniswap V3 (batches approve + exactInputSingle).
     * On mainnet a slippage guard is required: pass `minOut`, or `allowZeroMinOut: true` to opt out.
     */
    swap(vault: Address, params: {
        from: Address | string;
        to: Address | string;
        amount: bigint;
        minOut?: bigint;
        allowZeroMinOut?: boolean;
    }): Promise<TxResult>;
    readonly aave: {
        /** Supply `amount` of `asset` into Aave (batches approve + supply in one tx). */
        supply: (vault: Address, params: {
            asset: Address | string;
            amount: bigint;
        }) => Promise<TxResult>;
        /** Withdraw `amount` of `asset` from Aave back to the vault. */
        withdraw: (vault: Address, params: {
            asset: Address | string;
            amount: bigint;
        }) => Promise<TxResult>;
    };
}