@sheetxl/formulas-extended 0.7.23-beta.1

package/types/src/_utils/FinanceCoupon.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Shared pure-math helpers for bond pricing and coupon date functions.
+ *
+ * All formulas follow the Excel spec:
+ *   https://support.microsoft.com/en-us/office/financial-functions-reference
+ *
+ * Date arithmetic delegates to SheetXL's existing date utilities
+ * (dateAddMonths, getDaysInMonth, isLastDayOfMonth, getDayCount), and serial
+ * <-> Date conversion to FormulaContext's `dateOnly` flavors — same interface
+ * SheetXL uses throughout the financial module.
+ *
+ * Basis codes (used throughout):
+ *   0  US 30/360 (NASD)
+ *   1  Actual/actual
+ *   2  Actual/360
+ *   3  Actual/365
+ *   4  European 30/360
+ *
+ * These are plain number-in / number-out helpers that the formula wrappers
+ * call after doing all parameter validation and coercion — they touch
+ * FormulaContext only for serial<->Date conversion, never IRange or
+ * FormulaError.
+ */
+/**
+ * Returns the signed day count between two Excel serial dates using the given
+ * day-count basis.  The result is always positive (or zero) — we clamp
+ * negative to 0 because every caller wants a "days elapsed since" count and
+ * none of them need signed deltas.  Keeping a dedicated helper here makes the
+ * direction contract explicit at every call site.
+ *
+ * This is used internally by the coupon helpers and the ODD* price functions.
+ */
+export declare function daysBetween(startSerial: number, endSerial: number, basis: number): number;
+/**
+ * Previous coupon date (COUPPCD):
+ * Returns the Excel serial number of the last coupon date before or on the
+ * settlement date.
+ *
+ * Used by: COUPPCD, COUPDAYBS, COUPDAYS (basis=1), PRICE, YIELD, DURATION…
+ */
+export declare function calculateCouppcd(settlementSerial: number, maturitySerial: number, frequency: number): number;
+/**
+ * Next coupon date (COUPNCD):
+ * Returns the Excel serial number of the first coupon date after settlement.
+ *
+ * Used by: COUPNCD, COUPDAYSNC, ODDLPRICE (basis 2 / 3 branch).
+ */
+export declare function calculateCoupncd(settlementSerial: number, maturitySerial: number, frequency: number): number;
+/**
+ * Days from previous coupon to settlement (COUPDAYBS):
+ * The "accrued days" — how many days of the current coupon period have elapsed
+ * by the settlement date.
+ *
+ * Used by: COUPDAYBS, PRICE, YIELD, DURATION, MDURATION.
+ */
+export declare function calculateCoupdaybs(settlementSerial: number, maturitySerial: number, frequency: number, basis: number): number;
+/**
+ * Days in the coupon period that contains settlement (COUPDAYS):
+ * Basis 1 (actual/actual) counts actual calendar days from PCD to NCD.
+ * Basis 3 is always 365/frequency.
+ * All 30/360 bases divide 360 by frequency.
+ *
+ * Used by: COUPDAYS, PRICE, YIELD, DURATION, MDURATION, ODDLPRICE, ODDLYIELD.
+ */
+export declare function calculateCoupdays(settlementSerial: number, maturitySerial: number, frequency: number, basis: number): number;
+/**
+ * Number of remaining coupons from settlement to maturity (COUPNUM):
+ * Counts how many (12/frequency)-month backward steps from maturity are needed
+ * to pass settlement.
+ *
+ * Used by: COUPNUM, PRICE, YIELD, DURATION, MDURATION, ODDFPRICE, ODDFYIELD.
+ */
+export declare function calculateCoupnum(settlementSerial: number, maturitySerial: number, frequency: number): number;
+/**
+ * ODDFPRICE core:
+ * Prices a bond with an irregular (short or long) first coupon period.
+ *
+ * Dispatches to the short-coupon or long-coupon sub-function depending on
+ * whether DFC < E (short first period) or DFC >= E (long first period).
+ *
+ * All arguments are already validated scalars.  Returns NaN on degenerate
+ * inputs (the formula wrapper turns NaN → #NUM!).
+ *
+ * Reference:
+ *   https://support.microsoft.com/en-us/office/oddfprice-function-d7d664a8-34df-4233-8d2b-922bcf6a69e1
+ */
+export declare function calculateOddFPrice(settlementSerial: number, maturitySerial: number, issueSerial: number, firstCouponSerial: number, rate: number, yld: number, redemption: number, frequency: number, basis: number): number;
+/**
+ * Standard coupon bond price.
+ *
+ * The closed-form formula per $100 face value from the Excel spec:
+ *   https://support.microsoft.com/en-us/office/price-function-3ea9deac-8dfa-436f-a7c8-17ea02c21b0a
+ *
+ * Special-cased for N=1 (single remaining coupon period) where the standard
+ * summation degenerates and the spec provides a simpler formula.
+ *
+ * Used by: PRICE, YIELD (via Newton inversion).
+ */
+export declare function calculatePrice(settlementSerial: number, maturitySerial: number, rate: number, yld: number, redemption: number, frequency: number, basis: number): number;
+/**
+ * Macaulay duration of a coupon bond.
+ *
+ * Duration is the weighted average time to cash flow, where weights are
+ * present values of each cash flow as a fraction of total price.
+ *
+ * DURATION returns the Macaulay duration.
+ * MDURATION returns duration / (1 + yld/frequency) — the modified duration.
+ *
+ * Used by: DURATION, MDURATION.
+ */
+export declare function calculateDuration(settlementSerial: number, maturitySerial: number, coupon: number, yld: number, frequency: number, basis: number): number;
+/**
+ * Double-declining-balance depreciation for a single period.
+ *
+ * `factor` is the rate-of-decline multiplier (2 = double-declining, etc.).
+ * Switches to straight-line when SL depreciation exceeds DDB, unless the
+ * caller has requested noSwitch.
+ *
+ * This function computes one (startPeriod, endPeriod) slice; VDB sums slices
+ * across fractional periods.
+ *
+ * Used by: VDB.
+ */
+export declare function calculateDDB(cost: number, salvage: number, life: number, period: number, // 1-based period number
+factor: number): number;
+/**
+ * Returns true if the settlement and maturity dates are aligned to coupon
+ * dates — i.e., the day-of-month matches and the month difference is an exact
+ * multiple of (12/frequency).
+ *
+ * Used by ODDFPRICE / ODDFYIELD / ODDLPRICE / ODDLYIELD validators.
+ */
+export declare function isDatesAreAlignedToCoupon(date1Serial: number, date2Serial: number, frequency: number): boolean;
+/**
+ * Returns true if calculateCouppcd(d1, d2, frequency) >= 0.
+ *
+ * Used by ODDFPRICE / ODDFYIELD validators.
+ */
+export declare function isCouppcdIsNonNegative(date1Serial: number, date2Serial: number, frequency: number): boolean;
+export declare function isValidFrequency(frequency: number): boolean;
+//# sourceMappingURL=FinanceCoupon.d.ts.map

