import * as _enzymefinance_ethers from '@enzymefinance/ethers';
import { AddressLike, ContractReceipt, Contract, Call, Send } from '@enzymefinance/ethers';
import * as _enzymefinance_hardhat from '@enzymefinance/hardhat';
import { SignerWithAddress, EthereumTestnetProvider } from '@enzymefinance/hardhat';
import * as ethers from 'ethers';
import { BigNumberish, utils, BigNumber, Signer, BytesLike } from 'ethers';
import * as hardhat_deploy_dist_types from 'hardhat-deploy/dist/types';
import * as _enzymefinance_protocol from '@enzymefinance/protocol';
import { AaveAdapter, AaveDebtPositionLib, AaveDebtPositionParser, AavePriceFeed, AddressListRegistry, AllowedAdapterIncomingAssetsPolicy, AllowedAdaptersPerManagerPolicy, AllowedAdaptersPolicy, AllowedAssetsForRedemptionPolicy, AllowedDepositRecipientsPolicy, AllowedExternalPositionTypesPerManagerPolicy, AllowedExternalPositionTypesPolicy, AllowedSharesTransferRecipientsPolicy, ArbitraryLoanFixedInterestModule, ArbitraryLoanPositionLib, ArbitraryLoanPositionParser, ArbitraryLoanTotalNominalDeltaOracleModule, ArbitraryTokenPhasedSharesWrapperFactory, CompoundAdapter, CompoundDebtPositionLib, CompoundDebtPositionParser, CompoundPriceFeed, ComptrollerLib, ConvexCurveLpStakingAdapter, ConvexCurveLpStakingWrapperFactory, ConvexCurveLpStakingWrapperPriceFeed, ConvexVotingPositionLib, ConvexVotingPositionParser, CumulativeSlippageTolerancePolicy, CurveExchangeAdapter, CurveLiquidityAdapter, CurvePriceFeed, DepositWrapper, Dispatcher, EntranceRateBurnFee, EntranceRateDirectFee, ExitRateBurnFee, ExitRateDirectFee, ExternalPositionFactory, ExternalPositionManager, FeeManager, FiduPriceFeed, FundDeployer, FundValueCalculator, FundValueCalculatorRouter, FundValueCalculatorUsdWrapper, FuseAdapter, FusePriceFeed, GasRelayPaymasterFactory, GlobalConfigLib, IdleAdapter, IdlePriceFeed, IntegrationManager, LidoStethPriceFeed, LiquityDebtPositionLib, LiquityDebtPositionParser, ManagementFee, ManualValueOracleFactory, MapleLiquidityPositionLib, MapleLiquidityPositionParser, MinAssetBalancesPostRedemptionPolicy, MinMaxInvestmentPolicy, NotionalV2PositionLib, NotionalV2PositionParser, MinSharesSupplyFee, OlympusV2Adapter, OnlyRemoveDustExternalPositionPolicy, OnlyUntrackDustOrPricelessAssetsPolicy, ParaSwapV5Adapter, PerformanceFee, PolicyManager, PoolTogetherV4Adapter, PoolTogetherV4PriceFeed, ProtocolFeeReserveLib, ProtocolFeeTracker, RevertingPriceFeed, SharesSplitterFactory, SynthetixAdapter, UintListRegistry, UniswapV2ExchangeAdapter, UniswapV2LiquidityAdapter, UniswapV2PoolPriceFeed, UniswapV3Adapter, UnpermissionedActionsWrapper, UsdEthSimulatedAggregator, ValueInterpreter, VaultLib, YearnVaultV2Adapter, YearnVaultV2PriceFeed, ZeroExV2Adapter, ChainlinkRateAsset, CreateSignedRelayRequestOptions, IGsnRelayHub, StandardToken, MockChainlinkPriceSource, IExternalPositionProxy, VotiumClaimParam, MockGenericExternalPositionParser, MockGenericExternalPositionLib, IFee, ICERC20, CurveRedeemType, MockGenericAdapter, ParaSwapV5Path, SignedZeroExV2Order, IPolicy, ArbitraryTokenPhasedSharesWrapperLib, ManualValueOracleLib, SharesSplitterLib, ComptrollerProxy, GasRelayPaymasterLib, AddressListUpdateType } from '@enzymefinance/protocol';
import { MerkleTree } from 'merkletreejs';

declare function impersonateContractSigner({ contractAddress, ethSeeder, provider, }: {
    contractAddress: AddressLike;
    ethSeeder: SignerWithAddress;
    provider: EthereumTestnetProvider;
}): Promise<SignerWithAddress>;
declare function impersonateSigner({ signerAddress, provider, }: {
    signerAddress: AddressLike;
    provider: EthereumTestnetProvider;
}): Promise<SignerWithAddress>;
declare function seedAccount({ account, amount, provider, token, }: {
    account: AddressLike;
    amount: BigNumberish;
    provider: EthereumTestnetProvider;
    token: AddressLike;
}): Promise<void>;
interface SlotInfo {
    slot: number;
    storageAddress?: string;
    isVyper: boolean;
}
declare function findTokenBalanceStorageSlot(token: AddressLike, provider: EthereumTestnetProvider): Promise<SlotInfo | undefined>;

declare function assertEvent<TResult = any>(receipt: ContractReceipt<any>, event: utils.EventFragment | string, match?: TResult): NonNullable<TResult>;
declare function assertNoEvent(receipt: ContractReceipt<any>, event: utils.EventFragment | string): void;

declare function getNamedSigner(name: string): Promise<_enzymefinance_hardhat.SignerWithAddress>;
declare function getUnnamedSigners(): Promise<_enzymefinance_hardhat.SignerWithAddress[]>;
declare function deployProtocolFixture(): Promise<{
    readonly accounts: _enzymefinance_hardhat.SignerWithAddress[];
    readonly config: DeploymentConfig;
    readonly deployer: _enzymefinance_hardhat.SignerWithAddress;
    readonly deployment: {
        readonly aaveAdapter: AaveAdapter;
        readonly aaveDebtPositionLib: AaveDebtPositionLib;
        readonly aaveDebtPositionParser: AaveDebtPositionParser;
        readonly aavePriceFeed: AavePriceFeed;
        readonly addressListRegistry: AddressListRegistry;
        readonly allowedAdapterIncomingAssetsPolicy: AllowedAdapterIncomingAssetsPolicy;
        readonly allowedAdaptersPerManagerPolicy: AllowedAdaptersPerManagerPolicy;
        readonly allowedAdaptersPolicy: AllowedAdaptersPolicy;
        readonly allowedAssetsForRedemptionPolicy: AllowedAssetsForRedemptionPolicy;
        readonly allowedDepositRecipientsPolicy: AllowedDepositRecipientsPolicy;
        readonly allowedExternalPositionTypesPerManagerPolicy: AllowedExternalPositionTypesPerManagerPolicy;
        readonly allowedExternalPositionTypesPolicy: AllowedExternalPositionTypesPolicy;
        readonly allowedSharesTransferRecipientsPolicy: AllowedSharesTransferRecipientsPolicy;
        readonly arbitraryLoanFixedInterestModule: ArbitraryLoanFixedInterestModule;
        readonly arbitraryLoanPositionLib: ArbitraryLoanPositionLib;
        readonly arbitraryLoanPositionParser: ArbitraryLoanPositionParser;
        readonly arbitraryLoanTotalNominalDeltaOracleModule: ArbitraryLoanTotalNominalDeltaOracleModule;
        readonly arbitraryTokenPhasedSharesWrapperFactory: ArbitraryTokenPhasedSharesWrapperFactory;
        readonly compoundAdapter: CompoundAdapter;
        readonly compoundDebtPositionLib: CompoundDebtPositionLib;
        readonly compoundDebtPositionParser: CompoundDebtPositionParser;
        readonly compoundPriceFeed: CompoundPriceFeed;
        readonly comptrollerLib: ComptrollerLib;
        readonly convexCurveLpStakingAdapter: ConvexCurveLpStakingAdapter;
        readonly convexCurveLpStakingWrapperFactory: ConvexCurveLpStakingWrapperFactory;
        readonly convexCurveLpStakingWrapperPriceFeed: ConvexCurveLpStakingWrapperPriceFeed;
        readonly convexVotingPositionLib: ConvexVotingPositionLib;
        readonly convexVotingPositionParser: ConvexVotingPositionParser;
        readonly cumulativeSlippageTolerancePolicy: CumulativeSlippageTolerancePolicy;
        readonly curveExchangeAdapter: CurveExchangeAdapter;
        readonly curveLiquidityAdapter: CurveLiquidityAdapter;
        readonly curvePriceFeed: CurvePriceFeed;
        readonly depositWrapper: DepositWrapper;
        readonly dispatcher: Dispatcher;
        readonly entranceRateBurnFee: EntranceRateBurnFee;
        readonly entranceRateDirectFee: EntranceRateDirectFee;
        readonly exitRateBurnFee: ExitRateBurnFee;
        readonly exitRateDirectFee: ExitRateDirectFee;
        readonly externalPositionFactory: ExternalPositionFactory;
        readonly externalPositionManager: ExternalPositionManager;
        readonly feeManager: FeeManager;
        readonly fiduPriceFeed: FiduPriceFeed;
        readonly fundDeployer: FundDeployer;
        readonly fundValueCalculator: FundValueCalculator;
        readonly fundValueCalculatorRouter: FundValueCalculatorRouter;
        readonly fundValueCalculatorUsdWrapper: FundValueCalculatorUsdWrapper;
        readonly fuseAdapter: FuseAdapter;
        readonly fusePriceFeed: FusePriceFeed;
        readonly gasRelayPaymasterFactory: GasRelayPaymasterFactory;
        readonly globalConfigLib: GlobalConfigLib;
        readonly globalConfigProxy: GlobalConfigLib;
        readonly idleAdapter: IdleAdapter;
        readonly idlePriceFeed: IdlePriceFeed;
        readonly integrationManager: IntegrationManager;
        readonly lidoStethPriceFeed: LidoStethPriceFeed;
        readonly liquityDebtPositionLib: LiquityDebtPositionLib;
        readonly liquityDebtPositionParser: LiquityDebtPositionParser;
        readonly managementFee: ManagementFee;
        readonly manualValueOracleFactory: ManualValueOracleFactory;
        readonly mapleLiquidityPositionLib: MapleLiquidityPositionLib;
        readonly mapleLiquidityPositionParser: MapleLiquidityPositionParser;
        readonly minAssetBalancesPostRedemptionPolicy: MinAssetBalancesPostRedemptionPolicy;
        readonly minMaxInvestmentPolicy: MinMaxInvestmentPolicy;
        readonly notionalV2Position: NotionalV2PositionLib;
        readonly notionalV2PositionParser: NotionalV2PositionParser;
        readonly minSharesSupplyFee: MinSharesSupplyFee;
        readonly olympusV2Adapter: OlympusV2Adapter;
        readonly onlyRemoveDustExternalPositionPolicy: OnlyRemoveDustExternalPositionPolicy;
        readonly onlyUntrackDustOrPricelessAssetsPolicy: OnlyUntrackDustOrPricelessAssetsPolicy;
        readonly paraSwapV5Adapter: ParaSwapV5Adapter;
        readonly performanceFee: PerformanceFee;
        readonly policyManager: PolicyManager;
        readonly poolTogetherV4Adapter: PoolTogetherV4Adapter;
        readonly poolTogetherV4PriceFeed: PoolTogetherV4PriceFeed;
        readonly protocolFeeReserveLib: ProtocolFeeReserveLib;
        readonly protocolFeeReserveProxy: ProtocolFeeReserveLib;
        readonly protocolFeeTracker: ProtocolFeeTracker;
        readonly revertingPriceFeed: RevertingPriceFeed;
        readonly sharesSplitterFactory: SharesSplitterFactory;
        readonly synthetixAdapter: SynthetixAdapter;
        readonly uintListRegistry: UintListRegistry;
        readonly uniswapV2ExchangeAdapter: UniswapV2ExchangeAdapter;
        readonly uniswapV2LiquidityAdapter: UniswapV2LiquidityAdapter;
        readonly uniswapV2PoolPriceFeed: UniswapV2PoolPriceFeed;
        readonly uniswapV3Adapter: UniswapV3Adapter;
        readonly unpermissionedActionsWrapper: UnpermissionedActionsWrapper;
        readonly usdEthSimulatedAggregator: UsdEthSimulatedAggregator;
        readonly valueInterpreter: ValueInterpreter;
        readonly vaultLib: VaultLib;
        readonly yearnVaultV2Adapter: YearnVaultV2Adapter;
        readonly yearnVaultV2PriceFeed: YearnVaultV2PriceFeed;
        readonly zeroExV2Adapter: ZeroExV2Adapter;
    };
    readonly fixture: {
        [name: string]: hardhat_deploy_dist_types.Deployment;
    };
}>;
declare type Resolve<T extends () => any> = ReturnType<T> extends Promise<infer U> ? U : ReturnType<T>;
declare type ProtocolDeployment = Resolve<typeof deployProtocolFixture>;

