@sheetxl/formulas-extended 0.8.0-beta.2 → 0.8.0-beta.20

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

@@ -0,0 +1,203 @@
+import { FormulaError, IFormulaContext, IFunction, IRange, Scalar } from '@sheetxl/primitives';
+/**
+ * One aggregate column: a function applied to one value column.
+ */
+export interface Measure {
+    readonly fn: IFunction;
+    /** The value column it reads. */
+    readonly column: number;
+    /** Called with `(x, y)` rather than `(x)` — see {@link aggregate}. */
+    readonly twoArgs: boolean;
+    /** What the function-name row shows. */
+    readonly label: string;
+}
+/**
+ * The function argument, resolved.
+ */
+export interface Functions {
+    /** One per output column (or, when `vertical`, one per output row of each group). */
+    readonly measures: Measure[];
+    /** The functions were a column (`VSTACK(SUM,COUNT)`): each group gets one row per function. */
+    readonly vertical: boolean;
+    /** More than one function — a row or column names them. */
+    readonly named: boolean;
+}
+/**
+ * Resolves the function argument against the value columns, or answers the whole call's error.
+ *
+ * @remarks
+ * A row of functions is one column per function, a column of them one row per function (a13, a14),
+ * and a 2-D block is refused (a15). Functions pair with value columns one to many, many to one, or
+ * one to one (a37, a38, a42). A function that cannot take one argument, or needs more than two, is
+ * refused up front (a23, a24, a43) — the call shape is decided before any group runs.
+ */
+export declare const resolveFunctions: (fn: any, valueColumns: number) => Functions | FormulaError.Known;
+/**
+ * Applies a measure to a group's members.
+ *
+ * @remarks
+ * `y` is every kept value of the column, and only a function that REQUIRES two arguments gets it
+ * (`PERCENTOF`, `LAMBDA(x,y,…)`; a20–a22). An array result, a 1×1 included, is `#VALUE!` for that
+ * cell (a25, r05, r06); a single-cell reference reads as its value, and an error — returned or
+ * thrown — is just the cell's value.
+ */
+export declare const aggregate: (measure: Measure, x: IRange, y: () => IRange) => Scalar;
+/**
+ * How the first row is read — see {@link resolveHeaders}.
+ */
+export interface Headers {
+    /** The first row is a header, not data. */
+    readonly hasHeader: boolean;
+    /** A header row is output (the data's own, or generated). */
+    readonly show: boolean;
+}
+/**
+ * The `field_headers` argument, resolved; omitted, it is guessed from the values.
+ *
+ * @remarks
+ * 0: data; 1: header, hidden; 2: no header, generate one; 3: header, shown. Anything else is
+ * `#VALUE!` (b10, b11, b16).
+ *
+ * The guess is the one sort uses: a header when the first two rows hold values of different types
+ * in some value column (b01 has `"Sales"` over `10`, b08 has `"Product"` over `"Apple"`). Excel's
+ * own rule is not fully measured yet.
+ */
+export declare const resolveHeaders: (fieldHeaders: number | undefined, values: IRange) => Headers | FormulaError.Known;
+/**
+ * Validates a `total_depth` against the number of key fields.
+ *
+ * @remarks
+ * An integer no deeper than the fields (c04, c16, c20, c21); the sign puts totals first.
+ */
+export declare const isValidDepth: (depth: number, fieldCount: number) => boolean;
+/**
+ * One axis's sort: a direction per key level, or a sort by an aggregate.
+ */
+export interface SortSpec {
+    /** Per key level, 1 ascending or -1 descending. */
+    readonly keyDirections: number[];
+    /** Sort by an aggregate column: the measure's index and its direction. */
+    readonly byValue: {
+        readonly measure: number;
+        readonly direction: number;
+    } | null;
+}
+/**
+ * Parses a `sort_order` argument.
+ *
+ * @param valueColumns How many aggregate columns follow the keys; an index past the keys picks one.
+ *
+ * @remarks
+ * `±k` sorts key level `k`, or, past the keys, an aggregate column (d02, d05). Several indices must
+ * be distinct key levels, no more than there are (d09, d11, r12–r15). Zero, out of range, text, a
+ * fraction and a logical are `#VALUE!` (d07, d08, d16, d17, r24).
+ */
+export declare const resolveSort: (sortOrder: IRange | undefined, fieldCount: number, valueColumns: number) => SortSpec | FormulaError.Known;
+/**
+ * Whether `values` is one blank CELL — refused for the whole call (g16, g19).
+ *
+ * @remarks
+ * The rule `ARRAYTOTEXT` has for a lone blank: a reference to one empty cell is `#VALUE!`, while a
+ * blank KEY (g21), two blank cells (g18) or a blank array member are ordinary values.
+ */
+export declare const isLoneBlankCell: (values: IRange) => boolean;
+/**
+ * Validates a `filter_array` against the record count.
+ *
+ * @remarks
+ * One column as tall as the data, holding logicals and numbers only: an error or text anywhere is
+ * `#VALUE!` for the whole call (f06, f08), as is a shape mismatch (f03, f09, f11).
+ */
+export declare const isValidFilter: (filter: IRange, recordCount: number) => boolean;
+/** A group of one axis of the pivot. */
+export type Group = IFormulaContext.PivotGroup;
+/**
+ * One output line of an axis: a group at the innermost level, a subtotal, or the grand total
+ * (the axis's root).
+ */
+export interface AxisLine {
+    readonly kind: 'group' | 'subtotal' | 'total';
+    readonly node: Group;
+}
+/** Each group's children in their sorted order. */
+export type AxisOrder = ReadonlyMap<Group, readonly Group[]>;
+/**
+ * `measure` over the records in both a row group and a column group: the pivot's own aggregate
+ * when it computes the function ({@link IFormulaContext.Pivot.getAggregate}), the function over
+ * the members otherwise, and `""` when no record is in both.
+ */
+export declare const aggregateAt: (pivot: IFormulaContext.Pivot, measure: Measure, values: IRange, row: Group | undefined, column: Group | undefined, y: () => IRange) => Scalar;
+/**
+ * The layout of one axis of a pivot — `GROUPBY`'s rows, or either side of `PIVOTBY` — over the
+ * pivot's tree of groups ({@link IFormulaContext.createPivot}): sorting, subtotal and total
+ * placement, and key cells.
+ *
+ * @remarks
+ * The pivot groups every key level, so a subtotal's members are one group rather than a union of
+ * its children's, and each level keeps its own group's spelling: `East`, then `east` under a later
+ * product, is still `East` in that row (c13).
+ */
+export declare class AxisLayout {
+    readonly root: Group;
+    readonly fieldCount: number;
+    /**
+     * @param axis One axis of the pivot.
+     * @param fieldCount The key columns the axis is grouped by.
+     */
+    constructor(axis: IFormulaContext.PivotAxis, fieldCount: number);
+    /**
+     * Orders the groups at every level.
+     *
+     * @param valueOf A group's aggregate, for a sort by value.
+     *
+     * @remarks
+     * Keys sort by the comparison operators' order — numbers, text, `FALSE`, `TRUE`, errors — with
+     * a blank key last in either direction (e01, e02). A sort by value orders each level by its own
+     * aggregate, parents by their subtotal (d05); ties keep key order (e06), and an error aggregate
+     * sorts last.
+     */
+    sortTree(spec: SortSpec, valueOf: (node: Group) => Scalar): AxisOrder;
+    /**
+     * The innermost groups in one flat order, for field relationship 1 (d18): by every key level in
+     * turn, then by value when the sort asks for it.
+     */
+    sortLeaves(spec: SortSpec, valueOf: (node: Group) => Scalar): Group[];
+    /**
+     * The output lines in order, with subtotals and the grand total placed per `depth`.
+     *
+     * @remarks
+     * `|depth|` 1 is the grand total alone; each step deeper adds subtotals for one more level from
+     * the top (c03, c13, c14). A negative depth puts every total before what it totals (c06, c15).
+     */
+    lines(order: AxisOrder, depth: number): AxisLine[];
+    /**
+     * The key cells of a line: its keys, `""` past its level, and the total's label.
+     *
+     * @remarks
+     * A blank key shows as `0`, as Excel spills it (a01); padding is `""` (b09, c03). The grand total
+     * is `Grand Total` once subtotals show, `Total` otherwise (c02, c03).
+     */
+    keyCells(line: AxisLine, depth: number): Scalar[];
+}
+/**
+ * The generated header of key field `index` (0-based), for `field_headers` 2 (b04).
+ */
+export declare const generatedFieldLabel: (index: number) => string;
+/**
+ * The generated header of `PIVOTBY` column field `index` (0-based), for `field_headers` 2 (p43).
+ */
+export declare const generatedColumnFieldLabel: (index: number) => string;
+/**
+ * The generated header of value column `index` (0-based), for `field_headers` 2 (b04).
+ */
+export declare const generatedValueLabel: (index: number) => string;
+/**
+ * The columns of a range, one slice each — the same object every time it is asked for, which is
+ * what lets a grouping reuse its work on a value column.
+ */
+export declare const columnsOf: (range: IRange) => IRange[];
+/**
+ * A range without its first row — the data under a header.
+ */
+export declare const withoutFirstRow: (range: IRange) => IRange;
+//# sourceMappingURL=Pivot.d.ts.map

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