package/types/src/_utils/FinanceCoupon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinanceCoupon.d.ts","sourceRoot":"","sources":["../../../../src/_utils/FinanceCoupon.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AASH;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,MAAM,CAIR;AA8DD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GAChB,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GAChB,MAAM,CAKR;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,MAAM,CAGR;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,MAAM,CAsBR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,GAChB,MAAM,CAaR;AA8ED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,iBAAiB,EAAE,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,MAAM,CAkBR;AAyJD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,MAAM,CA8BR;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,MAAM,CA+BR;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAI,wBAAwB;AAC1C,MAAM,EAAE,MAAM,GACb,MAAM,CAaR;AAMD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAkBT;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAET;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAM3D"}

package/types/src/_utils/FinanceDate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This is a duplicate of DAYS in @sheetxl/formulas.
+ */
+export declare function daysBetween(endDate: number, // date
+startDate: number): number;
+/**
+ * Returns true if endSerial is strictly more than one year after startSerial.
+ * "More than one year" means the anniversary date has been passed —
+ * e.g. Jan 1 2008 → Jan 1 2009 is exactly one year (returns false),
+ * but Jan 1 2008 → Jan 2 2009 returns true.
+ */
+export declare function isMoreThanOneYearAfter(startSerial: number, endSerial: number): boolean;
+/**
+ * Add `months` calendar months to a UTC Date, mutating and returning it.
+ *
+ * End-of-month snapping: if the input date is the last day of its month, the
+ * result is also snapped to the last day of the destination month.  This
+ * matches Excel's coupon-date rolling convention — e.g. 31 Jan + 1 month =
+ * 28 Feb (not 3 Mar).
+ *
+ * `months` may be fractional but only the integer portion is meaningful for
+ * calendar arithmetic; the function passes the value straight to
+ * `setMonth` which truncates automatically.
+ */
+export declare function dateAddMonths(date: Date, months: number): Date;
+//# sourceMappingURL=FinanceDate.d.ts.map

