finance-calculator-pro 1.1.0 → 1.2.0

package/README.md

@@ -11,7 +11,7 @@
 ![finance-calculator-pro banner](https://raw.githubusercontent.com/boffincoders/finance-calculator/refs/heads/master/.github/assets/finance-calculator-pro.png)
 
 > **Zero-dependency financial analysis engine for JavaScript and TypeScript.**
-> Calculate 30+ fundamental analysis metrics — valuation ratios, profitability metrics, liquidity ratios, solvency indicators, efficiency metrics, earnings quality signals, and bankruptcy risk scores — from raw financial data. No API calls. No heavy dependencies. Works in Node.js, browsers, and edge runtimes.
+> Calculate 60+ financial metrics — valuation ratios, profitability, liquidity, solvency, efficiency, intrinsic value, composite scoring, technical indicators (SMA, EMA, RSI, MACD, ATR, ADX, Bollinger Bands), and bankruptcy risk scores — from raw financial data. No API calls. No runtime dependencies. Works in Node.js, browsers, and edge runtimes.
 
 ---
 
@@ -50,7 +50,7 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 
 ---
 
-## Metrics Reference — 30+ Fundamental Analysis Metrics
+## Metrics Reference — 60+ Functions Across 12 Categories
 
 ### Valuation Ratios
 | Metric | Function | Formula |
@@ -67,6 +67,7 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 | Dividend Yield | `dividendYield()` | `Annual Dividend / Price` |
 | Discounted Cash Flow (DCF) | `calculateDCF()` | Terminal value + discounted FCF streams |
 | Graham Number | `grahamNumber()` | `√(22.5 × EPS × Book Value)` |
+| Market Cap to Total Capital | `marketCapToDebtCap()` | `Market Cap / (Market Cap + Total Debt)` |
 
 ### Profitability Metrics
 | Metric | Function | Formula |
@@ -101,6 +102,9 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 | Inventory Turnover | `inventoryTurnover()` | `COGS / Average Inventory` |
 | Receivables Turnover | `receivablesTurnover()` | `Revenue / Trade Receivables` |
 | Days Sales Outstanding (DSO) | `daysSalesOutstanding()` | `365 / Receivables Turnover` |
+| Payable Days (DPO) | `payableDays()` | `(Trade Payables / COGS) × 365` |
+| Working Capital Days | `workingCapitalDays()` | `(Working Capital / Revenue) × 365` |
+| Cash Conversion Cycle | `cashConversionCycle()` | `DSO + DIO − DPO` |
 
 ### Earnings Quality Metrics
 | Metric | Function | Formula |
@@ -116,11 +120,51 @@ Building a stock screener, neo-bank, or internal financial analysis tool? [Let's
 | Sharpe Ratio | `sharpe()` | Risk-adjusted return vs risk-free rate |
 | Target Upside | `targetUpside()` | % gap to analyst target price |
 
+### Intrinsic Valuation & Scoring
+| Metric | Function | Notes |
+|---|---|---|
+| Graham Number | `grahamNumber()` | Benjamin Graham's defensive value ceiling |
+| Net Current Value Per Share | `computeNCVPS()` | (Current Assets − Total Liabilities) / Shares |
+| Intrinsic Value Estimate | `computeIntrinsicValue()` | Simple 5-yr EPS projection with margin of safety |
+| G-Factor (Composite) | `computeGFactor()` | Quality×40% + Growth×35% + Momentum×25% |
+| Quality Score | `computeQualityScore()` | Piotroski + ROE vs sector + margins + pledge + promoter |
+| Growth Score | `computeGrowthScore()` | Revenue growth + profit growth + EPS growth + CFO |
+| Value Score | `computeValueScore()` | P/E vs avg + P/B vs sector + PEG + historical percentile |
+| Momentum Score | `computeMomentumScore()` | SMA200 + RSI + ADX + volume ratio + ROC-125 |
+
 ### Growth & Timeseries Analysis
-- **YoY Growth** — Year-over-year revenue, net income, EPS growth rates
-- **QoQ Growth** — Quarter-over-quarter sequential growth
-- **CAGR** — Compound Annual Growth Rate over any period
-- **Fundamental Trends** — Multi-period margin trends, FCF conversion tracking
+| Function | Description |
+|---|---|
+| `calculateGrowthRate()` | Single-period % growth rate |
+| `yoyGrowth()` | Year-over-year growth rates for a series |
+| `qoqGrowth()` | Quarter-over-quarter growth rates |
+| `cagr()` | Compound Annual Growth Rate |
+| `medianGrowth()` | Median YoY growth rate (outlier-resistant) |
+
+### TTM & Historical Aggregation
+| Function | Description |
+|---|---|
+| `computeTTM()` | Trailing Twelve Months sum (last 4 quarters) |
+| `computeTTMAvg()` | Trailing Twelve Months average |
+| `computeNYearAverage()` | Rolling N-year average of quarterly data |
+| `computeNYearSum()` | Rolling N-year sum of quarterly data |
+| `computeHistoricalPoint()` | Value at exactly N quarters back |
+
+### Technical Indicators *(native — zero dependencies)*
+| Function | Description |
+|---|---|
+| `sma(prices, period)` | Simple Moving Average |
+| `ema(prices, period)` | Exponential Moving Average |
+| `rsi(prices, period?)` | Relative Strength Index (default 14) |
+| `roc(prices, period?)` | Rate of Change (default 14) |
+| `macd(prices, fast?, slow?, signal?)` | MACD line, signal line, histogram |
+| `atr(highs, lows, closes, period?)` | Average True Range (default 14) |
+| `bollingerBands(prices, period?, mult?)` | Upper, Middle, Lower bands + Bandwidth |
+| `adx(highs, lows, closes, period?)` | ADX + +DI + −DI (default 14) |
+| `mfi(highs, lows, closes, volumes, period?)` | Money Flow Index (default 14) |
+| `vwap(highs, lows, closes, volumes)` | Volume-Weighted Average Price |
+| `beta(stockReturns, benchmarkReturns)` | Beta vs benchmark |
+| `pivotPoints(high, low, close)` | Classic Pivot Points (P, R1–R3, S1–S3) |
 
 ---
 

package/dist/index.d.mts

@@ -711,6 +711,18 @@ declare const evRevenue: (enterpriseValue: number, totalRevenue: number) => numb
  */
 declare const evFcf: (enterpriseValue: number, freeCashFlow: number) => number | null;
 
+/**
+ * Market Cap to Total Capitalization Ratio (Market Cap / (Market Cap + Debt))
+ * Also known as the equity-to-total-capital ratio.
+ * Formula: Market Cap / (Market Cap + Total Debt)
+ * Interpretation:
+ * - Ranges from 0 to 1.
+ * - Higher ratio → company is predominantly equity-financed (lower financial risk).
+ * - Lower ratio → company is more debt-heavy relative to its total capital.
+ * - Useful for comparing capital structure across companies.
+ */
+declare const marketCapToDebtCap: (marketCap: number, totalDebt: number) => number | null;
+
 /**
  * Return on Equity (ROE)
  * Formula: Net Income / Equity
@@ -870,6 +882,38 @@ declare const receivablesTurnover: (totalRevenue: number, tradeReceivables: numb
  */
 declare const daysSalesOutstanding: (totalRevenue: number, tradeReceivables: number) => number | null;
 
+/**
+ * Payable Days (Days Payable Outstanding — DPO)
+ * Formula: (Trade Payables / COGS) × 365
+ * Interpretation:
+ * - How many days on average it takes the company to pay its suppliers.
+ * - Higher DPO can indicate strong bargaining power, but excessively high values
+ *   may signal liquidity stress or strained supplier relationships.
+ */
+declare const payableDays: (tradePayables: number, cogs: number) => number | null;
+
+/**
+ * Working Capital Days
+ * Formula: (Working Capital / Revenue) × 365
+ * Where Working Capital = Current Assets - Current Liabilities
+ * Interpretation:
+ * - Measures how many days of revenue are tied up in working capital.
+ * - Lower is generally better (capital is not locked in operations).
+ * - Negative values indicate current liabilities exceed current assets.
+ */
+declare const workingCapitalDays: (workingCapital: number, revenue: number) => number | null;
+
+/**
+ * Cash Conversion Cycle (CCC)
+ * Formula: Debtor Days + Inventory Days - Payable Days
+ * Interpretation:
+ * - Measures the number of days it takes to convert inventory/payables into cash.
+ * - Lower (or negative) is better — negative CCC means the company collects cash
+ *   before it pays its suppliers (e.g. e-commerce, supermarkets).
+ * - High positive CCC indicates capital is tied up in operations for longer.
+ */
+declare const cashConversionCycle: (debtorDays: number, inventoryDays: number, payableDays: number) => number;
+
 /**
  * Dividend Payout Ratio
  * The proportion of earnings paid to shareholders as dividends.
@@ -930,6 +974,56 @@ declare const altmanZScore: (workingCapital: number, retainedEarnings: number, e
  */
 declare const grahamNumber: (eps: number, book: number) => number | null;
 
+/**
+ * Net Current Value Per Share (NCVPS)
+ * Formula: (Current Assets - Total Liabilities) / Shares Outstanding
+ * Interpretation:
+ * - A conservative "liquidation value" per share, inspired by Benjamin Graham's
+ *   net-net working capital criterion.
+ * - If NCVPS > market price, the stock may be trading below liquidation value —
+ *   a deep value signal (but also common in distressed or declining businesses).
+ * - Positive NCVPS means current assets alone cover all liabilities.
+ */
+declare const computeNCVPS: (currentAssets: number, totalLiabilities: number, sharesOutstanding: number) => number | null;
+
+/**
+ * G-Factor (Composite Fundamental Score)
+ * Formula: (Quality × 0.40) + (Growth × 0.35) + (Momentum × 0.25)
+ * Inputs should be scores in the range [0, 100].
+ * Output is a weighted composite in the range [0, 100].
+ *
+ * Interpretation:
+ * - G-Factor > 70  → Strong composite fundamentals
+ * - G-Factor 40–70 → Average
+ * - G-Factor < 40  → Weak
+ *
+ * Weights are based on typical quantitative equity-factor research priorities:
+ * Quality is the most predictive of long-term returns; Growth drives near-term
+ * re-rating; Momentum captures market confirmation of the thesis.
+ */
+declare const computeGFactor: (qualityScore: number, growthScore: number, momentumScore: number) => number;
+
+/**
+ * Simplified Intrinsic Value Estimate
+ * Formula: EPS × (1 + growthRate) ^ years / (1 + discountRate) ^ years
+ *          applied over a default 5-year horizon, then divided by (1 - safetyMargin)
+ *
+ * A lightweight DCF approximation for quick screening:
+ *   intrinsicValue = (EPS × (1 + growthRate)^5) / (1 - safetyMargin)
+ *
+ * Parameters:
+ * @param eps           Earnings Per Share (current or TTM)
+ * @param growthRate    Expected annual EPS growth rate as a decimal (e.g. 0.15 for 15%)
+ * @param safetyMargin  Margin of safety as a decimal (e.g. 0.25 for 25% discount)
+ *
+ * Interpretation:
+ * - If market price < intrinsicValue → potential undervaluation
+ * - safetyMargin of 0.25–0.35 is conventional for conservative investing
+ *
+ * Returns null for non-positive EPS or invalid inputs.
+ */
+declare const computeIntrinsicValue: (eps: number, growthRate: number, safetyMargin: number) => number | null;
+
 /**
  * Calculate basic growth rate given current and previous values.
  * Useful for building out mapping functions natively in the analyzer.
@@ -950,6 +1044,16 @@ declare const qoqGrowth: (dataPoints: number[]) => number[];
  * Formula: (Ending Value / Beginning Value) ^ (1 / Years) - 1
  */
 declare const cagr: (beginningValue: number, endingValue: number, periods: number) => number | null;
+/**
+ * Median Growth Rate
+ * Calculates the YoY growth rates for a series of annual values (oldest first),
+ * then returns the median of those rates.
+ * Interpretation:
+ * - More robust than mean growth because it is not skewed by outlier years.
+ * - Useful for evaluating the "typical" annual growth of earnings, revenue, etc.
+ * Returns null if fewer than 2 data points are provided.
+ */
+declare const medianGrowth: (annualValues: number[]) => number | null;
 
 /**
  * Analyst Target Upside / Downside
@@ -960,4 +1064,330 @@ declare const cagr: (beginningValue: number, endingValue: number, periods: numbe
  */
 declare const targetUpside: (currentPrice: number, targetPrice: number) => number | null;
 
-export { type CompanySnapshotInput, type EvaluatedMetric, type FundamentalTimeseriesInput, type MetricStatus, type PiotroskiInput, type PiotroskiResult, type PiotroskiSignals, altmanZScore, analyzeBatch, analyzeCompany, analyzeEfficiency, analyzeFundamentalTrends, analyzeLiquidity, analyzeProfitability, analyzeQuality, analyzeRisk, analyzeSolvency, analyzeValuation, assetTurnover, cagr, calculateDCF, calculateEnterpriseValue, calculateGrowthRate, cashConversionRatio, currentRatio, daysSalesOutstanding, debtToAssets, debtToEquity, dividendYield, earningsYield, evEbitda, evFcf, evRevenue, evaluate, fcfMargin, grahamNumber, grossMargin, impliedSharePrice, interestCoverage, inventoryTurnover, netDebt, netDebtToEbitda, netProfitMargin, operatingMargin, payoutRatio, pb, pbFromMarketCap, pe, peg, piotroski, priceToCashFlow, priceToCashFlowPerShare, ps, psFromMarketCap, qoqGrowth, quickRatio, receivablesTurnover, roa, roe, roic, safeDivide, sharpe, targetUpside, yoyGrowth };
+/**
+ * Trailing Twelve Months (TTM) Utilities
+ *
+ * TTM aggregates the most recent four quarters of data to produce
+ * an annualised figure without waiting for a full fiscal year.
+ */
+/**
+ * Trailing Twelve Months Sum
+ * Returns the sum of the last 4 quarterly values (or fewer if < 4 available).
+ * Expects values in chronological order: oldest first, most recent last.
+ * e.g. [Q1, Q2, Q3, Q4, Q1_next, Q2_next] → sums last 4
+ */
+declare const computeTTM: (quarterlyValues: number[]) => number | null;
+/**
+ * Trailing Twelve Months Average
+ * Returns the average of the last 4 quarterly values (or fewer if < 4 available).
+ * Handles arrays shorter than 4 gracefully by averaging whatever is available.
+ * Expects chronological order: oldest first, most recent last.
+ */
+declare const computeTTMAvg: (quarterlyValues: number[]) => number | null;
+
+/**
+ * Historical Aggregation Utilities
+ *
+ * Functions for computing averages, sums, and point lookups over
+ * rolling windows of quarterly (or annual) data.
+ * All functions expect chronological order: oldest first, most recent last.
+ */
+/**
+ * N-Year Average
+ * Returns the average of the last (years × 4) quarterly values.
+ * e.g. computeNYearAverage(data, 3) → average of last 12 quarters.
+ * If fewer values are available than requested, averages all available values.
+ */
+declare const computeNYearAverage: (quarterlyValues: number[], years: number) => number | null;
+/**
+ * N-Year Sum
+ * Returns the sum of the last (years × 4) quarterly values.
+ * If fewer values are available, sums all available values.
+ */
+declare const computeNYearSum: (quarterlyValues: number[], years: number) => number | null;
+/**
+ * Historical Point Lookup
+ * Returns the value at exactly `quartersBack` quarters from the most recent value.
+ * quartersBack = 0 → most recent value
+ * quartersBack = 4 → value from 1 year ago (same quarter last year)
+ * Returns null if the index is out of bounds.
+ */
+declare const computeHistoricalPoint: (quarterlyValues: number[], quartersBack: number) => number | null;
+
+/**
+ * Composite Scoring Engine
+ *
+ * Four domain scores — Quality, Growth, Value, Momentum — each in range [0, 100].
+ * Each score is a weighted sum of normalised sub-signals (also 0-100 or boolean).
+ *
+ * These scores feed into computeGFactor for the overall composite.
+ */
+interface QualityScoreInput {
+    /** Piotroski F-Score (0–9) */
+    piotroskiScore: number;
+    /**
+     * ROE vs. sector median — percentage of sector ROE this company achieves.
+     * e.g. if company ROE is 18% and sector median is 15%, pass 18/15 = 1.2.
+     * Capped at 1.0 (100 points if >= sector median).
+     */
+    roeVsSector: number;
+    /** Whether operating margins are improving YoY (boolean) */
+    marginsImproving: boolean;
+    /** Promoter pledge percentage is 0 or negligible (boolean) */
+    pledgeFree: boolean;
+    /** Promoter holding is stable or increasing YoY (boolean) */
+    promoterStable: boolean;
+}
+/**
+ * Quality Score (0–100)
+ * Weights:
+ *   Piotroski (0–9 → 0–100): 30 %
+ *   ROE vs Sector (capped at 1.0 multiplier): 20 %
+ *   Margins improving: 20 %
+ *   Pledge-free: 15 %
+ *   Promoter stable: 15 %
+ */
+declare const computeQualityScore: (input: QualityScoreInput) => number;
+interface GrowthScoreInput {
+    /**
+     * Revenue growth rate relative to sector.
+     * e.g. if company revenue grew 20% and sector average is 12%, pass 20/12 = 1.67.
+     * Capped at 1.0 (100 points if >= sector growth).
+     */
+    revenueGrowthVsSector: number;
+    /**
+     * Profit (net income) growth rate as decimal (e.g. 0.20 for 20% growth).
+     * Capped at 30% for full score (0.30 → 100).
+     */
+    profitGrowthRate: number;
+    /**
+     * EPS growth rate as decimal. Capped at 25% for full score (0.25 → 100).
+     */
+    epsGrowthRate: number;
+    /** Operating cash flow is positive this period (boolean) */
+    cfoPositive: boolean;
+    /** Revenue acceleration: current year growth > prior year growth (boolean) */
+    revenueAccelerating: boolean;
+}
+/**
+ * Growth Score (0–100)
+ * Weights:
+ *   Revenue growth vs sector: 25 %
+ *   Profit growth rate: 25 %
+ *   EPS growth rate: 20 %
+ *   CFO positive: 15 %
+ *   Revenue accelerating: 15 %
+ */
+declare const computeGrowthScore: (input: GrowthScoreInput) => number;
+interface ValueScoreInput {
+    /**
+     * Current P/E divided by the stock's own 3-year average P/E.
+     * e.g. currentPE = 15, avgPE = 20 → ratio = 15/20 = 0.75 (trading below avg → higher score).
+     * Score is higher when ratio < 1 (currently cheaper than historical average).
+     */
+    peVs3yrAvg: number;
+    /**
+     * Current P/B vs sector median P/B. Score is higher when < 1.
+     * e.g. company PB = 2, sector median PB = 3 → ratio = 2/3 ≈ 0.67
+     */
+    pbVsSector: number;
+    /**
+     * PEG ratio (P/E ÷ Growth Rate). Lower is better; 1.0 = fair, < 1 = undervalued.
+     * Capped at 0 for negative PEG; capped at full score for PEG ≤ 0.5.
+     */
+    peg: number;
+    /**
+     * Current P/E percentile over the stock's own 5-year history (0–100).
+     * Lower percentile = cheaper vs history = higher score.
+     * Pass 0–100 directly.
+     */
+    historicalPePercentile: number;
+}
+/**
+ * Value Score (0–100)
+ * Weights:
+ *   P/E vs 3yr avg: 30 %
+ *   P/B vs sector: 25 %
+ *   PEG: 25 %
+ *   Historical P/E percentile: 20 %
+ */
+declare const computeValueScore: (input: ValueScoreInput) => number;
+interface MomentumScoreInput {
+    /**
+     * Current price vs its 200-day SMA ratio.
+     * e.g. price = 105, SMA200 = 100 → ratio = 1.05 (above SMA → bullish).
+     * Score peaks at ratio ≥ 1.10 (10% above SMA).
+     */
+    priceVsSma200: number;
+    /**
+     * RSI (14-period). Range 0–100.
+     * Score peaks at RSI 50–65 (trending without being overbought).
+     */
+    rsi: number;
+    /**
+     * ADX (Average Directional Index). Range 0–100.
+     * ADX > 25 indicates a strong trend; ADX < 20 is trendless.
+     * Score peaks at ADX ≥ 30.
+     */
+    adx: number;
+    /**
+     * Volume ratio: current 20-day avg volume / 90-day avg volume.
+     * > 1.0 = rising volume (confirming move). Score caps at 1.5x.
+     */
+    volumeRatio: number;
+    /**
+     * Rate of Change over 125 trading days (6 months), as a decimal.
+     * e.g. 0.20 = 20% return over 6 months. Capped at 40% for full score.
+     */
+    roc125: number;
+}
+/**
+ * Momentum Score (0–100)
+ * Weights:
+ *   Price vs SMA200: 25 %
+ *   RSI: 20 %
+ *   ADX: 20 %
+ *   Volume ratio: 20 %
+ *   ROC-125: 15 %
+ */
+declare const computeMomentumScore: (input: MomentumScoreInput) => number;
+
+/**
+ * Technical Indicators
+ *
+ * All indicators are implemented natively with zero external dependencies.
+ * Input arrays are expected in chronological order: oldest first, most recent last.
+ * Functions return null when insufficient data is provided.
+ */
+/**
+ * Simple Moving Average (SMA)
+ * Returns the average of the last `period` values.
+ * Returns null if fewer values than `period` are provided.
+ */
+declare const sma: (prices: number[], period: number) => number | null;
+/**
+ * Exponential Moving Average (EMA)
+ * Uses the standard smoothing factor k = 2 / (period + 1).
+ * Seed: SMA of first `period` values, then EMA forward.
+ * Returns null if fewer values than `period` are provided.
+ */
+declare const ema: (prices: number[], period: number) => number | null;
+/**
+ * Relative Strength Index (RSI)
+ * Uses Wilder's Smoothed Moving Average (SMMA) — standard RSI formula.
+ * Requires at least `period + 1` data points.
+ * @param prices  Closing prices, oldest first.
+ * @param period  Default 14.
+ * Returns null if insufficient data.
+ */
+declare const rsi: (prices: number[], period?: number) => number | null;
+/**
+ * Rate of Change (ROC)
+ * Formula: ((current - priorN) / priorN) × 100
+ * Returns the percentage change over `period` bars.
+ * Returns null if fewer than `period + 1` values are provided.
+ */
+declare const roc: (prices: number[], period?: number) => number | null;
+interface MACDResult {
+    /** MACD line = EMA(fast) - EMA(slow) */
+    macdLine: number;
+    /** Signal line = EMA(macdLine, signal) */
+    signalLine: number;
+    /** Histogram = macdLine - signalLine */
+    histogram: number;
+}
+/**
+ * MACD (Moving Average Convergence/Divergence)
+ * Default: fast=12, slow=26, signal=9
+ * Returns null if insufficient data.
+ */
+declare const macd: (prices: number[], fastPeriod?: number, slowPeriod?: number, signalPeriod?: number) => MACDResult | null;
+/**
+ * Average True Range (ATR)
+ * Measures volatility by averaging the True Range over `period` bars.
+ * True Range = max(high-low, |high-prevClose|, |low-prevClose|)
+ * Uses Wilder's smoothing (same as RSI).
+ * @param highs   Array of high prices, chronological.
+ * @param lows    Array of low prices, chronological.
+ * @param closes  Array of close prices, chronological.
+ * @param period  Default 14.
+ */
+declare const atr: (highs: number[], lows: number[], closes: number[], period?: number) => number | null;
+interface BollingerBandsResult {
+    upper: number;
+    middle: number;
+    lower: number;
+    /** Bandwidth: (upper - lower) / middle */
+    bandwidth: number;
+}
+/**
+ * Bollinger Bands
+ * Middle = SMA(period), Upper = SMA + (stdDev × multiplier), Lower = SMA - (stdDev × multiplier)
+ * @param prices    Closing prices, chronological.
+ * @param period    Default 20.
+ * @param multiplier Default 2.
+ */
+declare const bollingerBands: (prices: number[], period?: number, multiplier?: number) => BollingerBandsResult | null;
+interface ADXResult {
+    /** ADX: trend strength 0–100. > 25 = trending, < 20 = ranging */
+    adx: number;
+    /** +DI: positive directional indicator */
+    plusDI: number;
+    /** -DI: negative directional indicator */
+    minusDI: number;
+}
+/**
+ * ADX (Average Directional Index) with +DI and -DI
+ * Uses Wilder's smoothing (same period as ATR).
+ * @param period Default 14.
+ */
+declare const adx: (highs: number[], lows: number[], closes: number[], period?: number) => ADXResult | null;
+/**
+ * Money Flow Index (MFI)
+ * Volume-weighted RSI. Uses typical price = (high + low + close) / 3.
+ * @param period Default 14.
+ */
+declare const mfi: (highs: number[], lows: number[], closes: number[], volumes: number[], period?: number) => number | null;
+/**
+ * VWAP (Volume-Weighted Average Price)
+ * Typically computed intraday (resets each session), but useful as a rolling
+ * VWAP over the provided data window.
+ * Formula: sum(typicalPrice × volume) / sum(volume)
+ */
+declare const vwap: (highs: number[], lows: number[], closes: number[], volumes: number[]) => number | null;
+/**
+ * Beta
+ * Measures the stock's return volatility relative to a benchmark (e.g. index).
+ * Beta = Covariance(stock, benchmark) / Variance(benchmark)
+ * @param stockReturns     Array of periodic returns for the stock.
+ * @param benchmarkReturns Array of periodic returns for the benchmark.
+ *                         Must be the same length as stockReturns.
+ * Returns null if inputs are invalid or benchmark has zero variance.
+ */
+declare const beta: (stockReturns: number[], benchmarkReturns: number[]) => number | null;
+interface PivotPointsResult {
+    /** Central pivot point */
+    pivot: number;
+    /** Resistance levels */
+    r1: number;
+    r2: number;
+    r3: number;
+    /** Support levels */
+    s1: number;
+    s2: number;
+    s3: number;
+}
+/**
+ * Classic Pivot Points
+ * Computed from the prior session's high, low, and close.
+ *   Pivot   = (high + low + close) / 3
+ *   R1 = 2×Pivot − low
+ *   S1 = 2×Pivot − high
+ *   R2 = Pivot + (high − low)
+ *   S2 = Pivot − (high − low)
+ *   R3 = high + 2×(Pivot − low)
+ *   S3 = low − 2×(high − Pivot)
+ */
+declare const pivotPoints: (high: number, low: number, close: number) => PivotPointsResult;
+
+export { type ADXResult, type BollingerBandsResult, type CompanySnapshotInput, type EvaluatedMetric, type FundamentalTimeseriesInput, type GrowthScoreInput, type MACDResult, type MetricStatus, type MomentumScoreInput, type PiotroskiInput, type PiotroskiResult, type PiotroskiSignals, type PivotPointsResult, type QualityScoreInput, type ValueScoreInput, adx, altmanZScore, analyzeBatch, analyzeCompany, analyzeEfficiency, analyzeFundamentalTrends, analyzeLiquidity, analyzeProfitability, analyzeQuality, analyzeRisk, analyzeSolvency, analyzeValuation, assetTurnover, atr, beta, bollingerBands, cagr, calculateDCF, calculateEnterpriseValue, calculateGrowthRate, cashConversionCycle, cashConversionRatio, computeGFactor, computeGrowthScore, computeHistoricalPoint, computeIntrinsicValue, computeMomentumScore, computeNCVPS, computeNYearAverage, computeNYearSum, computeQualityScore, computeTTM, computeTTMAvg, computeValueScore, currentRatio, daysSalesOutstanding, debtToAssets, debtToEquity, dividendYield, earningsYield, ema, evEbitda, evFcf, evRevenue, evaluate, fcfMargin, grahamNumber, grossMargin, impliedSharePrice, interestCoverage, inventoryTurnover, macd, marketCapToDebtCap, medianGrowth, mfi, netDebt, netDebtToEbitda, netProfitMargin, operatingMargin, payableDays, payoutRatio, pb, pbFromMarketCap, pe, peg, piotroski, pivotPoints, priceToCashFlow, priceToCashFlowPerShare, ps, psFromMarketCap, qoqGrowth, quickRatio, receivablesTurnover, roa, roc, roe, roic, rsi, safeDivide, sharpe, sma, targetUpside, vwap, workingCapitalDays, yoyGrowth };