/**
 * optimization.ts — Mean-variance portfolio optimization (Markowitz).
 * Implements gradient-projection optimization for max_sharpe, min_variance,
 * and target_return objectives. No external solver dependencies.
 * Pure functions, zero side effects.
 */
/** Objective types for portfolio optimization */
export type OptimizationObjective = 'max_sharpe' | 'min_variance' | 'target_return';
/** Constraints for portfolio weights */
export interface OptimizationConstraints {
    /** Minimum weight per asset. Default 0.0 (long-only). */
    minWeight?: number;
    /** Maximum weight per asset. Default 1.0. */
    maxWeight?: number;
}
/** Input parameters for the optimizer */
export interface OptimizationParams {
    /** Expected return vector (annualized) for each asset. Length n. */
    expectedReturns: number[];
    /** Covariance matrix (annualized) of asset returns. n x n. */
    covarianceMatrix: number[][];
    /** Optimization objective */
    objective: OptimizationObjective;
    /** Required if objective is 'target_return'. Annualized target return. */
    targetReturn?: number;
    /** Annualized risk-free rate. Default 0.05. */
    riskFreeRate?: number;
    /** Constraints on individual weights */
    constraints?: OptimizationConstraints;
}
/** Result of portfolio optimization */
export interface OptimizationResult {
    /** Optimal weights for each asset (same order as input) */
    weights: number[];
    /** Expected portfolio return (annualized) */
    expectedReturn: number;
    /** Expected portfolio volatility (annualized) */
    expectedVolatility: number;
    /** Expected Sharpe ratio */
    sharpeRatio: number;
}
/** A point on the efficient frontier */
export interface FrontierPoint {
    /** Annualized return */
    return: number;
    /** Annualized volatility */
    volatility: number;
    /** Sharpe ratio */
    sharpe: number;
}
/**
 * Mean-variance portfolio optimization using projected gradient descent.
 *
 * Finds optimal portfolio weights that:
 * - max_sharpe: maximize (E[R] - Rf) / sigma
 * - min_variance: minimize portfolio variance w'*Sigma*w
 * - target_return: minimize variance subject to E[R] >= target
 *
 * Constraints: weights sum to 1, each weight in [minWeight, maxWeight].
 *
 * @param params - Optimization parameters including expected returns,
 *                 covariance matrix, objective, and constraints
 * @returns Optimal weights, expected return, volatility, and Sharpe ratio
 */
export declare function meanVarianceOptimize(params: OptimizationParams): OptimizationResult;
/**
 * Generate points along the efficient frontier.
 * Solves min-variance for a range of target returns from the global minimum
 * variance portfolio to the maximum attainable return.
 *
 * @param expectedReturns - Expected return vector (annualized)
 * @param covarianceMatrix - Covariance matrix (annualized)
 * @param riskFreeRate - Risk-free rate. Default 0.05.
 * @param numPoints - Number of frontier points. Default 20.
 * @param constraints - Weight constraints
 * @returns Array of FrontierPoint objects
 */
export declare function generateEfficientFrontier(expectedReturns: number[], covarianceMatrix: number[][], riskFreeRate?: number, numPoints?: number, constraints?: OptimizationConstraints): FrontierPoint[];
//# sourceMappingURL=optimization.d.ts.map