package/types/src/_utils/FinanceDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinanceDate.d.ts","sourceRoot":"","sources":["../../../../src/_utils/FinanceDate.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EAAE,OAAO;AACxB,SAAS,EAAE,MAAM,GAChB,MAAM,CAER;AAGD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAcT;AAGD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAiB9D"}

package/types/src/_utils/FinanceDayCount.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Returns true if `basis` is a valid day-count basis code (0..4).
+ */
+export declare function isValidBasis(basis: number): boolean;
+/**
+ * Result type returned by `getDayCount`.
+ *
+ * `days`     — the numerator: actual or 30/360 adjusted day count.
+ * `yearDays` — the denominator: 360, 365, or the actual/actual year length.
+ *
+ * The year fraction (used in accrued interest and yield calculations) is
+ * simply `days / yearDays`.
+ */
+export interface DayCount {
+    days: number;
+    yearDays: number;
+}
+/**
+ * Compute the day count between two Excel serial dates under any of the five
+ * standard ISDA/Excel day-count conventions (the `basis` parameter).
+ *
+ * Basis codes:
+ * 0  US 30/360 (NASD)     — adjust both ends to 30-day months
+ * 1  Actual/Actual        — real calendar days; yearDays = weighted avg
+ * 2  Actual/360           — real calendar days; yearDays = 360
+ * 3  Actual/365           — real calendar days; yearDays = 365
+ * 4  European 30/360      — like basis 0, different EOM rule
+ *
+ * The result `days` is always the absolute value of the difference; the
+ * calling function is responsible for sign semantics if needed.
+ *
+ * @param startSerial The Excel serial date representing the start date.
+ * @param endSerial The Excel serial date representing the end date.
+ * @param basis The integer code representing the day-count basis (0-4).
+ * @returns An object containing the calculated `days` and `yearDays`.
+ *
+ * @remarks
+ * **Implementation Note:** Basis 0 (`_getNasd30_360`) uses a strictly different
+ * February End-of-Month rule than the standalone `DAYS360` formula. Basis 0 blocks
+ * the start-of-month Feb EOM adjustment from cascading into the end-day calculation,
+ * which is required for functions like `YEARFRAC`, `ACCRINT`, and `PRICE` to match Excel.
+ *
+ */
+export declare function getDayCount(startSerial: number, endSerial: number, basis: number): DayCount;
+/**
+ * Calculates the DAYS360 US method — signed integer day count.
+ *
+ * @see {@link getDayCount} (specifically `_getNasd30_360`) for the correct basis 0
+ * implementation used by financial formulas.
+ *
+ * @param startSerial The Excel serial date representing the start date.
+ * @param endSerial The Excel serial date representing the end date.
+ * @returns The signed number of days between the dates (negative if endSerial < startSerial).
+ *
+ * @remarks
+ * **Implementation Note:** This function is strictly for the `DAYS360` formula.
+ * It must NOT be used for standard financial functions like `YEARFRAC`, `ACCRINT`, or `PRICE`.
+ *
+ * It deliberately differs from the standard NASD 30/360 convention (basis 0) on two points,
+ * both measured against Excel:
+ *
+ * 1. The February End-of-Month conversion (startDay → 30) CASCADES into the end-day rule.
+ *    Feb 28 to Mar 31 in 2011 is 30 days here and 31 days under basis 0.
+ * 2. End-of-February is decided on the LEGACY calendar — the day after the start falls in
+ *    March — where basis 0 asks the REAL calendar. The two disagree only across the phantom
+ *    `1900-02-29`: `DAYS360(59,91)` is 33 and `DAYS360(60,91)` is 30, while the same pairs
+ *    under basis 0 are 31/360 and 32/360.
+ *
+ * The arguments are NOT swapped into order first. `DAYS360` is not antisymmetric — the rules
+ * apply to (start, end) as given, so `DAYS360(3/15, 3/31)` is 16 but `DAYS360(3/31, 3/15)`
+ * is −15, and `DAYS360(43496, 0)` is −42870 against `DAYS360(0, 43496)` = 42871.
+ *
+ * We replicate Excel's exact behavior, which utilizes different 30/360 rulesets
+ * for DAYS360 vs. NASD-based functions.
+ *
+ * https://en.wikipedia.org/wiki/Day_count_convention
+ *
+ */
+export declare function getDays360US(startSerial: number, endSerial: number): number;
+//# sourceMappingURL=FinanceDayCount.d.ts.map