interface DeploymentConfig {
    feeBps: number;
    feeToken: string;
    feeTokenBurn: {
        burnFromVault: boolean;
        sendToProtocolFeeReserve: boolean;
        externalBurnerAddress: string;
    };
    weth: string;
    wrappedNativeAsset: string;
    primitives: Record<string, string>;
    gsn: {
        relayHub: string;
        relayWorker: string;
        trustedForwarder: string;
    };
    chainlink: {
        ethusd: string;
        aggregators: Record<string, readonly [string, ChainlinkRateAsset]>;
    };
    synthetix: {
        snx: string;
        susd: string;
        delegateApprovals: string;
        originator: string;
        redeemer: string;
        trackingCode: string;
    };
    convex: {
        booster: string;
        crvToken: string;
        cvxCrvStaking: string;
        cvxToken: string;
        vlCvx: string;
        vlCvxExtraRewards: string;
        votiumMultiMerkleStash: string;
    };
    curve: {
        addressProvider: string;
        minter: string;
        nativeAssetAddress: string;
        poolOwner: string;
        pools: Record<string, {
            pool: string;
            lpToken: string;
            liquidityGaugeToken: string;
            invariantProxyAsset: string;
            hasReentrantVirtualPrice: boolean;
        }>;
        virtualPriceDeviationThreshold: number;
    };
    aave: {
        incentivesController: string;
        lendingPoolAddressProvider: string;
        protocolDataProvider: string;
        atokens: Record<string, [string, string]>;
    };
    compound: {
        ceth: string;
        comptroller: string;
        ctokens: Record<string, string>;
    };
    fuse: {
        fetherTokens: Record<string, string>;
        ftokens: Record<string, string>;
    };
    goldfinch: {
        fidu: string;
        seniorPool: string;
    };
    idle: {
        bestYieldIdleDai: string;
        bestYieldIdleUsdc: string;
        bestYieldIdleUsdt: string;
        bestYieldIdleSusd: string;
        bestYieldIdleWbtc: string;
        riskAdjustedIdleDai: string;
        riskAdjustedIdleUsdc: string;
        riskAdjustedIdleUsdt: string;
    };
    lido: {
        steth: string;
    };
    liquity: {
        borrowerOperations: string;
        troveManager: string;
    };
    maple: {
        mplRewardsFactory: string;
        poolFactory: string;
    };
    notional: {
        notionalContract: string;
    };
    olympusV2: {
        stakingContract: string;
    };
    paraSwapV5: {
        augustusSwapper: string;
        tokenTransferProxy: string;
        feePartner: string;
        feePercent: number;
    };
    poolTogetherV4: {
        ptTokens: Record<string, [string, string]>;
    };
    positionsLimit: number;
    snapshot: {
        delegateRegistry: string;
    };
    solvFinanceV2: {
        convertibleMarket: string;
        initialConvertibleOfferingMarket: string;
        deployer: string;
        priceOracleManager: string;
        manualPriceOracle: string;
        convertibles: Record<'perp' | 'usf', {
            underlying: string;
            voucher: string;
            pool: string;
        }>;
    };
    theGraph: {
        stakingProxy: string;
        grt: string;
    };
    unsupportedAssets: Record<string, string>;
    uniswap: {
        factory: string;
        router: string;
        pools: Record<string, string>;
    };
    uniswapV3: {
        router: string;
        nonFungiblePositionManager: string;
    };
    yearn: {
        vaultV2: {
            registry: string;
            yVaults: Record<string, string>;
        };
    };
    zeroex: {
        exchange: string;
        allowedMakers: string[];
    };
}

interface RelayTransactionOptions extends CreateSignedRelayRequestOptions {
    relayHub: string;
}
declare function relayTransaction(options: RelayTransactionOptions): Promise<ContractReceipt<_enzymefinance_ethers.SendFunction<[maxAcceptanceBudget: BigNumberish, relayRequest: {
    request: {
        from: _enzymefinance_ethers.AddressLike;
        to: _enzymefinance_ethers.AddressLike;
        value: BigNumberish;
        gas: BigNumberish;
        nonce: BigNumberish;
        data: utils.BytesLike;
        validUntil: BigNumberish;
    };
    relayData: {
        gasPrice: BigNumberish;
        pctRelayFee: BigNumberish;
        baseRelayFee: BigNumberish;
        relayWorker: _enzymefinance_ethers.AddressLike;
        paymaster: _enzymefinance_ethers.AddressLike;
        forwarder: _enzymefinance_ethers.AddressLike;
        paymasterData: utils.BytesLike;
        clientId: BigNumberish;
    };
}, signature: utils.BytesLike, approvalData: utils.BytesLike, externalGasLimit: BigNumberish], {
    paymasterAccepted: boolean;
    returnValue: string;
}, IGsnRelayHub>>>;
declare function assertDidRelay(receipt: ContractReceipt<any>): {
    charge: any;
    from: any;
    paymaster: any;
    relayManager: any;
    relayWorker: any;
    selector: any;
    status: any;
    to: any;
};
declare function assertDidRelaySuccessfully(receipt: ContractReceipt<any>): void;
declare function assertDidRelayWithError(receipt: ContractReceipt<any>): void;
declare function assertDidRelayWithCharge(receipt: ContractReceipt<any>, amount: BigNumberish, tolerance?: BigNumberish): void;
declare function assertPaymasterDidReject(receipt: ContractReceipt<any>): {
    from: any;
    innerGasUsed: any;
    paymaster: any;
    reason: any;
    relayManager: any;
    relayWorker: any;
    selector: any;
    to: any;
};
declare function assertPaymasterDidRejectForReason(receipt: ContractReceipt<any>, reason: string): void;

declare function calcMlnValueAndBurnAmountForSharesBuyback({ valueInterpreter, mln, denominationAsset, sharesSupply, gav, buybackSharesAmount, }: {
    valueInterpreter: ValueInterpreter;
    mln: AddressLike;
    denominationAsset: AddressLike;
    sharesSupply: BigNumberish;
    gav: BigNumberish;
    buybackSharesAmount: BigNumberish;
}): Promise<{
    mlnAmountToBurn: BigNumber;
    mlnValue: BigNumber;
}>;
declare function generateMerkleTreeForContractProof({ itemArrays, itemTypes, }: {
    itemArrays: any[];
    itemTypes: string[];
}): {
    leaves: string[];
    root: string;
    tree: MerkleTree;
};
declare function sendEthBySelfDestruct({ signer, recipient, amount, }: {
    signer: SignerWithAddress;
    recipient: AddressLike;
    amount?: BigNumberish;
}): Promise<void>;
declare function transactionTimestamp(receipt: ContractReceipt<any>): Promise<number>;

