@syncfusion/ej2-calculate 35.1.37

package/src/formulas/database.js

@@ -0,0 +1,579 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { FormulasErrorsStrings, CommonErrors } from '../common/index';
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { getAlphalabel } from '../base/index';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Database-style conditional aggregates (DSUM, DCOUNT, DGET) over structured table ranges.
+ *
+ * Registers 12 functions including DAVERAGE, DCOUNT, DCOUNTA, DGET, DMAX, and others.
+ *
+ * @hidden
+ */
+var DatabaseFormulas = /** @class */ (function (_super) {
+    __extends(DatabaseFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function DatabaseFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'DAVERAGE', category: 'Database', description: 'Averages the values in a column of a list or database that match criteria.' },
+            { formulaName: 'DCOUNT', category: 'Database', description: 'Counts the cells that contain numbers in a column of a list or database that match criteria.' },
+            { formulaName: 'DCOUNTA', category: 'Database', description: 'Counts nonblank cells in a column of a list or database that match criteria.' },
+            { formulaName: 'DGET', category: 'Database', description: 'Extracts a single value from a column of a list or database that matches criteria.' },
+            { formulaName: 'DMAX', category: 'Database', description: 'Returns the maximum value from a column of a list or database that matches criteria.' },
+            { formulaName: 'DMIN', category: 'Database', description: 'Returns the minimum value from a column of a list or database that matches criteria.' },
+            { formulaName: 'DPRODUCT', category: 'Database', description: 'Multiplies values in a column of a list or database that match criteria.' },
+            { formulaName: 'DSTDEV', category: 'Database', description: 'Estimates the standard deviation of a population based on a sample of entries that match criteria.' },
+            { formulaName: 'DSTDEVP', category: 'Database', description: 'Calculates the standard deviation of a population based on entries that match criteria.' },
+            { formulaName: 'DSUM', category: 'Database', description: 'Adds the numbers in the field column of records in the database that match the criteria.' },
+            { formulaName: 'DVAR', category: 'Database', description: 'Estimates variance based on a sample of entries that match criteria.' },
+            { formulaName: 'DVARP', category: 'Database', description: 'Calculates variance based on the entire population of entries that match criteria.' }
+        ];
+        return _this;
+    }
+    DatabaseFormulas.prototype.readRange = function (rangeArg) {
+        var errCollection = this.parent.getErrorStrings();
+        if (!this.parent.isCellReference(rangeArg)) {
+            return errCollection[CommonErrors.Value];
+        }
+        var parts = rangeArg.indexOf(':') > -1 ? rangeArg.split(':') : [rangeArg, rangeArg];
+        var r1 = this.parent.rowIndex(parts[0]);
+        var c1 = this.parent.colIndex(parts[0]);
+        var r2 = this.parent.rowIndex(parts[1]);
+        var c2 = this.parent.colIndex(parts[1]);
+        var rowStart = Math.min(r1, r2);
+        var rowEnd = Math.max(r1, r2);
+        var colStart = Math.min(c1, c2);
+        var colEnd = Math.max(c1, c2);
+        var grid = [];
+        for (var r = rowStart; r <= rowEnd; r++) {
+            var row = [];
+            for (var c = colStart; c <= colEnd; c++) {
+                var addr = getAlphalabel(c) + r;
+                row.push(this.parent.getValueFromArg(addr));
+            }
+            grid.push(row);
+        }
+        return grid;
+    };
+    DatabaseFormulas.prototype.fieldIndex = function (fieldArg, headers) {
+        var errCollection = this.parent.getErrorStrings();
+        var fieldVal = this.resolveTextArg(fieldArg);
+        if (errCollection.indexOf(fieldVal) > -1) {
+            return fieldVal;
+        }
+        var num = this.parent.parseFloat(fieldVal);
+        if (!isNaN(num) && num >= 1 && num <= headers.length) {
+            return Math.floor(num) - 1;
+        }
+        var upper = fieldVal.toUpperCase();
+        for (var i = 0; i < headers.length; i++) {
+            if (headers[i].toUpperCase() === upper) {
+                return i;
+            }
+        }
+        return errCollection[CommonErrors.Value];
+    };
+    DatabaseFormulas.prototype.matchCriteria = function (row, criteriaRows, headers) {
+        for (var cr = 0; cr < criteriaRows.length; cr++) {
+            var crit = criteriaRows[cr];
+            var rowMatch = true;
+            for (var c = 0; c < headers.length; c++) {
+                var criterion = crit[c];
+                if (criterion === undefined || criterion === '') {
+                    continue;
+                }
+                var cellVal = row[c];
+                if (!this.matchesCriterion(cellVal, criterion)) {
+                    rowMatch = false;
+                    break;
+                }
+            }
+            if (rowMatch) {
+                return true;
+            }
+        }
+        return false;
+    };
+    DatabaseFormulas.prototype.matchesCriterion = function (value, criterion) {
+        var crit = criterion.trim();
+        if (crit === '') {
+            return true;
+        }
+        var ops = ['>=', '<=', '<>', '>', '<', '='];
+        for (var i = 0; i < ops.length; i++) {
+            var op = ops[i];
+            if (crit.startsWith(op)) {
+                var rhs = crit.substring(op.length).trim();
+                var lv = this.parent.parseFloat(value);
+                var rv = this.parent.parseFloat(rhs);
+                if (!isNaN(lv) && !isNaN(rv)) {
+                    switch (op) {
+                        case '>=':
+                            return lv >= rv;
+                        case '<=':
+                            return lv <= rv;
+                        case '<>':
+                            return lv !== rv;
+                        case '>':
+                            return lv > rv;
+                        case '<':
+                            return lv < rv;
+                        case '=':
+                            return lv === rv;
+                        default: {
+                            var _exhaustive = op;
+                            return _exhaustive;
+                        }
+                    }
+                }
+                if (op === '=' || op === '') {
+                    return value.toUpperCase() === rhs.toUpperCase();
+                }
+                if (op === '<>') {
+                    return value.toUpperCase() !== rhs.toUpperCase();
+                }
+                return false;
+            }
+        }
+        if (crit.includes('*') || crit.includes('?')) {
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            var regex = new RegExp('^' + crit.replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i');
+            return regex.test(value);
+        }
+        return value.toUpperCase() === crit.toUpperCase();
+    };
+    DatabaseFormulas.prototype.collectMatching = function (databaseArg, fieldArg, criteriaArg, numbersOnly) {
+        var db = this.readRange(databaseArg);
+        if (typeof db === 'string') {
+            return db;
+        }
+        if (db.length < 2) {
+            return this.parent.getErrorStrings()[CommonErrors.Value];
+        }
+        var headers = db[0];
+        var fieldIdx = this.fieldIndex(fieldArg, headers);
+        if (typeof fieldIdx === 'string') {
+            return fieldIdx;
+        }
+        var critGrid = this.readRange(criteriaArg);
+        if (typeof critGrid === 'string') {
+            return critGrid;
+        }
+        if (critGrid.length < 2) {
+            return this.parent.getErrorStrings()[CommonErrors.Value];
+        }
+        var critHeaders = critGrid[0];
+        var critRows = critGrid.slice(1);
+        var nums = [];
+        var _loop_1 = function (r) {
+            var row = db[r];
+            var aligned = headers.map(function (_h, i) { return row[i] || ''; });
+            var critAligned = critRows.map(function (cr) {
+                return critHeaders.map(function (_h, i) { return cr[i] || ''; });
+            });
+            if (!this_1.matchCriteria(aligned, critAligned, headers)) {
+                return "continue";
+            }
+            var val = row[fieldIdx] || '';
+            if (numbersOnly) {
+                if (val !== '' && this_1.parent.isNumber(val)) {
+                    nums.push(this_1.parent.parseFloat(val));
+                }
+            }
+            else if (val !== '') {
+                if (this_1.parent.isNumber(val)) {
+                    nums.push(this_1.parent.parseFloat(val));
+                }
+            }
+        };
+        var this_1 = this;
+        for (var r = 1; r < db.length; r++) {
+            _loop_1(r);
+        }
+        return nums;
+    };
+    DatabaseFormulas.prototype.requireThree = function (args) {
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return null;
+    };
+    DatabaseFormulas.prototype.mean = function (nums) {
+        return nums.reduce(function (a, b) { return a + b; }, 0) / nums.length;
+    };
+    DatabaseFormulas.prototype.variance = function (nums, population) {
+        var m = this.mean(nums);
+        var sum = 0;
+        for (var i = 0; i < nums.length; i++) {
+            sum += Math.pow(nums[i] - m, 2);
+        }
+        return sum / (population ? nums.length : nums.length - 1);
+    };
+    /**
+     * Averages the values in a column of a list or database that match criteria.
+     *
+     * Excel: `DAVERAGE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=DAVERAGE(1)');
+     * ```
+     */
+    DatabaseFormulas.prototype.ComputeDAVERAGE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return this.parent.getErrorStrings()[CommonErrors.DivZero];
+        }
+        return this.mean(nums).toString();
+    };
+    /**
+     * Counts the cells that contain numbers in a column of a list or database that match criteria.
+     *
+     * Excel: `DCOUNT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDCOUNT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        return nums.length.toString();
+    };
+    /**
+     * Counts nonblank cells in a column of a list or database that match criteria.
+     *
+     * Excel: `DCOUNTA(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDCOUNTA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var db = this.readRange(args[0]);
+        if (typeof db === 'string') {
+            return db;
+        }
+        var headers = db[0];
+        var fieldIdx = this.fieldIndex(args[1], headers);
+        if (typeof fieldIdx === 'string') {
+            return fieldIdx;
+        }
+        var critGrid = this.readRange(args[2]);
+        if (typeof critGrid === 'string') {
+            return critGrid;
+        }
+        var critRows = critGrid.slice(1);
+        var count = 0;
+        for (var r = 1; r < db.length; r++) {
+            var row = db[r];
+            var critAligned = critRows.map(function (cr) {
+                return critGrid[0].map(function (_h, i) { return cr[i] || ''; });
+            });
+            if (this.matchCriteria(row, critAligned, headers) && (row[fieldIdx] || '') !== '') {
+                count++;
+            }
+        }
+        return count.toString();
+    };
+    /**
+     * Extracts a single value from a column of a list or database that matches criteria.
+     *
+     * Excel: `DGET(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDGET = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var nums = this.collectMatching(args[0], args[1], args[2], false);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.NA];
+        }
+        if (nums.length > 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        return nums[0].toString();
+    };
+    /**
+     * Returns the maximum value from a column of a list or database that matches criteria.
+     *
+     * Excel: `DMAX(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDMAX = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return this.parent.getErrorStrings()[CommonErrors.NA];
+        }
+        return Math.max.apply(Math, nums).toString();
+    };
+    /**
+     * Returns the minimum value from a column of a list or database that matches criteria.
+     *
+     * Excel: `DMIN(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDMIN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return this.parent.getErrorStrings()[CommonErrors.NA];
+        }
+        return Math.min.apply(Math, nums).toString();
+    };
+    /**
+     * Multiplies values in a column of a list or database that match criteria.
+     *
+     * Excel: `DPRODUCT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDPRODUCT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return '0';
+        }
+        return nums.reduce(function (a, b) { return a * b; }, 1).toString();
+    };
+    /**
+     * Adds the numbers in the field column of records in the database that match the criteria.
+     *
+     * Excel: `DSUM(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDSUM = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        return nums.reduce(function (a, b) { return a + b; }, 0).toString();
+    };
+    /**
+     * Estimates the standard deviation of a population based on a sample of entries that match criteria.
+     *
+     * Excel: `DSTDEV(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDSTDEV = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length < 2) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return Math.sqrt(this.variance(nums, false)).toString();
+    };
+    /**
+     * Calculates the standard deviation of a population based on entries that match criteria.
+     *
+     * Excel: `DSTDEVP(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDSTDEVP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length < 1) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return Math.sqrt(this.variance(nums, true)).toString();
+    };
+    /**
+     * Estimates variance based on a sample of entries that match criteria.
+     *
+     * Excel: `DVAR(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDVAR = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length < 2) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return this.variance(nums, false).toString();
+    };
+    /**
+     * Calculates variance based on the entire population of entries that match criteria.
+     *
+     * Excel: `DVARP(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    DatabaseFormulas.prototype.ComputeDVARP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireThree(args);
+        if (bad) {
+            return bad;
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var nums = this.collectMatching(args[0], args[1], args[2], true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length < 1) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return this.variance(nums, true).toString();
+    };
+    return DatabaseFormulas;
+}(FormulaModuleBase));
+export { DatabaseFormulas };

package/src/formulas/date-time-extra.d.ts

@@ -0,0 +1,97 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Additional date/time utilities: workdays, network days, week numbers, and calendar offsets.
+ *
+ * Registered functions: YEAR, WEEKNUM, TIMEVALUE, DAYS360, YEARFRAC, NETWORKDAYS, WORKDAY.
+ *
+ * @hidden
+ */
+export declare class DateTimeExtraFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private toSerial;
+    /**
+     * Converts a serial number to a year.
+     *
+     * Excel: `YEAR(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=YEAR(1)');
+     * ```
+     */
+    ComputeYEAR(...args: string[]): string | number;
+    /**
+     * Converts a serial number to a number representing where the week falls numerically within a year.
+     *
+     * Excel: `WEEKNUM(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    ComputeWEEKNUM(...args: string[]): string | number;
+    /**
+     * Converts a time in the form of text to a serial number.
+     *
+     * Excel: `TIMEVALUE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    ComputeTIMEVALUE(...args: string[]): string | number;
+    /**
+     * Calculates the number of days between two dates based on a 360-day year.
+     *
+     * Excel: `DAYS360(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    ComputeDAYS360(...args: string[]): string | number;
+    /**
+     * Returns the year fraction representing the number of whole days between start_date and end_date.
+     *
+     * Excel: `YEARFRAC(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    ComputeYEARFRAC(...args: string[]): string | number;
+    private isWeekend;
+    private holidaySet;
+    /**
+     * Returns the number of whole workdays between two dates.
+     *
+     * Excel: `NETWORKDAYS(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    ComputeNETWORKDAYS(...args: string[]): string | number;
+    /**
+     * Returns the serial number of the date before or after a specified number of workdays.
+     *
+     * Excel: `WORKDAY(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    ComputeWORKDAY(...args: string[]): string | number;
+}