package/types/src/_utils/FinanceDayCount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinanceDayCount.d.ts","sourceRoot":"","sources":["../../../../src/_utils/FinanceDayCount.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAKnD;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,WAAW,CACzB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,QAAQ,CASV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAoC3E"}

package/types/src/_utils/FinanceUtils.d.ts

@@ -0,0 +1,3 @@
+import { IRuntime } from '@sheetxl/primitives';
+export declare const defaultCurrencyFormat: (runtime: IRuntime) => string;
+//# sourceMappingURL=FinanceUtils.d.ts.map

package/types/src/_utils/FinanceUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FinanceUtils.d.ts","sourceRoot":"","sources":["../../../../src/_utils/FinanceUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAAI,SAAS,QAAQ,WAItD,CAAA"}

package/types/src/_utils/LeastSquares.d.ts

@@ -0,0 +1,131 @@
+import { FormulaError, IRange } from '@sheetxl/primitives';
+/**
+ * How Excel reads `known_y` / `known_x` into (observations x predictors).
+ *
+ * `known_y`'s SHAPE picks the axis, and nothing else does — a transposed `known_x` is an error,
+ * not something Excel silently rotates (`LINEST(D1:D6, A25:F26)` is `#REF!`):
+ *
+ * * `known_y` a single ROW (1 x p, p > 1) — each COLUMN is an observation, so each ROW of
+ *   `known_x` is one predictor.
+ * * anything else — each ROW is an observation, so each COLUMN of `known_x` is one predictor.
+ *
+ * A RECTANGULAR `known_y` (rows > 1 and columns > 1) is not an error. Excel's documented rule is
+ * "if only one variable is used, `known_y` and `known_x` may be any shape as long as the
+ * dimensions are equal", so a rectangular `known_y` is always a SINGLE-predictor fit: both sides
+ * are flattened row-major and `known_x` must match the shape exactly.
+ * (`LINEST(E1:F6)` fits over x = 1..12; `LINEST(E1:F6, A1:A6)` is `#REF!`.)
+ */
+export interface RegressionData {
+    /** p observations, flattened row-major. */
+    ys: number[];
+    /** p x k design, WITHOUT the intercept column. */
+    xs: number[][];
+    /** Number of predictors — `xs[i].length`. */
+    k: number;
+    /** `known_y` was a single row, so predictions spill as a row and new_x's predictors are rows. */
+    isRowOriented: boolean;
+    /** `known_y` was rectangular, which forces k = 1 and makes new_x element-wise. */
+    isRectangularY: boolean;
+    /** `known_y`'s shape, for shaping fitted values. */
+    yRows: number;
+    yCols: number;
+}
+/**
+ * Reads `known_y` / `known_x` the way the whole LINEST family does.
+ *
+ * STRICT membership: any non-numeric member of either range — text, boolean, or BLANK — is
+ * `#VALUE!`. There is no skipping and no coercion here (`LINEST({2;TRUE;5;4}, …)` and
+ * `LINEST({2;"3";5;4}, …)` are both `#VALUE!`), which is the opposite of the paired statistics
+ * (CORREL/SLOPE/…) where a non-numeric member drops its pair. Dropping a member here would shift
+ * every later observation against its x and silently return a different fit.
+ *
+ * @throws #VALUE! on a non-numeric member, #REF! on a dimension mismatch.
+ */
+export declare const readRegressionData: (knownYs: IRange, knownXs: IRange | undefined) => RegressionData;
+/**
+ * Reads a `new_x` range into (observations x k), and reports the shape its predictions spill into.
+ *
+ * With a SINGLE predictor `new_x` is element-wise and keeps its own shape whatever that is —
+ * `GROWTH(Q1:Q6, B1:B6, A14:B15)` over a 2x2 `new_x` spills 2x2, one prediction per member. With
+ * more than one predictor the predictor axis is pinned instead: `k` columns (or `k` rows when
+ * `known_y` was a row), and a `new_x` of the wrong width is `#REF!`.
+ *
+ * @throws #VALUE! on a non-numeric member, #REF! when the predictor axis does not match k.
+ */
+export declare const readNewX: (newXs: IRange, data: RegressionData) => {
+    xs: number[][];
+    rows: number;
+    cols: number;
+};
+/**
+ * `ln(y)` for the log-space members of the family (LOGEST / GROWTH).
+ *
+ * A y at or below zero has no logarithm, and Excel reports that as #NUM! — a distinct outcome from
+ * the #VALUE! a non-numeric member gets, so the two checks stay separate.
+ *
+ * @throws #NUM! when any y is <= 0.
+ */
+export declare const toLogYs: (ys: number[]) => number[];
+/**
+ * Evaluates a fit over `new_x`, in the shape Excel spills.
+ *
+ * With `new_x` omitted the fit is evaluated over the known xs and takes `known_y`'s OWN shape —
+ * the fitted values, so a 6x2 `known_y` spills 6x2. Otherwise the shape comes from `new_x`
+ * ({@link readNewX} decides whether that is element-wise or one row/column per observation).
+ */
+export declare const predictInShape: (data: RegressionData, newXs: IRange | undefined, predict: (x: number[]) => number) => number[][];
+/** A fitted model — coefficients in Excel's slot order plus everything the stats grid needs. */
+export interface RegressionFit {
+    /**
+     * k + 1 coefficients in EXCEL'S SLOT ORDER: `[m_k, m_(k-1), …, m_1, b]` — reversed, so slot 0
+     * belongs to the LAST column of `known_x`.
+     */
+    coefficients: number[];
+    /** Standard errors in the same slot order. `se[k]` is meaningless when `!useConst` (Excel: #N/A). */
+    standardErrors: number[];
+    /** Number of predictors actually used — a column dropped for rank deficiency does not count. */
+    kEffective: number;
+    /** `n - kEffective - (useConst ? 1 : 0)`. */
+    df: number;
+    /** Standard error of the y estimate. 0 when `df <= 0`, which is what Excel returns. */
+    sey: number;
+    /** `ssReg / ssTotal`, and 1 when `ssTotal` is 0. */
+    r2: number;
+    /** `(ssReg / kEffective) / (ssResid / df)`. `null` when `df <= 0` — Excel puts #NUM! there. */
+    f: number | null;
+    ssReg: number;
+    ssResid: number;
+    /** Predicts at one observation's predictor vector, in ORIGINAL column order. */
+    predict: (x: number[]) => number;
+}
+/**
+ * Ordinary least squares, with Excel's rank-deficiency behavior.
+ *
+ * Excel does NOT fail on collinear predictors. It drops the redundant column — coefficient 0,
+ * standard error 0 — and reduces the effective k, so `df` and `F` are computed against the
+ * columns that survived (`LINEST(M1:M4, N1:O4)` with x2 = 2*x1 returns `0.65, 0, -0.5` and df 2,
+ * not #NUM!). WHICH column is dropped is observable: the intercept is always kept, then columns
+ * are accepted from the LAST toward the first, so it is the earlier column that goes. That
+ * matches the reversed output order — Excel is eliminating in the order it reports.
+ *
+ * The same path covers "not enough observations": with n = 2 and 2 predictors the second column
+ * has no residual left and is dropped, which is exactly what Excel returns.
+ */
+export declare const fitLeastSquares: (ys: number[], xs: number[][], useConst: boolean) => RegressionFit;
+/**
+ * The `stats = TRUE` grid: 5 rows x (k + 1) columns.
+ *
+ * ```text
+ *   m_k      m_(k-1)  …  m_1   b
+ *   se(m_k)  se(…)    …  se(m_1)  se(b)
+ *   r2       sey         #N/A  #N/A
+ *   F        df          #N/A  #N/A
+ *   ssreg    ssresid     #N/A  #N/A
+ * ```
+ *
+ * Rows 3-5 hold two values each however wide the grid is, and every remaining slot is #N/A. So is
+ * `se(b)` when the intercept was not fitted — the b slot itself still carries a value (0 for
+ * LINEST, 1 for LOGEST), it is only its error that is #N/A.
+ */
+export declare const buildStatsGrid: (fit: RegressionFit, coefficients: number[], useConst: boolean) => (number | FormulaError.Known)[][];
+//# sourceMappingURL=LeastSquares.d.ts.map