@@ -7,7 +7,7 @@
  * @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>;
+caption?: string): string;
 /**
  * Returns a member or tuple from the cube.
  * @hidden Unimplemented Cube
@@ -15,7 +15,7 @@ caption?: string): Promise<string>;
  * @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>;
+export declare function CUBEMEMBER(connection: string, memberExpression: string, caption?: string): string;
 /**
  * Returns the value of a member property from the cube.
  * @hidden Unimplemented Cube
@@ -23,7 +23,7 @@ export declare function CUBEMEMBER(connection: string, memberExpression: string,
  * @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>;
+export declare function CUBEMEMBERPROPERTY(connection: string, memberExpression: string, kpiProperty: number): string;
 /**
  * Returns the nth, or ranked, member in a set.
  * @hidden Unimplemented Cube
@@ -33,7 +33,7 @@ export declare function CUBEMEMBERPROPERTY(connection: string, memberExpression:
  * @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>;
+caption?: string): string;
 /**
  * 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.
  * @hidden Unimplemented Cube
@@ -47,18 +47,18 @@ caption?: string): Promise<string>;
  * 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>;
+sortBy?: string): string;
 /**
  * Returns the number of items in a set.
  * @hidden Unimplemented Cube
  * @param set is the set whose elements are to be counted.
  */