declare function addNewAssetsToFund({ signer, comptrollerProxy, integrationManager, assets, amounts, provider, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    assets: StandardToken[];
    amounts?: BigNumberish[];
    provider: EthereumTestnetProvider;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function updateChainlinkAggregator(aggregator: MockChainlinkPriceSource, price?: BigNumberish): Promise<void>;

declare function getAssetBalances({ account, assets }: {
    account: AddressLike;
    assets: AddressLike[];
}): Promise<ethers.BigNumber[]>;
declare function getAssetUnit(asset: StandardToken): Promise<ethers.BigNumber>;

declare function createFundDeployer({ deployer, externalPositionManager, dispatcher, gasRelayPaymasterFactory, valueInterpreter, vaultLib, setOnDispatcher, setReleaseLive, }: {
    deployer: Signer;
    externalPositionManager: ExternalPositionManager;
    dispatcher: Dispatcher;
    feeManager: FeeManager;
    gasRelayPaymasterFactory: GasRelayPaymasterFactory;
    integrationManager: IntegrationManager;
    policyManager: PolicyManager;
    valueInterpreter: ValueInterpreter;
    vaultLib: VaultLib;
    setOnDispatcher?: boolean;
    setReleaseLive?: boolean;
}): Promise<FundDeployer>;

declare function callOnExtension({ comptrollerProxy, extension, actionId, callArgs, signer, }: {
    comptrollerProxy: ComptrollerLib;
    extension: AddressLike;
    actionId: BigNumberish;
    callArgs?: BytesLike;
    signer?: SignerWithAddress;
}): Promise<any>;

declare function aaveDebtPositionAddCollateral({ comptrollerProxy, externalPositionManager, signer, aTokens, amounts, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    aTokens: AddressLike[];
    amounts: BigNumberish[];
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function aaveDebtPositionBorrow({ comptrollerProxy, externalPositionManager, signer, tokens, amounts, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    tokens: AddressLike[];
    amounts: BigNumberish[];
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function aaveDebtPositionClaimRewards({ comptrollerProxy, externalPositionManager, signer, assets, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    assets: AddressLike[];
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function aaveDebtPositionRemoveCollateral({ comptrollerProxy, externalPositionManager, signer, aTokens, amounts, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    aTokens: AddressLike[];
    amounts: BigNumberish[];
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function aaveDebtPositionRepayBorrow({ comptrollerProxy, externalPositionManager, signer, tokens, amounts, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    tokens: AddressLike[];
    amounts: BigNumberish[];
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function createAaveDebtPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
}>;

declare function callOnExternalPosition({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, actionId, actionArgs, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    actionId: BigNumberish;
    actionArgs: BytesLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function createExternalPosition({ signer, comptrollerProxy, externalPositionManager, externalPositionTypeId, initializationData, callOnExternalPositionData, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionTypeId: BigNumberish;
    initializationData?: BytesLike;
    callOnExternalPositionData?: BytesLike;
}): Promise<{
    externalPositionProxy: IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>;
}>;
declare function reactivateExternalPosition({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function removeExternalPosition({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;

declare function arbitraryLoanPositionCallOnAccountingModule({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function arbitraryLoanPositionCloseLoan({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, extraAssetsToSweep, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    extraAssetsToSweep?: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function arbitraryLoanPositionConfigureLoan({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, borrower, loanAsset, amount, accountingModule, accountingModuleConfigData, description, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    borrower: AddressLike;
    loanAsset: AddressLike;
    amount: BigNumberish;
    accountingModule: AddressLike;
    accountingModuleConfigData: BytesLike;
    description?: string;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function arbitraryLoanPositionReconcile({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, extraAssetsToSweep, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    extraAssetsToSweep?: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function arbitraryLoanPositionUpdateBorrowableAmount({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, amountDelta, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    amountDelta: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function createArbitraryLoanPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>;
}>;

declare function compoundDebtPositionAddCollateral({ comptrollerProxy, externalPositionManager, fundOwner, assets, amounts, externalPositionProxy, cTokens, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    fundOwner: SignerWithAddress;
    assets: AddressLike[];
    cTokens: AddressLike[];
    amounts: BigNumberish[];
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function compoundDebtPositionBorrow({ comptrollerProxy, externalPositionManager, fundOwner, externalPositionProxy, assets, amounts, cTokens, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    externalPositionManager: ExternalPositionManager;
    fundOwner: SignerWithAddress;
    externalPositionProxy: AddressLike;
    assets: AddressLike[];
    amounts: BigNumberish[];
    cTokens: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function compoundDebtPositionClaimComp({ comptrollerProxy, externalPositionManager, fundOwner, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    externalPositionManager: ExternalPositionManager;
    fundOwner: SignerWithAddress;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function compoundDebtPositionRemoveCollateral({ comptrollerProxy, externalPositionManager, fundOwner, assets, amounts, externalPositionProxy, cTokens, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    fundOwner: SignerWithAddress;
    assets: AddressLike[];
    amounts: BigNumberish[];
    externalPositionProxy: AddressLike;
    cTokens: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function compoundDebtPositionRepayBorrow({ comptrollerProxy, externalPositionManager, fundOwner, assets, amounts, externalPositionProxy, cTokens, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    fundOwner: SignerWithAddress;
    assets: AddressLike[];
    amounts: BigNumberish[];
    externalPositionProxy: AddressLike;
    cTokens: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function createCompoundDebtPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
}>;

declare function createConvexVotingPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
}>;
declare function convexVotingPositionClaimRewards({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, claimLockerRewards, extraRewardTokens, votiumClaims, unstakeCvxCrv, allTokensToTransfer, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    claimLockerRewards: boolean;
    extraRewardTokens: AddressLike[];
    votiumClaims: VotiumClaimParam[];
    unstakeCvxCrv: boolean;
    allTokensToTransfer: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function convexVotingPositionDelegate({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, delegatee, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    delegatee: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function convexVotingPositionLock({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, amount, spendRatio, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    amount: BigNumberish;
    spendRatio?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function convexVotingPositionRelock({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function convexVotingPositionWithdraw({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

interface ILiquityTroveManager extends Contract<ILiquityTroveManager> {
    getBorrowingFee: Call<(_LUSDDebt: BigNumberish) => BigNumber>;
}
declare const ILiquityTroveManager: _enzymefinance_ethers.ContractFactory<ILiquityTroveManager, never>;
interface ILiquityHintHelper extends Contract<ILiquityHintHelper> {
    getApproxHint: Call<(_cr: BigNumberish, _numTrials: BigNumberish, _inputRandomSeed: BigNumberish) => [hintAddress_: AddressLike, diff_: BigNumber, latestRandomSeed_: BigNumber]>;
}
declare const ILiquityHintHelper: _enzymefinance_ethers.ContractFactory<ILiquityHintHelper, never>;
interface ILiquitySortedTroves extends Contract<ILiquitySortedTroves> {
    findInsertPosition: Call<(_icr: BigNumberish, _prevId: AddressLike, _nextId: AddressLike) => [prevId_: AddressLike, nextId_: AddressLike]>;
}
declare const ILiquitySortedTroves: _enzymefinance_ethers.ContractFactory<ILiquitySortedTroves, never>;
declare function createLiquityDebtPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>;
}>;
declare function liquityCalcHints({ collateralAmount, debtAmount, // Total debt, inclusive of fees
numTrials, // See note above for recommended value. This helper uses a static value for testing purposes.
liquitySortedTroves, liquityHintHelper, inputRandomSeed, }: {
    collateralAmount: BigNumber;
    debtAmount: BigNumber;
    numTrials?: BigNumber;
    liquitySortedTroves: ILiquitySortedTroves;
    liquityHintHelper: ILiquityHintHelper;
    inputRandomSeed?: BigNumber;
}): Promise<{
    lowerHint: AddressLike;
    upperHint: AddressLike;
}>;
declare function liquityDebtPositionAddCollateral({ comptrollerProxy, externalPositionManager, signer, collateralAmount, upperHint, lowerHint, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    collateralAmount: BigNumberish;
    upperHint: AddressLike;
    lowerHint: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function liquityDebtPositionBorrow({ comptrollerProxy, externalPositionManager, signer, maxFeePercentage, lusdAmount, upperHint, lowerHint, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    maxFeePercentage: BigNumberish;
    lusdAmount: BigNumberish;
    upperHint: AddressLike;
    lowerHint: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function liquityDebtPositionCloseTrove({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function liquityDebtPositionOpenTrove({ comptrollerProxy, externalPositionManager, signer, maxFeePercentage, collateralAmount, lusdAmount, upperHint, lowerHint, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    maxFeePercentage: BigNumberish;
    collateralAmount: BigNumberish;
    lusdAmount: BigNumberish;
    upperHint: AddressLike;
    lowerHint: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function liquityDebtPositionRemoveCollateral({ comptrollerProxy, externalPositionManager, signer, collateralAmount, upperHint, lowerHint, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    collateralAmount: BigNumberish;
    upperHint: AddressLike;
    lowerHint: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function liquityDebtPositionRepay({ comptrollerProxy, externalPositionManager, signer, lusdAmount, upperHint, lowerHint, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    lusdAmount: BigNumberish;
    upperHint: AddressLike;
    lowerHint: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

declare function createMapleLiquidityPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
}>;
declare function mapleLiquidityPositionClaimInterest({ comptrollerProxy, externalPositionManager, signer, pool, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    pool: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionClaimRewards({ comptrollerProxy, externalPositionManager, signer, rewardsContract, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    rewardsContract: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionIntendToRedeem({ comptrollerProxy, externalPositionManager, signer, pool, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    pool: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionLend({ comptrollerProxy, externalPositionManager, signer, liquidityAssetAmount, pool, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    pool: AddressLike;
    liquidityAssetAmount: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionLendAndStake({ comptrollerProxy, externalPositionManager, signer, liquidityAssetAmount, pool, rewardsContract, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    pool: AddressLike;
    rewardsContract: AddressLike;
    liquidityAssetAmount: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionRedeem({ comptrollerProxy, externalPositionManager, signer, liquidityAssetAmount, pool, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    liquidityAsset: AddressLike;
    pool: AddressLike;
    liquidityAssetAmount: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionStake({ comptrollerProxy, externalPositionManager, signer, poolTokenAmount, pool, rewardsContract, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    poolTokenAmount: BigNumberish;
    pool: AddressLike;
    rewardsContract: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionUnstake({ comptrollerProxy, externalPositionManager, signer, poolTokenAmount, rewardsContract, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    poolTokenAmount: BigNumberish;
    rewardsContract: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mapleLiquidityPositionUnstakeAndRedeem({ comptrollerProxy, externalPositionManager, signer, pool, poolTokenAmount, rewardsContract, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    pool: AddressLike;
    poolTokenAmount: BigNumberish;
    rewardsContract: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function createMockExternalPosition({ comptrollerProxy, externalPositionManager, externalPositionFactory, defaultActionAssetsToTransfer, defaultActionAmountsToTransfer, defaultActionAssetsToReceive, fundOwner, deployer, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionFactory: ExternalPositionFactory;
    defaultActionAssetsToTransfer: AddressLike[];
    defaultActionAmountsToTransfer: BigNumberish[];
    defaultActionAssetsToReceive: AddressLike[];
    fundOwner: SignerWithAddress;
    deployer: SignerWithAddress;
}): Promise<{
    externalPositionProxy: string;
    mockExternalPositionParser: MockGenericExternalPositionParser;
    mockGenericExternalPositionLib: MockGenericExternalPositionLib;
    receipt: {
        externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
        receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
    };
    typeId: ethers.BigNumber;
}>;
declare function mockExternalPositionAddDebtAssets({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, assets, amounts, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    assets: AddressLike[];
    amounts: BigNumberish[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mockExternalPositionAddManagedAssets({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, assets, amounts, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    assets: AddressLike[];
    amounts: BigNumberish[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mockExternalPositionRemoveDebtAssets({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, assets, amounts, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    assets: AddressLike[];
    amounts: BigNumberish[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function mockExternalPositionRemoveManagedAssets({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, assets, amounts, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    assets: AddressLike[];
    amounts: BigNumberish[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare enum NotionalV2MarketIndex {
    ThreeMonths = "1",
    SixMonths = "2",
    OneYear = "3",
    TwoYears = "4",
    FiveYears = "5",
    TenYears = "6",
    TwentyYears = "7"
}
declare enum NotionalV2CurrencyId {
    Eth = "1",
    Dai = "2",
    Usdc = "3"
}
declare function createNotionalV2Position({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
}>;
declare function notionalV2GetActiveMarketArraySlot(index: NotionalV2MarketIndex): number;
declare function notionalV2PositionAddCollateral({ comptrollerProxy, externalPositionManager, signer, currencyId, collateralAssetAmount, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    currencyId: BigNumberish;
    collateralAssetAmount: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function notionalV2PositionBorrow({ comptrollerProxy, externalPositionManager, signer, collateralCurrencyId, collateralAssetAmount, borrowCurrencyId, fCashAmount, marketIndex, minLendRate, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    collateralCurrencyId?: BigNumberish;
    borrowCurrencyId: BigNumberish;
    collateralAssetAmount?: BigNumberish;
    fCashAmount: BigNumberish;
    marketIndex: BigNumberish;
    minLendRate: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function notionalV2PositionLend({ comptrollerProxy, externalPositionManager, signer, currencyId, underlyingAssetAmount, fCashAmount, marketIndex, minLendRate, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    underlyingAssetAmount: BigNumberish;
    currencyId: BigNumberish;
    fCashAmount: BigNumberish;
    marketIndex: BigNumberish;
    minLendRate: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function notionalV2PositionRedeem({ comptrollerProxy, externalPositionManager, signer, currencyId, yieldTokenAmount, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    currencyId: BigNumberish;
    yieldTokenAmount: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function solvV2ConvertibleBuyerPositionBuyOffering({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, offerId, units, voucher, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    offerId: BigNumberish;
    units: BigNumberish;
    voucher: AddressLike;
}): Promise<{
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
    tokenId: BigNumber;
}>;
declare function solvV2ConvertibleBuyerPositionBuySaleByAmount({ comptrollerProxy, externalPositionManager, signer, amount, externalPositionProxy, saleId, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    amount: BigNumberish;
    externalPositionProxy: AddressLike;
    saleId: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleBuyerPositionBuySaleByUnits({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, saleId, units, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    saleId: BigNumberish;
    units: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleBuyerPositionClaim({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, tokenId, voucher, units, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    tokenId: BigNumberish;
    voucher: AddressLike;
    units?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleBuyerPositionCreateSaleDecliningPrice({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, voucher, tokenId, currency, min, max, startTime, useAllowList, highest, lowest, duration, interval, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    voucher: AddressLike;
    tokenId: BigNumberish;
    currency: AddressLike;
    min: BigNumberish;
    max: BigNumberish;
    startTime: BigNumberish;
    useAllowList: boolean;
    highest: BigNumberish;
    lowest: BigNumberish;
    duration: BigNumberish;
    interval: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleBuyerPositionCreateSaleFixedPrice({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, voucher, tokenId, currency, min, max, startTime, useAllowList, price, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    voucher: AddressLike;
    tokenId: BigNumberish;
    currency: AddressLike;
    min: BigNumberish;
    max: BigNumberish;
    startTime: BigNumberish;
    useAllowList: boolean;
    price: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleBuyerPositionReconcile({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleBuyerPositionRemoveSale({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, saleId, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    saleId: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function createSolvV2ConvertibleBuyerPosition({ comptrollerProxy, externalPositionManager, signer, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
}>;

interface SolvV2ConvertibleIssuerPositionCreateOfferParams {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
    voucher: AddressLike;
    currency: AddressLike;
    min: BigNumberish;
    max: BigNumberish;
    startTime: BigNumberish;
    endTime: BigNumberish;
    useAllowList: boolean;
    priceType: BigNumberish;
    priceData: BytesLike;
    mintParameter: {
        lowestPrice: BigNumberish;
        highestPrice: BigNumberish;
        tokenInAmount: BigNumberish;
        effectiveTime: BigNumberish;
        maturity: BigNumberish;
    };
}
declare function solvV2ConvertibleIssuerPositionCreateOffer({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, voucher, currency, min, max, startTime, endTime, useAllowList, priceType, priceData, mintParameter, }: SolvV2ConvertibleIssuerPositionCreateOfferParams): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleIssuerPositionReconcile({ comptrollerProxy, externalPositionManager, signer, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleIssuerPositionRefund({ comptrollerProxy, externalPositionManager, signer, voucher, slotId, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    voucher: AddressLike;
    slotId: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleIssuerPositionRemoveOffer({ comptrollerProxy, externalPositionManager, signer, offerId, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    offerId: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function solvV2ConvertibleIssuerPositionWithdraw({ comptrollerProxy, externalPositionManager, signer, voucher, slotId, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    voucher: AddressLike;
    slotId: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function createSolvV2ConvertibleIssuerPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>;
}>;

declare function theGraphDelegationPositionDelegate({ comptrollerProxy, externalPositionManager, signer, indexer, tokens, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    indexer: AddressLike;
    tokens: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function theGraphDelegationPositionUndelegate({ comptrollerProxy, externalPositionManager, signer, indexer, shares, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    indexer: AddressLike;
    shares: BigNumberish;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function theGraphDelegationPositionWithdraw({ comptrollerProxy, externalPositionManager, signer, indexer, nextIndexer, externalPositionProxy, }: {
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    signer: SignerWithAddress;
    indexer: AddressLike;
    nextIndexer: AddressLike;
    externalPositionProxy: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function createTheGraphDelegationPosition({ signer, comptrollerProxy, externalPositionManager, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
}): Promise<{
    externalPositionProxy: _enzymefinance_protocol.IExternalPositionProxy;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>;
}>;

declare enum UniswapV3FeeAmount {
    LOW = 500,
    MEDIUM = 3000,
    HIGH = 10000
}
declare const uniswapV3LiquidityPositionGetMinTick: (tickSpacing: number) => number;
declare const uniswapV3LiquidityPositionGetMaxTick: (tickSpacing: number) => number;
interface IUniswapV3NonFungibleTokenManager extends Contract<IUniswapV3NonFungibleTokenManager> {
    positions: Call<(tokenId: BigNumberish) => {
        nonce: BigNumber;
        operator: string;
        token0: string;
        token1: string;
        fee: BigNumber;
        tickLower: BigNumber;
        tickUpper: BigNumber;
        liquidity: BigNumber;
        feeGrowthInside0LastX128: BigNumber;
        feeGrowthInside1LastX128: BigNumber;
        tokensOwed0: BigNumber;
        tokensOwed1: BigNumber;
    }>;
}
declare const IUniswapV3NonFungibleTokenManager: _enzymefinance_ethers.ContractFactory<IUniswapV3NonFungibleTokenManager, never>;
declare function createUniswapV3LiquidityPosition({ signer, comptrollerProxy, externalPositionManager, callOnExternalPositionData, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    callOnExternalPositionData?: BytesLike;
}): Promise<{
    externalPositionProxyAddress: string;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>;
}>;
declare function uniswapV3LiquidityPositionAddLiquidity({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, nftId, amount0Desired, amount1Desired, amount0Min, amount1Min, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    nftId: BigNumberish;
    amount0Desired: BigNumberish;
    amount1Desired: BigNumberish;
    amount0Min?: BigNumberish;
    amount1Min?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function uniswapV3LiquidityPositionCollect({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, nftId, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    nftId: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function uniswapV3LiquidityPositionMint({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, token0, token1, fee, tickLower, tickUpper, amount0Desired, amount1Desired, amount0Min, amount1Min, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    token0: AddressLike;
    token1: AddressLike;
    fee: BigNumberish;
    tickLower: BigNumberish;
    tickUpper: BigNumberish;
    amount0Desired: BigNumberish;
    amount1Desired: BigNumberish;
    amount0Min?: BigNumberish;
    amount1Min?: BigNumberish;
}): Promise<{
    nftId: any;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>;
}>;
declare function uniswapV3LiquidityPositionPurge({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, nftId, liquidity, amount0Min, amount1Min, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    nftId: BigNumberish;
    liquidity: BigNumberish;
    amount0Min?: BigNumberish;
    amount1Min?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function uniswapV3LiquidityPositionRemoveLiquidity({ signer, comptrollerProxy, externalPositionManager, externalPositionProxy, nftId, liquidity, amount0Min, amount1Min, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    externalPositionManager: ExternalPositionManager;
    externalPositionProxy: AddressLike;
    nftId: BigNumberish;
    liquidity: BigNumberish;
    amount0Min?: BigNumberish;
    amount1Min?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function uniswapV3OrderTokenPair({ tokenA, tokenB }: {
    tokenA: AddressLike;
    tokenB: AddressLike;
}): {
    token0: string;
    token1: string;
};

declare function generateFeeManagerConfigWithMockFees({ deployer }: {
    deployer: SignerWithAddress;
}): Promise<string>;
declare function generateMockFees({ deployer }: {
    deployer: SignerWithAddress;
}): Promise<{
    mockContinuousFeeSettleOnly: _enzymefinance_ethers.MockContract<IFee>;
    mockContinuousFeeWithGavAndUpdates: _enzymefinance_ethers.MockContract<IFee>;
    mockPostBuySharesFee: _enzymefinance_ethers.MockContract<IFee>;
}>;

declare function aaveLend({ comptrollerProxy, integrationManager, fundOwner, aaveAdapter, aToken, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    aaveAdapter: AaveAdapter;
    aToken: StandardToken;
    amount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function aaveRedeem({ comptrollerProxy, integrationManager, fundOwner, aaveAdapter, aToken, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    aaveAdapter: AaveAdapter;
    aToken: StandardToken;
    amount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

interface ICompoundComptroller extends Contract<ICompoundComptroller> {
    claimComp: Send<(_account: AddressLike) => void>;
}
declare const ICompoundComptroller: _enzymefinance_ethers.ContractFactory<ICompoundComptroller, never>;
declare function assertCompoundLend({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, compoundAdapter, tokenAmount, cToken, compoundPriceFeed, provider, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    compoundAdapter: CompoundAdapter;
    tokenAmount?: BigNumber;
    cToken: ICERC20;
    compoundPriceFeed: CompoundPriceFeed;
    provider: EthereumTestnetProvider;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function assertCompoundRedeem({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, compoundAdapter, cToken, compoundPriceFeed, provider, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    compoundAdapter: CompoundAdapter;
    cToken: ICERC20;
    compoundPriceFeed: CompoundPriceFeed;
    provider: EthereumTestnetProvider;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function compoundClaim({ comptrollerProxy, integrationManager, fundOwner, compoundAdapter, compoundComptroller, cTokens, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    compoundAdapter: CompoundAdapter;
    compoundComptroller: AddressLike;
    cTokens: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function compoundLend({ comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, tokenAmount, cTokenAmount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    compoundAdapter: CompoundAdapter;
    cToken: AddressLike;
    tokenAmount?: BigNumberish;
    cTokenAmount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function compoundRedeem({ comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, tokenAmount, cTokenAmount, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    compoundAdapter: CompoundAdapter;
    cToken: AddressLike;
    tokenAmount?: BigNumberish;
    cTokenAmount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

interface CurveLiquidityGaugeV2 extends Contract<CurveLiquidityGaugeV2> {
    claim_rewards: Send<(_addr: AddressLike) => void>;
    integrate_fraction: Call<(_for: AddressLike) => BigNumber>;
}
declare const CurveLiquidityGaugeV2: _enzymefinance_ethers.ContractFactory<CurveLiquidityGaugeV2, never>;
interface CurveRegistry extends Contract<CurveRegistry> {
    get_coins: Call<(_pool: AddressLike) => AddressLike[]>;
    get_lp_token: Call<(_pool: AddressLike) => AddressLike>;
}
declare const CurveRegistry: _enzymefinance_ethers.ContractFactory<CurveRegistry, never>;
interface CurveSwaps extends Contract<CurveSwaps> {
    get_best_rate: Call<(_from: AddressLike, to: AddressLike, amount: BigNumberish) => {
        bestPool: AddressLike;
        amountReceived: BigNumber;
    }, CurveSwaps>;
}
declare const CurveSwaps: _enzymefinance_ethers.ContractFactory<CurveSwaps, never>;
interface CurveMinter extends Contract<CurveMinter> {
    mint_for: Send<(_gauge_address: AddressLike, _for: AddressLike) => void>;
}
declare const CurveMinter: _enzymefinance_ethers.ContractFactory<CurveMinter, never>;
declare function curveTakeOrder({ comptrollerProxy, integrationManager, fundOwner, curveExchangeAdapter, pool, outgoingAsset, outgoingAssetAmount, incomingAsset, minIncomingAssetAmount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    curveExchangeAdapter: CurveExchangeAdapter;
    pool: AddressLike;
    outgoingAsset: StandardToken;
    outgoingAssetAmount?: BigNumberish;
    incomingAsset: StandardToken;
    minIncomingAssetAmount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function curveClaimRewards({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAdapter, stakingToken, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    curveLiquidityAdapter: CurveLiquidityAdapter;
    stakingToken: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function curveLend({ comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, orderedOutgoingAssetAmounts, minIncomingLpTokenAmount, useUnderlyings, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    curveLiquidityAdapter: CurveLiquidityAdapter;
    pool: AddressLike;
    orderedOutgoingAssetAmounts: BigNumberish[];
    minIncomingLpTokenAmount?: BigNumberish;
    useUnderlyings: boolean;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function curveLendAndStake({ comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, orderedOutgoingAssetAmounts, incomingStakingToken, minIncomingStakingTokenAmount, useUnderlyings, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    curveLiquidityAdapter: CurveLiquidityAdapter;
    pool: AddressLike;
    orderedOutgoingAssetAmounts: BigNumberish[];
    incomingStakingToken: AddressLike;
    minIncomingStakingTokenAmount?: BigNumberish;
    useUnderlyings: boolean;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function curveRedeem({ comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingLpTokenAmount, useUnderlyings, redeemType, incomingAssetData, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    curveLiquidityAdapter: CurveLiquidityAdapter;
    pool: AddressLike;
    outgoingLpTokenAmount: BigNumberish;
    useUnderlyings: boolean;
    redeemType: CurveRedeemType;
    incomingAssetData: BytesLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function curveStake({ comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, incomingStakingToken, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    curveLiquidityAdapter: CurveLiquidityAdapter;
    pool: AddressLike;
    incomingStakingToken: AddressLike;
    amount: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function curveUnstake({ comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingStakingToken, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    curveLiquidityAdapter: CurveLiquidityAdapter;
    pool: AddressLike;
    outgoingStakingToken: AddressLike;
    amount: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function curveUnstakeAndRedeem({ comptrollerProxy, integrationManager, signer, curveLiquidityAdapter, pool, outgoingStakingToken, outgoingStakingTokenAmount, useUnderlyings, redeemType, incomingAssetData, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    curveLiquidityAdapter: CurveLiquidityAdapter;
    pool: AddressLike;
    outgoingStakingToken: StandardToken;
    outgoingStakingTokenAmount: BigNumberish;
    useUnderlyings: boolean;
    redeemType: CurveRedeemType;
    incomingAssetData: BytesLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;

declare function idleClaimRewards({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    idleAdapter: IdleAdapter;
    idleToken: StandardToken;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function idleLend({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, outgoingUnderlyingAmount, minIncomingIdleTokenAmount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    idleAdapter: IdleAdapter;
    idleToken: StandardToken;
    outgoingUnderlyingAmount: BigNumberish;
    minIncomingIdleTokenAmount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function idleRedeem({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, outgoingIdleTokenAmount, minIncomingUnderlyingAmount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    idleAdapter: IdleAdapter;
    idleToken: StandardToken;
    outgoingIdleTokenAmount: BigNumberish;
    minIncomingUnderlyingAmount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare const mockGenericRemoveOnlySelector: string;
declare const mockGenericSwapASelector: string;
declare const mockGenericSwapBSelector: string;
declare const mockGenericSwapDirectFromVaultSelector: string;
declare const mockGenericSwapViaApprovalSelector: string;
declare function mockGenericSwapArgs({ spendAssets, actualSpendAssetAmounts, maxSpendAssetAmounts, incomingAssets, actualIncomingAssetAmounts, minIncomingAssetAmounts, }: {
    spendAssets?: AddressLike[];
    maxSpendAssetAmounts?: BigNumberish[];
    actualSpendAssetAmounts?: BigNumberish[];
    incomingAssets?: AddressLike[];
    minIncomingAssetAmounts?: BigNumberish[];
    actualIncomingAssetAmounts?: BigNumberish[];
}): string;
declare function mockGenericSwap({ comptrollerProxy, vaultProxy, integrationManager, signer, mockGenericAdapter, selector, spendAssets, actualSpendAssetAmounts, maxSpendAssetAmounts, incomingAssets, actualIncomingAssetAmounts, minIncomingAssetAmounts, seedFund, provider, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    mockGenericAdapter: MockGenericAdapter;
    provider: EthereumTestnetProvider;
    selector?: BytesLike;
    spendAssets?: StandardToken[];
    maxSpendAssetAmounts?: BigNumberish[];
    actualSpendAssetAmounts?: BigNumberish[];
    incomingAssets?: StandardToken[];
    minIncomingAssetAmounts?: BigNumberish[];
    actualIncomingAssetAmounts?: BigNumberish[];
    seedFund?: boolean;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;

declare function olympusV2Stake({ comptrollerProxy, integrationManager, signer, olympusV2Adapter, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    olympusV2Adapter: OlympusV2Adapter;
    amount: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function olympusV2Unstake({ comptrollerProxy, integrationManager, signer, olympusV2Adapter, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: SignerWithAddress;
    olympusV2Adapter: OlympusV2Adapter;
    amount: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function paraSwapV5GenerateDummyPaths({ toTokens }: {
    toTokens: AddressLike[];
}): {
    adapters: never[];
    to: AddressLike;
    totalNetworkFee: number;
}[];
declare function paraSwapV5TakeOrder({ comptrollerProxy, integrationManager, fundOwner, paraSwapV5Adapter, outgoingAsset, outgoingAssetAmount, minIncomingAssetAmount, expectedIncomingAssetAmount, uuid, paths, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    paraSwapV5Adapter: ParaSwapV5Adapter;
    outgoingAsset: StandardToken;
    outgoingAssetAmount: BigNumberish;
    minIncomingAssetAmount?: BigNumberish;
    expectedIncomingAssetAmount?: BigNumberish;
    uuid?: BytesLike;
    paths: ParaSwapV5Path[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;

declare function poolTogetherV4Lend({ comptrollerProxy, integrationManager, fundOwner, poolTogetherV4Adapter, ptToken, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    poolTogetherV4Adapter: PoolTogetherV4Adapter;
    ptToken: StandardToken;
    amount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function poolTogetherV4Redeem({ comptrollerProxy, integrationManager, fundOwner, poolTogetherV4Adapter, ptToken, amount, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    poolTogetherV4Adapter: PoolTogetherV4Adapter;
    ptToken: StandardToken;
    amount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;
declare function poolTogetherV4ClaimRewards({ comptrollerProxy, integrationManager, fundOwner, poolTogetherV4Adapter, prizeDistributor, drawIds, winningPicks, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    poolTogetherV4Adapter: PoolTogetherV4Adapter;
    prizeDistributor: AddressLike;
    drawIds: BigNumberish[];
    winningPicks: BytesLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;

declare function synthetixAssignExchangeDelegate({ comptrollerProxy, synthetixDelegateApprovals, fundOwner, delegate, }: {
    comptrollerProxy: ComptrollerLib;
    synthetixDelegateApprovals: AddressLike;
    fundOwner: Signer;
    delegate: AddressLike;
}): Promise<void>;
declare function synthetixRedeem({ comptrollerProxy, integrationManager, signer, synthetixAdapter, synths, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    signer: Signer;
    synthetixAdapter: SynthetixAdapter;
    synths: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
declare function synthetixTakeOrder({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, synthetixAdapter, outgoingAsset, outgoingAssetAmount, minIncomingSusdAmount, provider, seedFund, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    fundOwner: Signer;
    provider: EthereumTestnetProvider;
    synthetixAdapter: SynthetixAdapter;
    outgoingAsset: StandardToken;
    outgoingAssetAmount?: BigNumberish;
    minIncomingSusdAmount?: BigNumberish;
    seedFund?: boolean;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

declare function addTrackedAssetsToVault({ signer, comptrollerProxy, integrationManager, assets, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    assets: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: ethers.BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function removeTrackedAssetsFromVault({ signer, comptrollerProxy, integrationManager, assets, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    assets: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: ethers.BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

interface UniswapV2Factory extends Contract<UniswapV2Factory> {
    createPair: Send<(_token0: AddressLike, _token1: AddressLike) => AddressLike>;
    getPair: Call<(_token0: AddressLike, _token1: AddressLike) => AddressLike>;
}
declare const UniswapV2Factory: _enzymefinance_ethers.ContractFactory<UniswapV2Factory, never>;
declare function uniswapV2Lend({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, uniswapV2LiquidityAdapter, tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin, minPoolTokenAmount, provider, seedFund, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    uniswapV2LiquidityAdapter: UniswapV2LiquidityAdapter;
    tokenA: StandardToken;
    tokenB: StandardToken;
    amountADesired: BigNumberish;
    amountBDesired: BigNumberish;
    amountAMin: BigNumberish;
    amountBMin: BigNumberish;
    minPoolTokenAmount: BigNumberish;
    provider: EthereumTestnetProvider;
    seedFund?: boolean;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function uniswapV2Redeem({ comptrollerProxy, integrationManager, fundOwner, uniswapV2LiquidityAdapter, poolTokenAmount, tokenA, tokenB, amountAMin, amountBMin, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    uniswapV2LiquidityAdapter: UniswapV2LiquidityAdapter;
    poolTokenAmount: BigNumberish;
    tokenA: AddressLike;
    tokenB: AddressLike;
    amountAMin: BigNumberish;
    amountBMin: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function uniswapV2TakeOrder({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, uniswapV2ExchangeAdapter, path, outgoingAssetAmount, minIncomingAssetAmount, seedFund, provider, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    uniswapV2ExchangeAdapter: UniswapV2ExchangeAdapter;
    path: StandardToken[];
    outgoingAssetAmount: BigNumberish;
    minIncomingAssetAmount: BigNumberish;
    seedFund?: boolean;
    provider: EthereumTestnetProvider;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function uniswapV3TakeOrder({ comptrollerProxy, integrationManager, fundOwner, uniswapV3Adapter, pathAddresses, pathFees, outgoingAssetAmount, provider, minIncomingAssetAmount, seedFund, }: {
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    uniswapV3Adapter: AddressLike;
    pathAddresses: StandardToken[];
    pathFees: BigNumber[];
    outgoingAssetAmount: BigNumberish;
    provider: EthereumTestnetProvider;
    minIncomingAssetAmount?: BigNumberish;
    seedFund?: boolean;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function yearnVaultV2Lend({ signer, comptrollerProxy, integrationManager, yearnVaultV2Adapter, yVault, outgoingUnderlyingAmount, minIncomingYVaultSharesAmount, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    yearnVaultV2Adapter: YearnVaultV2Adapter;
    yVault: StandardToken;
    outgoingUnderlyingAmount: BigNumberish;
    minIncomingYVaultSharesAmount?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;
declare function yearnVaultV2Redeem({ signer, comptrollerProxy, integrationManager, yearnVaultV2Adapter, yVault, maxOutgoingYVaultSharesAmount, minIncomingUnderlyingAmount, slippageToleranceBps, }: {
    signer: SignerWithAddress;
    comptrollerProxy: ComptrollerLib;
    integrationManager: IntegrationManager;
    yearnVaultV2Adapter: YearnVaultV2Adapter;
    yVault: StandardToken;
    maxOutgoingYVaultSharesAmount: BigNumberish;
    minIncomingUnderlyingAmount?: BigNumberish;
    slippageToleranceBps?: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function zeroExV2TakeOrder({ comptrollerProxy, integrationManager, fundOwner, zeroExV2Adapter, signedOrder, takerAssetFillAmount, }: {
    comptrollerProxy: ComptrollerLib;
    vaultProxy: VaultLib;
    integrationManager: IntegrationManager;
    fundOwner: SignerWithAddress;
    zeroExV2Adapter: ZeroExV2Adapter;
    signedOrder: SignedZeroExV2Order;
    takerAssetFillAmount: BigNumberish;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_extension: _enzymefinance_ethers.AddressLike, _actionId: BigNumberish, _callArgs: ethers.BytesLike], void, ComptrollerLib>>>;

declare function generatePolicyManagerConfigWithMockPolicies({ deployer }: {
    deployer: Signer;
}): Promise<string>;
declare function generateMockPolicies({ deployer }: {
    deployer: Signer;
}): Promise<{
    mockAddTrackedAssetsPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
    mockCreateExternalPositionPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
    mockPostBuySharesPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
    mockPostCallOnExternalPositionPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
    mockPostCoIPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
    mockPreTransferSharesPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
    mockRedeemSharesForSpecificAssetsPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
    mockRemoveExternalPositionPolicy: _enzymefinance_ethers.MockContract<IPolicy>;
}>;

interface IConvexBaseRewardPool extends Contract<IConvexBaseRewardPool> {
    stakeFor: Send<(forUser: AddressLike, amount: BigNumberish) => boolean>;
}
declare const IConvexBaseRewardPool: _enzymefinance_ethers.ContractFactory<IConvexBaseRewardPool, never>;
interface IConvexCrvDepositor extends Contract<IConvexCrvDepositor> {
    deposit: Send<(amount: BigNumberish, lock: boolean) => void>;
}
declare const IConvexCrvDepositor: _enzymefinance_ethers.ContractFactory<IConvexCrvDepositor, never>;
interface IConvexCvxLocker extends Contract<IConvexCvxLocker> {
    balanceOf: Call<(account: AddressLike) => BigNumber>;
    checkpointEpoch: Send<() => void>;
    getReward: Send<(account: AddressLike, stake: boolean) => void>;
    lockedBalanceOf: Call<(account: AddressLike) => BigNumber>;
}
declare const IConvexCvxLocker: _enzymefinance_ethers.ContractFactory<IConvexCvxLocker, never>;
interface IConvexVlCvxExtraRewardDistribution extends Contract<IConvexVlCvxExtraRewardDistribution> {
    addReward: Send<(token: AddressLike, amount: BigNumberish) => void>;
    claimableRewards: Call<(account: AddressLike, token: AddressLike) => BigNumber>;
}
declare const IConvexVlCvxExtraRewardDistribution: _enzymefinance_ethers.ContractFactory<IConvexVlCvxExtraRewardDistribution, never>;
interface ISnapshotDelegateRegistry extends Contract<ISnapshotDelegateRegistry> {
    delegation: Call<(account: AddressLike, id: BytesLike) => AddressLike>;
}
declare const ISnapshotDelegateRegistry: _enzymefinance_ethers.ContractFactory<ISnapshotDelegateRegistry, never>;
interface IVotiumMultiMerkleStash extends Contract<IVotiumMultiMerkleStash> {
    owner: Call<() => AddressLike>;
    updateMerkleRoot: Send<(token: AddressLike, merkleRoot: BytesLike) => void>;
}
declare const IVotiumMultiMerkleStash: _enzymefinance_ethers.ContractFactory<IVotiumMultiMerkleStash, never>;

declare enum ArbitraryTokenPhasedSharesWrapperState {
    Deposit = "0",
    Locked = "1",
    Redeem = "2"
}
declare function deployArbitraryTokenPhasedSharesWrapper({ signer, sharesWrapperFactory, vaultProxy, depositToken, allowedDepositorListId, transfersAllowed, totalDepositMax, feeRecipient, feeBps, feeExcludesDepositTokenPrincipal, manager, }: {
    signer: SignerWithAddress;
    sharesWrapperFactory: ArbitraryTokenPhasedSharesWrapperFactory;
    vaultProxy: AddressLike;
    depositToken: AddressLike;
    allowedDepositorListId: BigNumberish;
    transfersAllowed: boolean;
    totalDepositMax: BigNumberish;
    feeRecipient: AddressLike;
    feeBps: BigNumberish;
    feeExcludesDepositTokenPrincipal: boolean;
    manager: AddressLike;
}): Promise<{
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_vaultProxy: AddressLike, _depositToken: AddressLike, _allowedDepositorListId: BigNumberish, _transfersAllowed: boolean, _totalDepositMax: BigNumberish, _feeRecipient: AddressLike, _feeBps: BigNumberish, _feeExcludesDepositTokenPrincipal: boolean, _manager: AddressLike], string, ArbitraryTokenPhasedSharesWrapperFactory>>;
    sharesWrapper: ArbitraryTokenPhasedSharesWrapperLib;
}>;

declare function deployManualValueOracle({ signer, manualValueOracleFactory, owner, updater, description, }: {
    signer: SignerWithAddress;
    manualValueOracleFactory: ManualValueOracleFactory;
    owner: AddressLike;
    updater: AddressLike;
    description?: string;
}): Promise<{
    proxy: ManualValueOracleLib;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_owner: AddressLike, _updater: AddressLike, _description: string], string, ManualValueOracleFactory>>;
}>;

declare function deploySharesSplitter({ signer, sharesSplitterFactory, splitUsers, splitPercentages, }: {
    signer: SignerWithAddress;
    sharesSplitterFactory: SharesSplitterFactory;
    splitUsers: AddressLike[];
    splitPercentages: BigNumberish[];
}): Promise<{
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_users: AddressLike[], _splitPercentages: BigNumberish[]], string, SharesSplitterFactory>>;
    sharesSplitterProxy: SharesSplitterLib;
}>;

interface BuySharesParams {
    comptrollerProxy: ComptrollerLib;
    denominationAsset: StandardToken;
    buyer: SignerWithAddress;
    investmentAmount?: BigNumberish;
    minSharesQuantity?: BigNumberish;
    seedBuyer?: boolean;
    provider: EthereumTestnetProvider;
}
interface RedeemSharesForSpecificAssetsParams {
    comptrollerProxy: ComptrollerLib;
    signer: SignerWithAddress;
    recipient?: AddressLike;
    quantity?: BigNumberish;
    payoutAssets: AddressLike[];
    payoutAssetPercentages: BigNumberish[];
}
interface RedeemSharesInKindParams {
    comptrollerProxy: ComptrollerLib;
    signer: SignerWithAddress;
    recipient?: AddressLike;
    quantity?: BigNumberish;
    additionalAssets?: AddressLike[];
    assetsToSkip?: AddressLike[];
}
declare function buyShares(options: BuySharesParams): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_investmentAmount: BigNumberish, _minSharesQuantity: BigNumberish], ethers.BigNumber, ComptrollerLib>>>;
declare function buySharesFunction({ comptrollerProxy, denominationAsset, buyer, investmentAmount, minSharesQuantity, seedBuyer, provider, }: BuySharesParams): Promise<_enzymefinance_ethers.Send<(_investmentAmount: BigNumberish, _minSharesQuantity: BigNumberish) => ethers.BigNumber, ComptrollerLib>>;
declare function redeemSharesForSpecificAssets({ comptrollerProxy, signer, recipient, quantity, payoutAssets, payoutAssetPercentages, }: RedeemSharesForSpecificAssetsParams): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_recipient: AddressLike, _sharesQuantity: BigNumberish, _payoutAssets: AddressLike[], _payoutAssetPercentages: BigNumberish[]], ethers.BigNumber[], ComptrollerLib>>>;
declare function redeemSharesInKind({ comptrollerProxy, signer, recipient, quantity, additionalAssets, assetsToSkip, }: RedeemSharesInKindParams): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_recipient: AddressLike, _sharesQuantity: BigNumberish, _additionalAssets: AddressLike[], _assetsToSkip: AddressLike[]], {
    payoutAssets_: string[];
    payoutAmounts_: ethers.BigNumber[];
}, ComptrollerLib>>>;

declare type InitialInvestmentParams = Omit<BuySharesParams, 'comptrollerProxy' | 'denominationAsset'>;
interface CreateMigrationRequestParams {
    signer: SignerWithAddress;
    fundDeployer: FundDeployer;
    vaultProxy: AddressLike;
    denominationAsset: AddressLike;
    sharesActionTimelock?: BigNumberish;
    feeManagerConfigData?: BytesLike;
    policyManagerConfigData?: BytesLike;
    bypassPrevReleaseFailure?: boolean;
}
interface CreateNewFundParams {
    signer: SignerWithAddress;
    fundDeployer: FundDeployer;
    denominationAsset: StandardToken;
    sharesActionTimelock?: BigNumberish;
    fundOwner?: AddressLike;
    fundName?: string;
    fundSymbol?: string;
    feeManagerConfig?: BytesLike;
    policyManagerConfig?: BytesLike;
    investment?: InitialInvestmentParams;
}
interface CreateReconfigurationRequestParams {
    signer: SignerWithAddress;
    fundDeployer: FundDeployer;
    vaultProxy: AddressLike;
    denominationAsset: AddressLike;
    sharesActionTimelock?: BigNumberish;
    feeManagerConfigData?: BytesLike;
    policyManagerConfigData?: BytesLike;
}
declare function createComptrollerProxy({ signer, comptrollerLib, denominationAsset, sharesActionTimelock, }: {
    signer: SignerWithAddress;
    comptrollerLib: ComptrollerLib;
    denominationAsset: AddressLike;
    sharesActionTimelock?: BigNumberish;
}): Promise<{
    comptrollerProxy: ComptrollerLib;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.ConstructorFunction<any, ComptrollerProxy>>;
}>;
declare function createMigrationRequest({ signer, fundDeployer, vaultProxy, denominationAsset, sharesActionTimelock, feeManagerConfigData, policyManagerConfigData, bypassPrevReleaseFailure, }: CreateMigrationRequestParams): Promise<{
    comptrollerProxy: ComptrollerLib;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_vaultProxy: AddressLike, _denominationAsset: AddressLike, _sharesActionTimelock: BigNumberish, _feeManagerConfigData: BytesLike, _policyManagerConfigData: BytesLike, _bypassPrevReleaseFailure: boolean], string, FundDeployer>>;
}>;
declare function createNewFund({ signer, fundDeployer, denominationAsset, sharesActionTimelock, fundOwner, fundName, fundSymbol, feeManagerConfig, policyManagerConfig, investment, }: CreateNewFundParams): Promise<{
    comptrollerProxy: ComptrollerLib;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_fundOwner: AddressLike, _fundName: string, _fundSymbol: string, _denominationAsset: AddressLike, _sharesActionTimelock: BigNumberish, _feeManagerConfigData: BytesLike, _policyManagerConfigData: BytesLike], {
        comptrollerProxy_: string;
        vaultProxy_: string;
    }, FundDeployer>>;
    vaultProxy: VaultLib;
}>;
declare function createReconfigurationRequest({ signer, fundDeployer, vaultProxy, denominationAsset, sharesActionTimelock, feeManagerConfigData, policyManagerConfigData, }: CreateReconfigurationRequestParams): Promise<{
    comptrollerProxy: ComptrollerLib;
    receipt: _enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_vaultProxy: AddressLike, _denominationAsset: AddressLike, _sharesActionTimelock: BigNumberish, _feeManagerConfigData: BytesLike, _policyManagerConfigData: BytesLike], string, FundDeployer>>;
}>;
declare function createVaultProxy({ signer, vaultLib, fundOwner, fundAccessor, fundName, }: {
    signer: SignerWithAddress;
    vaultLib: VaultLib;
    fundOwner: AddressLike;
    fundAccessor: SignerWithAddress;
    fundName?: string;
}): Promise<VaultLib>;
declare function setupGasRelayerPaymaster({ signer, vaultProxy, fundAccessor, provider, weth, startingBalance, }: {
    signer: SignerWithAddress;
    vaultProxy: AddressLike;
    fundAccessor: AddressLike;
    provider: EthereumTestnetProvider;
    weth: StandardToken;
    startingBalance?: BigNumberish;
}): Promise<GasRelayPaymasterLib>;

declare function vaultCallCreateNewList({ addressListRegistry, comptrollerProxy, items, owner, signer, updateType, }: {
    addressListRegistry: AddressListRegistry;
    comptrollerProxy: ComptrollerLib;
    items: AddressLike[];
    owner: AddressLike;
    signer: SignerWithAddress;
    updateType: AddressListUpdateType;
}): Promise<ethers.BigNumber>;
declare function vaultCallCurveMinterMint({ comptrollerProxy, minter, gauge, }: {
    comptrollerProxy: ComptrollerLib;
    minter: AddressLike;
    gauge: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_contract: AddressLike, _selector: utils.BytesLike, _encodedArgs: utils.BytesLike], string, ComptrollerLib>>>;
declare function vaultCallCurveMinterMintMany({ comptrollerProxy, minter, gauges, }: {
    comptrollerProxy: ComptrollerLib;
    minter: AddressLike;
    gauges: AddressLike[];
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_contract: AddressLike, _selector: utils.BytesLike, _encodedArgs: utils.BytesLike], string, ComptrollerLib>>>;
declare function vaultCallCurveMinterToggleApproveMint({ comptrollerProxy, minter, account, }: {
    comptrollerProxy: ComptrollerLib;
    minter: AddressLike;
    account: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_contract: AddressLike, _selector: utils.BytesLike, _encodedArgs: utils.BytesLike], string, ComptrollerLib>>>;
declare function vaultCallStartAssetBypassTimelock({ comptrollerProxy, contract, asset, }: {
    comptrollerProxy: ComptrollerLib;
    contract: AddressLike;
    asset: AddressLike;
}): Promise<_enzymefinance_ethers.ContractReceipt<_enzymefinance_ethers.SendFunction<[_contract: AddressLike, _selector: utils.BytesLike, _encodedArgs: utils.BytesLike], string, ComptrollerLib>>>;

export { ArbitraryTokenPhasedSharesWrapperState, BuySharesParams, CreateMigrationRequestParams, CreateNewFundParams, CreateReconfigurationRequestParams, CurveLiquidityGaugeV2, CurveMinter, CurveRegistry, CurveSwaps, DeploymentConfig, ICompoundComptroller, IConvexBaseRewardPool, IConvexCrvDepositor, IConvexCvxLocker, IConvexVlCvxExtraRewardDistribution, ILiquityHintHelper, ILiquitySortedTroves, ILiquityTroveManager, ISnapshotDelegateRegistry, IUniswapV3NonFungibleTokenManager, IVotiumMultiMerkleStash, InitialInvestmentParams, NotionalV2CurrencyId, NotionalV2MarketIndex, ProtocolDeployment, RedeemSharesForSpecificAssetsParams, RedeemSharesInKindParams, RelayTransactionOptions, SolvV2ConvertibleIssuerPositionCreateOfferParams, UniswapV2Factory, UniswapV3FeeAmount, aaveDebtPositionAddCollateral, aaveDebtPositionBorrow, aaveDebtPositionClaimRewards, aaveDebtPositionRemoveCollateral, aaveDebtPositionRepayBorrow, aaveLend, aaveRedeem, addNewAssetsToFund, addTrackedAssetsToVault, arbitraryLoanPositionCallOnAccountingModule, arbitraryLoanPositionCloseLoan, arbitraryLoanPositionConfigureLoan, arbitraryLoanPositionReconcile, arbitraryLoanPositionUpdateBorrowableAmount, assertCompoundLend, assertCompoundRedeem, assertDidRelay, assertDidRelaySuccessfully, assertDidRelayWithCharge, assertDidRelayWithError, assertEvent, assertNoEvent, assertPaymasterDidReject, assertPaymasterDidRejectForReason, buyShares, buySharesFunction, calcMlnValueAndBurnAmountForSharesBuyback, callOnExtension, callOnExternalPosition, compoundClaim, compoundDebtPositionAddCollateral, compoundDebtPositionBorrow, compoundDebtPositionClaimComp, compoundDebtPositionRemoveCollateral, compoundDebtPositionRepayBorrow, compoundLend, compoundRedeem, convexVotingPositionClaimRewards, convexVotingPositionDelegate, convexVotingPositionLock, convexVotingPositionRelock, convexVotingPositionWithdraw, createAaveDebtPosition, createArbitraryLoanPosition, createCompoundDebtPosition, createComptrollerProxy, createConvexVotingPosition, createExternalPosition, createFundDeployer, createLiquityDebtPosition, createMapleLiquidityPosition, createMigrationRequest, createMockExternalPosition, createNewFund, createNotionalV2Position, createReconfigurationRequest, createSolvV2ConvertibleBuyerPosition, createSolvV2ConvertibleIssuerPosition, createTheGraphDelegationPosition, createUniswapV3LiquidityPosition, createVaultProxy, curveClaimRewards, curveLend, curveLendAndStake, curveRedeem, curveStake, curveTakeOrder, curveUnstake, curveUnstakeAndRedeem, deployArbitraryTokenPhasedSharesWrapper, deployManualValueOracle, deployProtocolFixture, deploySharesSplitter, findTokenBalanceStorageSlot, generateFeeManagerConfigWithMockFees, generateMerkleTreeForContractProof, generateMockFees, generateMockPolicies, generatePolicyManagerConfigWithMockPolicies, getAssetBalances, getAssetUnit, getNamedSigner, getUnnamedSigners, idleClaimRewards, idleLend, idleRedeem, impersonateContractSigner, impersonateSigner, liquityCalcHints, liquityDebtPositionAddCollateral, liquityDebtPositionBorrow, liquityDebtPositionCloseTrove, liquityDebtPositionOpenTrove, liquityDebtPositionRemoveCollateral, liquityDebtPositionRepay, mapleLiquidityPositionClaimInterest, mapleLiquidityPositionClaimRewards, mapleLiquidityPositionIntendToRedeem, mapleLiquidityPositionLend, mapleLiquidityPositionLendAndStake, mapleLiquidityPositionRedeem, mapleLiquidityPositionStake, mapleLiquidityPositionUnstake, mapleLiquidityPositionUnstakeAndRedeem, mockExternalPositionAddDebtAssets, mockExternalPositionAddManagedAssets, mockExternalPositionRemoveDebtAssets, mockExternalPositionRemoveManagedAssets, mockGenericRemoveOnlySelector, mockGenericSwap, mockGenericSwapASelector, mockGenericSwapArgs, mockGenericSwapBSelector, mockGenericSwapDirectFromVaultSelector, mockGenericSwapViaApprovalSelector, notionalV2GetActiveMarketArraySlot, notionalV2PositionAddCollateral, notionalV2PositionBorrow, notionalV2PositionLend, notionalV2PositionRedeem, olympusV2Stake, olympusV2Unstake, paraSwapV5GenerateDummyPaths, paraSwapV5TakeOrder, poolTogetherV4ClaimRewards, poolTogetherV4Lend, poolTogetherV4Redeem, reactivateExternalPosition, redeemSharesForSpecificAssets, redeemSharesInKind, relayTransaction, removeExternalPosition, removeTrackedAssetsFromVault, seedAccount, sendEthBySelfDestruct, setupGasRelayerPaymaster, solvV2ConvertibleBuyerPositionBuyOffering, solvV2ConvertibleBuyerPositionBuySaleByAmount, solvV2ConvertibleBuyerPositionBuySaleByUnits, solvV2ConvertibleBuyerPositionClaim, solvV2ConvertibleBuyerPositionCreateSaleDecliningPrice, solvV2ConvertibleBuyerPositionCreateSaleFixedPrice, solvV2ConvertibleBuyerPositionReconcile, solvV2ConvertibleBuyerPositionRemoveSale, solvV2ConvertibleIssuerPositionCreateOffer, solvV2ConvertibleIssuerPositionReconcile, solvV2ConvertibleIssuerPositionRefund, solvV2ConvertibleIssuerPositionRemoveOffer, solvV2ConvertibleIssuerPositionWithdraw, synthetixAssignExchangeDelegate, synthetixRedeem, synthetixTakeOrder, theGraphDelegationPositionDelegate, theGraphDelegationPositionUndelegate, theGraphDelegationPositionWithdraw, transactionTimestamp, uniswapV2Lend, uniswapV2Redeem, uniswapV2TakeOrder, uniswapV3LiquidityPositionAddLiquidity, uniswapV3LiquidityPositionCollect, uniswapV3LiquidityPositionGetMaxTick, uniswapV3LiquidityPositionGetMinTick, uniswapV3LiquidityPositionMint, uniswapV3LiquidityPositionPurge, uniswapV3LiquidityPositionRemoveLiquidity, uniswapV3OrderTokenPair, uniswapV3TakeOrder, updateChainlinkAggregator, vaultCallCreateNewList, vaultCallCurveMinterMint, vaultCallCurveMinterMintMany, vaultCallCurveMinterToggleApproveMint, vaultCallStartAssetBypassTimelock, yearnVaultV2Lend, yearnVaultV2Redeem, zeroExV2TakeOrder };