package/types/src/_utils/LeastSquares.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeastSquares.d.ts","sourceRoot":"","sources":["../../../../src/_utils/LeastSquares.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAgBhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,kDAAkD;IAClD,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,6CAA6C;IAC7C,CAAC,EAAE,MAAM,CAAC;IACV,iGAAiG;IACjG,aAAa,EAAE,OAAO,CAAC;IACvB,kFAAkF;IAClF,cAAc,EAAE,OAAO,CAAC;IACxB,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,EACf,SAAS,MAAM,GAAG,SAAS,KAC1B,cAoCF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GACnB,OAAO,MAAM,EACb,MAAM,cAAc,KACnB;IAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAoB9C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,GAAI,IAAI,MAAM,EAAE,KAAG,MAAM,EAO5C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,cAAc,EACpB,OAAO,MAAM,GAAG,SAAS,EACzB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,KAC/B,MAAM,EAAE,EAuBV,CAAC;AAEF,gGAAgG;AAChG,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,qGAAqG;IACrG,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,gGAAgG;IAChG,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,EAAE,EAAE,MAAM,CAAC;IACX,uFAAuF;IACvF,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,EAAE,EAAE,MAAM,CAAC;IACX,+FAA+F;IAC/F,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CAClC;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,GAC1B,IAAI,MAAM,EAAE,EACZ,IAAI,MAAM,EAAE,EAAE,EACd,UAAU,OAAO,KAChB,aA+IF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GACzB,KAAK,aAAa,EAClB,cAAc,MAAM,EAAE,EACtB,UAAU,OAAO,KAChB,CAAC,MAAM,GAAG,YAAY,CAAC,KAAK,CAAC,EAAE,EAsBjC,CAAC"}