-export declare function CUBESETCOUNT(set: string): Promise<number>;
+export declare function CUBESETCOUNT(set: string): number;
 /**
  * Returns an aggregated value from the cube.
  * @hidden Unimplemented 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>;
+export declare function CUBEVALUE(connection: string, ...memberExpression: string[]): string;
 //# sourceMappingURL=Cube.d.ts.map

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

@@ -9,19 +9,6 @@ import { AcceptError, Omittable, Scalar, NoLift } from '@sheetxl/primitives';
  * @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
- * `par · rate/frequency · Σ(Aᵢ/NLᵢ)` over the quasi-coupon periods anchored at `first_interest`,
- * as Excel 16.0 composes it (fn-battery financial/ACCRINT and adhoc-accrint-clamped, 1,796 rows,
- * 2026-08-28 / 2026-09-09) — see {@link accruedPeriods}.
- * The seven leading slots are Excel-declared `any` (a boolean is #VALUE!, an empty slot #N/A —
- * except `par`, which is 1000 when omitted — a blank cell 0); `calc_method` is a logical read
- * FIRST: any number is accepted (nonzero is TRUE), text — `"TRUE"` included — is #VALUE!. Then
- * the slots are read from the first, each coerced and validated before the next (a negative
- * issue is #NUM! over a text frequency, a frequency of 3 over a text basis): every date in the
- * calendar, the frequency 1/2/4 and the basis 0–4 after truncation; then `issue < settlement`,
- * `rate > 0`, `par > 0`, and a quasi-coupon date the walk needs below serial 1 or past the
- * calendar's end is #NUM!. A product that overflows is 0.
  */
 export declare function ACCRINT(issue: NoLift<Omittable<AcceptError<Scalar>>>, firstInterest: NoLift<Omittable<AcceptError<Scalar>>>, settlement: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, par: NoLift<Omittable<AcceptError<Scalar>>>, frequency: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>, calcMethod?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -31,16 +18,6 @@ export declare function ACCRINT(issue: NoLift<Omittable<AcceptError<Scalar>>>, f
  * @param rate is the security's annual coupon rate.
  * @param par is the security's par value.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `par · rate · yearfrac(issue, settlement)` with YEARFRAC's year fraction (the signed NASD
- * count at basis 0), measured against Excel 16.0 (fn-battery financial/ACCRINTM, 2026-08-28).
- * There is no quasi-coupon walk here — a security paying at maturity has one period — so the
- * two share their reading and nothing else. The slots read from the first: each date is coerced
- * and checked against the calendar before the next slot is looked at, then the rate, the par and
- * the basis are coerced, and only then the date order (`issue ≤ settlement` once truncated —
- * equal is 0) and the signs of the rate and the par. An OMITTED par is 1000 (a blank cell is 0,
- * and #NUM!). A product that overflows is 0.
  */
 export declare function ACCRINTM(issue: NoLift<Omittable<AcceptError<Scalar>>>, settlement: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, par: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 //# sourceMappingURL=ACCRINT.d.ts.map

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

@@ -8,28 +8,6 @@ import { Scalar, Omittable, NoLift } from '@sheetxl/primitives';
  * @param period is the period.
  * @param rate is the depreciation rate.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/AMORDEGRC, 2026-08-28), where it differs from
- * the documentation in most places:
- *
- * - The life is `1/rate`. A life of 2 or less is #NUM!; the coefficient is 1.5 up to a life of 4,
- *   2 up to 6, 2.5 beyond (the documented "1 to 2 years" and "4 to 5 years" bands do not exist).
- * - Period 0 is `cost · rate · coefficient · stub fraction` (the AMORLINC stub, see
- *   `getAmorDayCount`), capped at `cost − salvage`, ROUNDED — half away from zero, not
- *   floored — and carried into the balance rounded.
- * - Each later period is the declining charge `balance · rate · coefficient`, except the LAST
- *   TWO periods of `ceil(life)`, which split the balance in two and then take the rest. There is
- *   no other straight-line switch (a 10-year asset stays on the declining charge in period 7
- *   although straight line is larger). Every returned charge is rounded, but the balance carries
- *   the UNROUNDED charge.
- * - A balance already below salvage at the start of a period returns 0; one equal to salvage is
- *   still depreciated (`AMORDEGRC(2400,…,2399,1,0.15,1)` is 900).
- * - A period under 1 is period 1 and above 1 truncates — except that Excel answers other
- *   periods' values for some fractions below 1 (0.1 and 1E-300 answer period 5, 0.5 answers 0);
- *   those rows are accepted differences.
- * - Every argument is Excel-declared `any`: a boolean is refused, an empty argument is missing, a
- *   multi-cell reference does not broadcast. Basis truncates and 2 is refused; 4 is accepted.
  */
 export declare function AMORDEGRC(cost: NoLift<Omittable<Scalar>>, datePurchased: NoLift<Omittable<Scalar>>, firstPeriod: NoLift<Omittable<Scalar>>, salvage: NoLift<Omittable<Scalar>>, period: NoLift<Omittable<Scalar>>, rate: NoLift<Omittable<Scalar>>, basis?: NoLift<Omittable<Scalar>>): number;
 //# sourceMappingURL=AMORDEGRC.d.ts.map

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

@@ -9,17 +9,6 @@ export declare function NPV(rate: number, value: IRange<number>[]): number;
  * Returns the internal rate of return for a series of cash flows.
  * @param values is an array or a reference to cells that contain numbers for which you want to calculate the internal rate of return.
  * @param guess is a number that you guess is close to the result of IRR.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/IRR plus `adhoc-irr-iterates` and
- * `adhoc-irr-guess`, 2026-08-29). The member rule is NPV's — a text, boolean, blank or
- * empty-string member is SKIPPED and the periods close up behind it, so `{-100,TRUE,110}` is the
- * two-flow 10% — while an error member is `#VALUE!` whatever its own identity was. An error handed
- * as the whole argument is not a member and keeps its identity (`IRR(NA())` is `#N/A`). `guess` is
- * declared `number` (a boolean coerces, a text is `#VALUE!`), an ABSENT argument is 0.1 where an
- * EMPTY slot and a blank cell are 0, and the domain is the one RATE has at both ends:
- * `guess <= -1` is `#VALUE!`, and so is a guess so large that `1 + guess` is `guess` again
- * (the turn is at 2^53 — `IRR(…,9.007E15)` answers and `IRR(…,9.008E15)` does not).
  */
 export declare function IRR(values: Omittable<Flatten<AcceptError<Scalar>>>, guess?: number): number;
 /**
@@ -27,19 +16,6 @@ export declare function IRR(values: Omittable<Flatten<AcceptError<Scalar>>>, gue
  * @param values An array of cash flows; must contain at least one positive and one negative value.
  * @param financeRate The interest rate paid on negative cash flows (cost of capital).
  * @param reinvestRate The interest rate received on positive cash flows (reinvestment rate).
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/MIRR, 2026-08-29). The member rule is IRR's —
- * a text, boolean, blank or empty-string member is SKIPPED and the periods close up, so it also
- * shortens the `n` the exponent counts — but an error member keeps its own identity here where
- * IRR flattens every one to `#VALUE!`. The two rates are declared `number` (a boolean coerces, an
- * empty slot and a blank cell are 0) and are read before the members, so a text rate beats an
- * `#N/A` in the schedule.
- *
- * The form is the documented one, and each side DIVIDES by its own compounding — which is where
- * `#DIV/0!` comes from at a rate of −1 (a flow at period 0 divides by `(1+r)^0` and survives one:
- * `MIRR({-100,110},-1,0)` is 10% while `MIRR({-100,110},0,-1)` is not). Fewer than two flows, or
- * no outflow at all, divides by zero as well.
  */
 export declare function MIRR(values: Omittable<Flatten<AcceptError<Scalar>>>, financeRate: number, reinvestRate: number): number;
 /**
@@ -47,14 +23,6 @@ export declare function MIRR(values: Omittable<Flatten<AcceptError<Scalar>>>, fi
  * @param rate is the discount rate to apply to the cash flows.
  * @param values is a series of cash flows that correspond to a schedule of payments in dates.
  * @param dates is a schedule of payment dates that corresponds to the cash flow payments.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/XNPV, 2026-08-29). Each flow is discounted
- * over ACTUAL days from the FIRST date on a 365-day year — `(trunc(dᵢ) − trunc(d₀))/365`, each
- * serial truncated on its own, so a fractional date changes nothing. The dates need not be
- * sorted; they need only fall at or after `d₀`, and a date before it is #NUM!. The rate is
- * strictly positive (0 and below are #NUM!, 1E-300 is an answer), and a discount factor or a
- * sum that overflows is #NUM!. The operands read as {@link readDatedFlows} describes.
  */
 export declare function XNPV(rate: NoLift<Omittable<Scalar>>, values: Omittable<IRange>, dates: Omittable<IRange>): number;
 /**
@@ -62,23 +30,6 @@ export declare function XNPV(rate: NoLift<Omittable<Scalar>>, values: Omittable<
  * @param values is a series of cash flows that correspond to a schedule of payments in dates.
  * @param dates is a schedule of payment dates that corresponds to the cash flow payments.
  * @param guess is a number that you guess is close to the result of XIRR.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/XIRR, 2026-08-29). XIRR is XNPV's equation
- * solved for the rate — the same `(trunc(dᵢ) − trunc(d₀))/365` day count — but neither its
- * operands nor its answer are XNPV's. The members are COERCED rather than refused (numeric text
- * and date text parse; a boolean or a true text is `#VALUE!`), a pair whose VALUE is blank is
- * DROPPED, serial 0 is legal, and the dates need not be ordered at all: a flow before `d₀` is
- * discounted by a negative exponent. Fewer than two surviving pairs is `#N/A`; two of the same
- * sign is `#NUM!`. `guess` is ATP `any` — a boolean is `#VALUE!`, an EMPTY slot is the 0.1
- * default where a blank cell is 0, and a reference does not lift.
- *
- * Excel's own answer is only accurate to about eight digits and moves with the guess in the
- * ninth, so the fixture's numeric rows carry a `precision` (CALC-ISSUES 26): its
- * iteration is unidentified, as YIELD's and ODDFYIELD's are. What IS reproduced is the search's
- * one directional rule — from a NEGATIVE guess Excel never reaches a positive root
- * (`XIRR({-100,110},…,-0.5)` is `#NUM!` while the same call at guess 0 answers 10%), though a
- * non-negative guess reaches a negative root freely.
  */
 export declare function XIRR(values: Omittable<IRange>, dates: Omittable<IRange>, guess?: NoLift<Omittable<Scalar>>): number;
 //# sourceMappingURL=Cashflow.d.ts.map

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

@@ -1,12 +1,4 @@
 import { Omittable, Scalar, NoLift } from '@sheetxl/primitives';
-/**
- * Coupon date and day-count functions.
- *
- * The six share one argument reader, `readCouponArgs` — every slot is Excel-declared `any`,
- * the dates and frequency validate before the basis is read — and one coupon chain,
- * `FinanceCoupon`'s, both measured against Excel 16.0 (fn-battery financial/COUP*,
- * 2026-08-28). COUPNCD and COUPPCD return date serials, not day counts.
- */
 /**
  * Returns the number of days from the beginning of the coupon period to the settlement date.
  * @param settlement is the security's settlement date, expressed as a serial date number.
@@ -37,12 +29,6 @@ export declare function COUPDAYSNC(settlement: NoLift<Omittable<Scalar>>, maturi
  * @param maturity is the security's maturity date, expressed as a serial date number.
  * @param frequency is the number of coupon payments per year.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * Returns a date serial and leaves the cell's format alone — Excel does not hint one here, on a
- * serial argument, on `DATE(...)` or on a date-formatted reference (measured 2026-08-29). No
- * ATP-era date function does; `DATE` and `TODAY` do, and an operator such as `B1+1` propagates
- * its operand's.
  */
 export declare function COUPNCD(settlement: NoLift<Omittable<Scalar>>, maturity: NoLift<Omittable<Scalar>>, frequency: NoLift<Omittable<Scalar>>, basis?: NoLift<Omittable<Scalar>>): number;
 /**

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

@@ -5,17 +5,6 @@ import { AcceptError, Scalar, Omittable, NoLift } from '@sheetxl/primitives';
  * @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.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/DATEDIF, 2026-08-28). Both serials are
- * truncated before anything is compared (`DATEDIF(37179.6,37179.5,"d")` is 0); a serial outside
- * the calendar is #NUM!, as is a start after the end, and so is a unit that is not exactly one
- * of Y M D MD YM YD in either case — nothing is trimmed, and a number or a boolean arrives as
- * text and is refused the same way. `"MD"` re-anchors the start's day into the end's month
- * (the documented negative answers are Excel's own: Jan 31 → Mar 1 is −2). `"YD"` is the
- * `"YM"` months and `"MD"` days walked forward from the start, so it counts on the START year's
- * calendar — Jan 1 2004 → Mar 1 2005 is 60 where Jan 1 2003 → Mar 1 2004 is 59 (the documented
- * leap-year quirk), and Feb 29 2004 → Mar 1 2005 is 0.
  */
 export declare function DATEDIF(startDate: number, // Date
 endDate: number, // Date
@@ -26,17 +15,6 @@ unit: string): number;
  * @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
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/YEARFRAC, 2026-08-28). Excel declares all
- * three arguments `any`: a boolean is #VALUE!, an empty argument is #N/A where a blank cell is
- * serial 0, and a multi-cell reference does not broadcast while an array constant does. The
- * basis is read and validated FIRST — truncated, #NUM! below 0 or above 4, so
- * `YEARFRAC("x",39814,5)` is #NUM! and `YEARFRAC(NA(),39814,"x")` is #VALUE! (the dates
- * accept an error so that the body, not the marshaller, decides which is seen first) — then
- * the start, then the end, each coerced and range-checked in turn (`YEARFRAC(-1,"x",0)` is
- * #NUM!). The day counts are `getYearFrac`'s: serials truncated, dates ordered, basis 0
- * signed.
  */
 export declare function YEARFRAC(startDate: NoLift<Omittable<AcceptError<Scalar>>>, endDate: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<Scalar>>): number;
 /**
@@ -44,13 +22,6 @@ export declare function YEARFRAC(startDate: NoLift<Omittable<AcceptError<Scalar>
  * @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.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/DAYS360, 2026-08-28). Excel declares the
- * dates `number` and the method `logical`, so the engine's coercion applies: a boolean date is
- * its serial, a number is a method, `"TRUE"` is one while `"1"` is #VALUE!. A serial outside
- * the calendar is #NUM! at either slot and the fraction is discarded. The US rules are
- * `getDays360US`'s, applied to (start, end) as given.
  */
 export declare function DAYS360(startDate: number, // date
 endDate: number, // date

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

@@ -44,15 +44,6 @@ export declare function DDB(cost: number, salvage: number, life: number, period:
  * @param period is the period.
  * @param rate is the rate of depreciation.
  * @param basis year basis : 0 for year of 360 days, 1 for actual, 3 for year of 365 days.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/AMORLINC, 2026-08-28). Period 0 is the
- * stub from purchase to the end of the first period, pro-rated by `getAmorDayCount` (a
- * zero-day stub is a whole period; a stub longer than a year is not capped) and capped at
- * `cost − salvage`; every following period is `cost·rate` until the one that takes what is
- * left, and 0 beyond. A period under 1 is period 1, above it truncates. Basis truncates and 2 is
- * refused. Every argument is Excel-declared `any`: a boolean is refused, an empty argument is
- * missing, a multi-cell reference does not broadcast.
  */
 export declare function AMORLINC(cost: NoLift<Omittable<Scalar>>, datePurchased: NoLift<Omittable<Scalar>>, firstPeriod: NoLift<Omittable<Scalar>>, salvage: NoLift<Omittable<Scalar>>, period: NoLift<Omittable<Scalar>>, rate: NoLift<Omittable<Scalar>>, basis?: NoLift<Omittable<Scalar>>): number;
 //# sourceMappingURL=Depreciation.d.ts.map

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

@@ -10,16 +10,6 @@ import { AcceptError, Omittable, Scalar, NoLift } from '@sheetxl/primitives';
  * @param redemption is the security's redemption value per $100 face value.
  * @param frequency is the number of coupon payments per year.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * The odd FIRST period `[issue, firstCoupon]` is short (a stub of one regular period) or long
- * (several quasi-coupon periods); which, and the day-count sums of either, are
- * {@link oddFirstSums} — measured against Excel 16.0 on 1,125 (shape, frequency, basis) triples
- * and every row of its battery (fn-battery financial/ODDFPRICE, 2026-08-29), Excel's own
- * month-end exponent quirk included. Reading and validation are {@link readOddArgs}'s, then
- * `issue < settlement < firstCoupon < maturity` once truncated, the first coupon on the
- * maturity's coupon grid, `rate ≥ 0`, `yld ≥ 0`, `redemption > 0`; an odd period exactly one
- * regular period long is #NUM!.
  */
 export declare function ODDFPRICE(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, issue: NoLift<Omittable<AcceptError<Scalar>>>, firstCoupon: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, yld: NoLift<Omittable<AcceptError<Scalar>>>, redemption: NoLift<Omittable<AcceptError<Scalar>>>, frequency: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -50,14 +40,6 @@ export declare function ODDFYIELD(settlement: NoLift<Omittable<AcceptError<Scala
  * @param redemption is the amount to be received at maturity.
  * @param frequency is the number of coupon payments per year.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `(redemption + C·ΣDCᵢ/NLᵢ) / (1 + yld/frequency · ΣDSCᵢ/NLᵢ) − C·ΣAᵢ/NLᵢ` with
- * `C = 100·rate/frequency` — linear in the yield, since the whole bond is the one irregular
- * period. The three sums are {@link oddLastSums}; a product that overflows is 0. Measured
- * bit-for-bit on Excel 16.0 (fn-battery financial/ODDLPRICE, 556 numeric rows, 2026-08-28).
- * Reading and validation are {@link readOddArgs}'s: `lastInterest < settlement < maturity` once
- * truncated, `rate ≥ 0`, `yld ≥ 0`, `redemption > 0`.
  */
 export declare function ODDLPRICE(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, lastInterest: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, yld: NoLift<Omittable<AcceptError<Scalar>>>, redemption: NoLift<Omittable<AcceptError<Scalar>>>, frequency: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**

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

@@ -53,16 +53,6 @@ export declare function MDURATION(settlement: NoLift<Omittable<AcceptError<Scala
  * @param redemption is the security's redemption value per $100 face value.
  * @param frequency is the number of coupon payments per year.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * PRICE inverted: the yield `y` with `PRICE(…, y, …) = pr`. With one coupon left the doc's closed
- * form is used, over a coupon period that is the real span from the previous coupon to the
- * maturity (so at bases 2 and 3 the single-coupon yield does not invert PRICE's 360/f or 365/f
- * period). With more than one it is `solveYieldByNewton` on `calculatePrice` from
- * `approximateYield` — an iteration that STOPS SHORT of the root, so the answer sits ~1e-10 away
- * from it, and on a bond it cannot converge on (a redemption that dwarfs the price) it is simply
- * where the walk stood after a hundred steps. Measured, fn-battery financial/YIELD and
- * /adhoc-yield-* (2026-08-28, iteration 2026-09-09).
  */
 export declare function YIELD(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, pr: NoLift<Omittable<AcceptError<Scalar>>>, redemption: NoLift<Omittable<AcceptError<Scalar>>>, frequency: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 //# sourceMappingURL=Security.d.ts.map

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

@@ -6,13 +6,6 @@ import { AcceptError, Scalar, Omittable, NoLift } from '@sheetxl/primitives';
  * @param pr is the security's price per $100 face value.
  * @param redemption is the security's redemption value per $100 face value.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `(1 − pr/redemption)` over YEARFRAC's year fraction of the two dates — the signed NASD count
- * at basis 0, the 365/366 rules at basis 1 — measured against Excel 16.0 (fn-battery
- * financial/DISC, 2026-08-28); a price above the redemption is a negative rate, and a
- * zero-day 30/360 span (Mar 30 → Mar 31) is #NUM!. The arguments read as
- * {@link readDiscountArgs} describes.
  */
 export declare function DISC(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, pr: NoLift<Omittable<AcceptError<Scalar>>>, redemption: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -22,12 +15,6 @@ export declare function DISC(settlement: NoLift<Omittable<AcceptError<Scalar>>>,
  * @param discount is the security's discount rate.
  * @param redemption is the amount to be received at maturity.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `redemption − discount · redemption · yearfrac` with YEARFRAC's year fraction, measured
- * against Excel 16.0 (fn-battery financial/PRICEDISC, 2026-08-28): a discount that exhausts
- * the redemption gives a negative price, and the product overflowing is #NUM!. The arguments
- * read as {@link readDiscountArgs} describes.
  */
 export declare function PRICEDISC(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, discount: NoLift<Omittable<AcceptError<Scalar>>>, redemption: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -37,11 +24,6 @@ export declare function PRICEDISC(settlement: NoLift<Omittable<AcceptError<Scala
  * @param pr is the security's price per $100 face value.
  * @param redemption is the security's redemption value per $100 face value.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `(redemption − pr)/pr` over YEARFRAC's year fraction, measured against Excel 16.0 (fn-battery
- * financial/YIELDDISC, 2026-08-28); a price above the redemption is a negative yield. The
- * arguments read as {@link readDiscountArgs} describes.
  */
 export declare function YIELDDISC(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, pr: NoLift<Omittable<AcceptError<Scalar>>>, redemption: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -51,11 +33,6 @@ export declare function YIELDDISC(settlement: NoLift<Omittable<AcceptError<Scala
  * @param investment is the amount invested in the security.
  * @param redemption is the amount to be received at maturity.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `(redemption − investment)/investment` over YEARFRAC's year fraction, measured against Excel 16.0
- * (fn-battery financial/INTRATE, 2026-08-28); a redemption below the investment is a negative
- * rate. The arguments read as {@link readDiscountArgs} describes.
  */
 export declare function INTRATE(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, investment: NoLift<Omittable<AcceptError<Scalar>>>, redemption: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -65,12 +42,6 @@ export declare function INTRATE(settlement: NoLift<Omittable<AcceptError<Scalar>
  * @param investment is the amount invested in the security.
  * @param discount is the security's discount rate.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `investment / (1 − discount · yearfrac)` with YEARFRAC's year fraction, measured against
- * Excel 16.0 (fn-battery financial/RECEIVED, 2026-08-28); a denominator at or below zero (a
- * discount of 4 over a 90/360 quarter) is #NUM!. The arguments read as
- * {@link readDiscountArgs} describes.
  */
 export declare function RECEIVED(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, investment: NoLift<Omittable<AcceptError<Scalar>>>, discount: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -81,12 +52,6 @@ export declare function RECEIVED(settlement: NoLift<Omittable<AcceptError<Scalar
  * @param rate is the interest rate.
  * @param yld is the security's annual yield.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * The doc's `(100 + DIM/B·rate·100) / (1 + DSM/B·yld) − A/B·rate·100`, measured against Excel
- * 16.0 (fn-battery financial/PRICEMAT, 2026-08-28) with the counts {@link readMatArgs}
- * describes (DSM is `DIM − A`); a coupon term that overflows is 0, so a rate of 1E307 prices
- * the redemption alone.
  */
 export declare function PRICEMAT(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, issue: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, yld: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -97,11 +62,6 @@ export declare function PRICEMAT(settlement: NoLift<Omittable<AcceptError<Scalar
  * @param rate is the interest rate.
  * @param pr is the security's price per $100 face value.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * PRICEMAT inverted in closed form, `((1 + DIM/B·rate) / (pr/100 + A/B·rate) − 1) / (DSM/B)`,
- * measured against Excel 16.0 (fn-battery financial/YIELDMAT, 2026-08-28) with the counts
- * {@link readMatArgs} describes.
  */
 export declare function YIELDMAT(settlement: NoLift<Omittable<AcceptError<Scalar>>>, maturity: NoLift<Omittable<AcceptError<Scalar>>>, issue: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, pr: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 //# sourceMappingURL=SecurityMaturity.d.ts.map