/**
 * Portfolio Optimization Utility
 *
 * Portfolio allocation and rebalancing algorithms for optimal vault distribution.
 * Provides risk-adjusted portfolio recommendations and rebalancing guidance.
 */
import { RiskScoreBreakdown } from './risk-scoring.js';
/**
 * Portfolio position with current and target allocations
 */
export interface PortfolioPosition {
    vaultAddress: string;
    vaultName: string;
    chainId: number;
    currentAllocation: number;
    targetAllocation: number;
    currentValueUsd: number;
    targetValueUsd: number;
    rebalanceAmount: number;
    rebalancePercentage: number;
    vault: VaultForOptimization;
}
/**
 * Portfolio optimization result
 */
export interface PortfolioOptimization {
    strategy: 'equal_weight' | 'risk_parity' | 'max_sharpe' | 'min_variance';
    totalValueUsd: number;
    positions: PortfolioPosition[];
    metrics: {
        expectedReturn: number;
        portfolioRisk: number;
        sharpeRatio: number;
        diversificationScore: number;
    };
    rebalanceNeeded: boolean;
    rebalanceThreshold: number;
    recommendations: string[];
}
/**
 * Vault data for portfolio optimization
 */
export interface VaultForOptimization {
    address: string;
    name: string;
    chainId: number;
    currentValueUsd: number;
    expectedApr: number;
    volatility: number;
    riskScore: number;
    riskBreakdown?: RiskScoreBreakdown;
}
/**
 * Calculate equal-weight allocation strategy
 * Allocates portfolio equally across all vaults
 */
export declare function calculateEqualWeight(vaults: VaultForOptimization[], totalValueUsd: number): PortfolioPosition[];
/**
 * Calculate risk-parity allocation strategy
 * Allocates based on inverse volatility (lower volatility = higher allocation)
 * Uses market risk (volatility) rather than composite risk score for proper
 * risk parity — the goal is to equalize each asset's risk contribution to the portfolio.
 */
export declare function calculateRiskParity(vaults: VaultForOptimization[], totalValueUsd: number): PortfolioPosition[];
/**
 * Calculate maximum Sharpe ratio allocation strategy
 * Allocates to maximize risk-adjusted returns
 */
export declare function calculateMaxSharpe(vaults: VaultForOptimization[], totalValueUsd: number, riskFreeRate?: number): PortfolioPosition[];
/**
 * Calculate minimum variance allocation strategy
 * Allocates to minimize portfolio volatility
 */
export declare function calculateMinVariance(vaults: VaultForOptimization[], totalValueUsd: number): PortfolioPosition[];
/**
 * Calculate portfolio metrics
 */
export declare function calculatePortfolioMetrics(positions: PortfolioPosition[], vaults: VaultForOptimization[], riskFreeRate?: number): {
    expectedReturn: number;
    portfolioRisk: number;
    sharpeRatio: number;
    diversificationScore: number;
};
/**
 * Check if rebalancing is needed
 */
export declare function needsRebalancing(positions: PortfolioPosition[], threshold?: number): boolean;
/**
 * Generate optimization recommendations
 */
export declare function generateRecommendations(positions: PortfolioPosition[], metrics: PortfolioOptimization['metrics'], strategy: PortfolioOptimization['strategy']): string[];
/**
 * Optimize portfolio based on strategy
 *
 * @param vaults - Vaults with current positions and metrics
 * @param strategy - Optimization strategy to use
 * @param rebalanceThreshold - Minimum drift percentage to trigger rebalancing (default: 5%)
 * @param riskFreeRate - Risk-free rate for Sharpe ratio calculation (default: 2%)
 * @returns Portfolio optimization result with positions and recommendations
 */
export declare function optimizePortfolio(vaults: VaultForOptimization[], strategy?: 'equal_weight' | 'risk_parity' | 'max_sharpe' | 'min_variance', rebalanceThreshold?: number, riskFreeRate?: number): PortfolioOptimization;
//# sourceMappingURL=portfolio-optimization.d.ts.map