package/types/src/cube/Cube.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @hidden Unimplemented Cube
+ * @summary Returns a key performance indicator (KPI) property and displays the KPI name in the cell.
+ * @param connection is the name of a connection to an OLAP cube.
+ * @param kpiName is the KPI name.
+ * @param kpiProperty is the KPI property.
+ * @param caption is the caption to be displayed in the cell.
+ */
+export declare function CUBEKPIMEMBER(connection: string, kpiName: string, kpiProperty: number, // option 1-6
+caption?: string): Promise<string>;
+/**
+ * @hidden Unimplemented Cube
+ * @summary Returns a member or tuple from the cube.
+ * @param connection is the name of a connection to an OLAP cube.
+ * @param memberExpression is the expression representing the name of a member or tuple in the OLAP cube.
+ * @param caption is the caption to be displayed in the cell.
+ */
+export declare function CUBEMEMBER(connection: string, memberExpression: string, caption?: string): Promise<string>;
+/**
+ * @hidden Unimplemented Cube
+ * @summary Returns the value of a member property from the cube.
+ * @param connection is the name of a connection to an OLAP cube.
+ * @param memberExpression is the expression representing the name of a member in the OLAP cube.
+ * @param kpiProperty is the property name.
+ */
+export declare function CUBEMEMBERPROPERTY(connection: string, memberExpression: string, kpiProperty: number): Promise<string>;
+/**
+ * @hidden Unimplemented Cube
+ * @summary Returns the nth, or ranked, member in a set.
+ * @param connection is the name of a connection to an OLAP cube.
+ * @param setExpression is the set from which the element is to be retrieved.
+ * @param rank is the rank of the element to be retrieved.
+ * @param caption is the caption to be displayed in the cell.
+ */
+export declare function CUBERANKEDMEMBER(connection: string, setExpression: string, rank: number, // 1 - 5
+caption?: string): Promise<string>;
+/**
+ * @hidden Unimplemented Cube
+ * @summary Defines a calculated set of members or tuples by sending a set expression to the cube on the server, which creates the set, and then returns that set to Microsoft Excel.
+ * @param connection is the name of a connection to an OLAP cube.
+ * @param setExpression is the expression for the set.
+ * @param caption is the caption to be displayed in the cell.
+ * @param sortOrder is the sort order.
+ * @param sortBy is the sort by.
+ *
+ * @remarks
+ * https://support.office.com/client/results?authtype=unknown&lcid=1033&locale=en-us&microsoftapplicationstelemetrydeviceid=70192ff8-de17-4a6b-8e59-35903120b479&ns=EXCEL&syslcid=1033&uilcid=1033&version=90&helpid=xlmain11.chm60526
+ */
+export declare function CUBESET(connection: string, setExpression: string, caption?: string, sortOrder?: number, // 1 - 6
+sortBy?: string): Promise<string>;
+/**
+ * @hidden Unimplemented Cube
+ * @summary Returns the number of items in a set.
+ * @param set is the set whose elements are to be counted.
+ */
+export declare function CUBESETCOUNT(set: string): Promise<number>;
+/**
+ * @hidden Unimplemented Cube
+ * @summary Returns an aggregated value from the cube.
+ * @param connection is the name of a connection to an OLAP cube.
+ * @param memberExpression is a slicer that determines the portion of the OLAP cube for which the aggregation value is to be retrieved.
+ */
+export declare function CUBEVALUE(connection: string, ...memberExpression: string[]): Promise<string>;
+//# sourceMappingURL=Cube.d.ts.map

