/**
 * monte-carlo.ts — Monte Carlo path generation for portfolio simulation.
 * Implements Geometric Brownian Motion (GBM) and Merton Jump-Diffusion models.
 * Uses a seedable PRNG (Mulberry32) for reproducible simulations.
 * Pure functions, zero external dependencies.
 */
/** Parameters for Geometric Brownian Motion path generation */
export interface GBMParams {
    /** Annualized drift (expected return). If not provided, estimated from returnSeries. */
    mu?: number;
    /** Annualized volatility. If not provided, estimated from returnSeries. */
    sigma?: number;
    /** Historical return series used to estimate mu and sigma if not directly provided */
    returnSeries?: number[];
    /** Number of simulation paths to generate */
    numPaths: number;
    /** Simulation horizon in trading days */
    horizonDays: number;
    /** Initial portfolio or asset value */
    initialValue: number;
    /** Trading days per year for annualization. Default 252. */
    tradingDaysPerYear?: number;
    /** Optional seed for reproducibility. If null/undefined, uses Math.random. */
    seed?: number | null;
}
/** Parameters for Merton Jump-Diffusion path generation */
export interface JumpDiffusionParams extends GBMParams {
    /** Average number of jumps per year (Poisson intensity lambda). Default 1.0. */
    jumpIntensity?: number;
    /** Mean of the jump size (log-normal). Default -0.05 (5% drop). */
    jumpMean?: number;
    /** Standard deviation of the jump size. Default 0.10. */
    jumpStdDev?: number;
}
/** Result of a Monte Carlo simulation */
export interface MonteCarloResult {
    /** Array of terminal (end-of-horizon) values, one per path */
    terminalValues: number[];
    /** Number of paths actually generated */
    numPaths: number;
    /** Horizon in days */
    horizonDays: number;
    /** The drift used */
    mu: number;
    /** The volatility used */
    sigma: number;
}
/**
 * Generate terminal portfolio values using Geometric Brownian Motion (GBM).
 *
 * The GBM model: dS = mu*S*dt + sigma*S*dW
 * Discrete-time: S(t+dt) = S(t) * exp((mu - sigma^2/2)*dt + sigma*sqrt(dt)*Z)
 * where Z ~ N(0,1).
 *
 * For efficiency, since we only need terminal values (not full paths),
 * we use the closed-form: S(T) = S(0) * exp((mu - sigma^2/2)*T + sigma*sqrt(T)*Z)
 * when horizonDays == 1 step. For multi-day horizons, we step daily to capture
 * path-dependent effects if needed in the future.
 *
 * @param params - GBM simulation parameters
 * @returns MonteCarloResult with terminal values for each path
 */
export declare function generateGBMPaths(params: GBMParams): MonteCarloResult;
/**
 * Generate terminal portfolio values using Merton's Jump-Diffusion model.
 *
 * Extends GBM by adding random jumps (modeled as a compound Poisson process
 * with log-normally distributed jump sizes). This captures fat tails and
 * sudden market crashes better than pure GBM.
 *
 * dS/S = (mu - lambda*k)*dt + sigma*dW + J*dN
 * where N ~ Poisson(lambda*dt), J ~ LogNormal(jumpMean, jumpStdDev)
 * and k = E[e^J - 1] is the compensator.
 *
 * @param params - Jump-diffusion simulation parameters
 * @returns MonteCarloResult with terminal values for each path
 */
export declare function generateJumpDiffusionPaths(params: JumpDiffusionParams): MonteCarloResult;
//# sourceMappingURL=monte-carlo.d.ts.map