package/types/src/cube/Cube.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cube.d.ts","sourceRoot":"","sources":["../../../../src/cube/Cube.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,aAAa;AAClC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,EACxB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,EAAE,QAAQ;AACtB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACrB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ;AAC5B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEzD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,UAAU,EAAE,MAAM,EAClB,GAAG,gBAAgB,EAAE,MAAM,EAAE,GAC5B,OAAO,CAAC,MAAM,CAAC,CAEjB"}

package/types/src/financial/ACCRINT.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @summary Returns the accrued interest for a security that pays periodic interest.
+ * @param issue is the security's issue date, expressed as a serial date number.
+ * @param firstInterest is the security's first interest date, expressed as a serial date number.
+ * @param settlement is the security's settlement date, expressed as a serial date number.
+ * @param rate is the security's annual coupon rate.
+ * @param par is the security's par value.
+ * @param frequency is the number of coupon payments per year.
+ * @param basis is the type of day count basis to use.
+ * @param calcMethod is a logical value: to accrued interest from issue date = TRUE; to calculate from last coupon payment date = FALSE.
+ *
+ * @remarks
+ * {@link https://support.microsoft.com/en-us/office/accrint-function-fe45d089-6722-4fb3-9379-e1f911d8dc74|Docs}
+ */
+export declare function ACCRINT(issue: number, // date
+firstInterest: number, //date
+settlement: number, //date
+rate: number, par: number, frequency: number, basis?: number, calcMethod?: boolean): number;
+//# sourceMappingURL=ACCRINT.d.ts.map

package/types/src/financial/ACCRINT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ACCRINT.d.ts","sourceRoot":"","sources":["../../../../src/financial/ACCRINT.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,EAAE,OAAO;AACtB,aAAa,EAAE,MAAM,EAAE,MAAM;AAC7B,UAAU,EAAE,MAAM,EAAE,MAAM;AAC1B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,KAAK,GAAE,MAAQ,EACf,UAAU,GAAE,OAAY,GACvB,MAAM,CA+BR"}

package/types/src/financial/AMORDEGRC.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @summary Returns the depreciation for each accounting period using a
+ * depreciation coefficient (French degressive / accelerated depreciation).
+ * @param cost is the cost of the asset.
+ * @param datePurchased is the date the asset is purchased.
+ * @param firstPeriod is the date of the end of the first period.
+ * @param salvage is the salvage value at the end of life of the asset.
+ * @param period is the period.
+ * @param rate is the depreciation rate.
+ * @param basis is the type of day count basis to use.
+ *
+ * @remarks
+ * AMORDEGRC is the accelerated counterpart to AMORLINC. The depreciation
+ * rate is multiplied by a coefficient that depends on the asset's useful life
+ * (computed as `1 / rate`):
+ *
+ *   life (1/rate)  │ coefficient
+ *   ───────────────┼────────────
+ *   < 3 years      │ 1.5 (special algorithm — see below)
+ *   3–4 years      │ 1.5
+ *   5–6 years      │ 2.0
+ *   > 6 years      │ 2.5
+ *
+ * The accelerated rate = rate × coefficient.
+ *
+ * Normal algorithm (life >= 3, per Excel spec):
+ *   Period 0: FLOOR(cost × rateAccel × (days / 365))   [basis=1 always uses 365]
+ *             bv carry-forward uses actual yearDays (366 for leap years)
+ *   Period N: FLOOR(max(DDB, SL)) where:
+ *               DDB = bv × rateAccel
+ *               SL  = bv / (ceil(1/rate) − period)   [no salvage subtraction]
+ *             No clamping to (bv − salvage) — Excel deprecates past salvage.
+ *             Returns 0 when bv ≤ salvage at start of period.
+ *
+ * Special algorithm (life < 3):
+ *   Period 0: FLOOR(cost × rateAccel × (days / actualYearDays))
+ *   Period N: CEIL(bv / (ceil(1/rate) − 1))  — same value for all remaining periods
+ *   Returns 0 once all remaining periods are exhausted.
+ *
+ * Excel-verified behaviors:
+ *   - basis=2 and basis=4 return #NUM! (unlike AMORLINC which rejects basis=2
+ *     only; AMORDEGRC rejects both)
+ *   - life < 3 does NOT return #NUM! despite documentation — Excel computes
+ *     using coeff=1.5 with the simplified equal-split algorithm above
+ *   - period 0 for basis=1 with life >= 3: return value uses yearDays=365,
+ *     but the bv carried into period 1 uses the actual yearDays (366 for leap).
+ *     This means total depreciation across all periods can exceed cost by 1
+ *     for the life < 3 case — this matches Excel's behavior exactly.
+ */
+export declare function AMORDEGRC(cost: number, datePurchased: number, // date serial
+firstPeriod: number, // date serial
+salvage: number, period: number, rate: number, basis?: number): number;
+//# sourceMappingURL=AMORDEGRC.d.ts.map

package/types/src/financial/AMORDEGRC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AMORDEGRC.d.ts","sourceRoot":"","sources":["../../../../src/financial/AMORDEGRC.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EAAE,cAAc;AACrC,WAAW,EAAE,MAAM,EAAI,cAAc;AACrC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAAU,GAChB,MAAM,CAoCR"}

package/types/src/financial/Date.d.ts

@@ -0,0 +1,29 @@
+import { Scalar } from '@sheetxl/primitives';
+/**
+ * @hidden Legacy
+ * @summary Returns the number of days between two dates.
+ * @param startDate is a serial date number that represents the start date.
+ * @param endDate is a serial date number that represents the end date.
+ * @param unit is a string that specifies the unit of time to use.
+ */
+export declare function DATEDIF(startDate: number, // Date
+endDate: number, // Date
+unit: string): number;
+/**
+ * @summary Returns the year fraction representing the number of whole days between start_date and end_date.
+ * @param startDate is a serial date number that represents the start date.
+ * @param endDate is a serial date number that represents the end date.
+ * @param basis is the type of day count basis to use.
+ * @category Date & Time
+ */
+export declare function YEARFRAC(startDate: Scalar, endDate: Scalar, basis?: Scalar): number;
+/**
+ * @summary Returns the number of days between two dates based on a 360-day year (twelve 30-day months).
+ * @param endDate startDate and endDate are the two dates between which you want to know the number of days.
+ * @param startDate startDate and endDate are the two dates between which you want to know the number of days.
+ * @param method is a logical value specifying the calculation method: U.S. (NASD) = FALSE; European = TRUE.
+ */
+export declare function DAYS360(startDate: number, // date
+endDate: number, // date
+method?: boolean): number;
+//# sourceMappingURL=Date.d.ts.map

package/types/src/financial/Date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Date.d.ts","sourceRoot":"","sources":["../../../../src/financial/Date.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAKlE;;;;;;GAMG;AACH,wBAAgB,OAAO,CACrB,SAAS,EAAE,MAAM,EAAE,OAAO;AAC1B,OAAO,EAAE,MAAM,EAAE,OAAO;AACxB,IAAI,EAAE,MAAM,GACX,MAAM,CAsCR;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,MAAQ,GACd,MAAM,CAwBR;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CACrB,SAAS,EAAE,MAAM,EAAE,OAAO;AAC1B,OAAO,EAAE,MAAM,EAAE,OAAO;AACxB,MAAM,GAAE,OAAa,GACpB,MAAM,CAMR"}