sec-edgar-api 0.2.1 → 0.2.2

package/build/services/ReportBuilder/FactPeriodResolver.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ReportRawResolvable_1 = require("./ReportRawResolvable");
+var FactPeriodResolver = /** @class */ (function () {
+    function FactPeriodResolver(args) {
+        /** Values for each quarter [numQ1, numQ2, numQ3, numQ4] */
+        this.valueByQuarterByPropertyByYear = new Map();
+        /** Same as by quarter but string values */
+        this.valueByQuarterByPropertyByYearString = new Map();
+        /** Value sums (each includes sum of previous quarter). last el used for annual report. [sumQ1, sumQ2, sumQ3, sumFY] */
+        this.sumByQuarterByPropertyByYear = new Map();
+        /** Which properties have a range that need to be resolved to get quarterly value */
+        this.propertiesResolvableByYear = new Map();
+        /** all properties present for each year */
+        this.propertiesByYear = new Map();
+        /** prevent values from being added multiple times */
+        this.resolvedValues = new Set();
+        this.unresolvedReports = new Map();
+        var cik = args.cik;
+        this.cik = cik;
+    }
+    FactPeriodResolver.prototype.getOrSetBucketArr = function (map, year, propertyName) {
+        var _a, _b;
+        var propertyMap = (_a = map.get(year)) !== null && _a !== void 0 ? _a : map.set(year, new Map()).get(year);
+        return (_b = propertyMap.get(propertyName)) !== null && _b !== void 0 ? _b : propertyMap.set(propertyName, new Map()).get(propertyName);
+    };
+    FactPeriodResolver.prototype.addPropertyByYear = function (bucket, year, propertyName) {
+        var _a;
+        var properties = (_a = bucket.get(year)) !== null && _a !== void 0 ? _a : bucket.set(year, new Set()).get(year);
+        properties.add(propertyName);
+    };
+    FactPeriodResolver.prototype.resolveValues = function (propertyName, year) {
+        var _a, _b, _c;
+        var keyResolved = "".concat(year, "_").concat(propertyName);
+        var isResolved = this.resolvedValues.has(keyResolved);
+        var isResolvable = Boolean((_a = this.propertiesResolvableByYear.get(year)) === null || _a === void 0 ? void 0 : _a.has(propertyName));
+        if (!isResolvable || isResolved)
+            return;
+        var _d = this.getPropertyBuckets(year, propertyName), bucketQuarter = _d.bucketQuarter, bucketSum = _d.bucketSum;
+        if (bucketQuarter.size === 4 && bucketSum.has(3))
+            return;
+        for (var i = 0; i < 4; i++) {
+            var quarterValue = bucketQuarter.get(i);
+            var reportKey = "".concat(year, "_").concat(i + 1);
+            var unresolvedReport = this.unresolvedReports.get(reportKey);
+            var unresolvedReportPrev = this.unresolvedReports.get("".concat(year, "_").concat(i));
+            var sumValue = (_b = unresolvedReport === null || unresolvedReport === void 0 ? void 0 : unresolvedReport.getNumber(propertyName)) !== null && _b !== void 0 ? _b : 0;
+            var prevSum = (_c = unresolvedReportPrev === null || unresolvedReportPrev === void 0 ? void 0 : unresolvedReportPrev.getNumber(propertyName)) !== null && _c !== void 0 ? _c : 0;
+            if (quarterValue === undefined) {
+                var bucketQuarter_1 = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYear, year, propertyName);
+                bucketQuarter_1.set(i, (Number(sumValue) || 0) - (Number(prevSum) || 0));
+            }
+            if (quarterValue !== undefined && sumValue === undefined) {
+                var bucketSum_1 = this.getOrSetBucketArr(this.sumByQuarterByPropertyByYear, year, propertyName);
+                bucketSum_1.set(i, quarterValue + prevSum);
+            }
+        }
+        this.resolvedValues.add(keyResolved);
+    };
+    FactPeriodResolver.prototype.get = function (propertyName, year, fiscalPeriod) {
+        var _a, _b;
+        this.resolveValues(propertyName, year);
+        var index = (_a = { Q1: 0, Q2: 1, Q3: 2, Q4: 3, FY: 3 }[fiscalPeriod]) !== null && _a !== void 0 ? _a : 4;
+        var isAnnual = fiscalPeriod === 'FY';
+        var bucket = isAnnual
+            ? this.sumByQuarterByPropertyByYear.get(year)
+            : this.valueByQuarterByPropertyByYear.get(year);
+        return (_b = bucket === null || bucket === void 0 ? void 0 : bucket.get(propertyName)) === null || _b === void 0 ? void 0 : _b.get(index);
+    };
+    FactPeriodResolver.prototype.getPropertyBuckets = function (year, propertyName) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var isInstant = !((_a = this.propertiesResolvableByYear.get(year)) === null || _a === void 0 ? void 0 : _a.has(propertyName));
+        var bucketQuarter = (_c = (_b = this.valueByQuarterByPropertyByYear.get(year)) === null || _b === void 0 ? void 0 : _b.get(propertyName)) !== null && _c !== void 0 ? _c : new Map();
+        var bucketSum = isInstant
+            ? bucketQuarter
+            : (_e = (_d = this.sumByQuarterByPropertyByYear.get(year)) === null || _d === void 0 ? void 0 : _d.get(propertyName)) !== null && _e !== void 0 ? _e : new Map();
+        var bucketString = (_g = (_f = this.valueByQuarterByPropertyByYearString.get(year)) === null || _f === void 0 ? void 0 : _f.get(propertyName)) !== null && _g !== void 0 ? _g : new Map();
+        return { bucketQuarter: bucketQuarter, bucketSum: bucketSum, bucketString: bucketString };
+    };
+    FactPeriodResolver.prototype.getPeriod = function (params) {
+        var start = params.start, end = params.end;
+        if (!start || start === end)
+            return 0;
+        var differenceMS = new Date(end).getTime() - new Date(start).getTime();
+        var differenceDays = differenceMS / 86400000;
+        if (differenceDays < 135)
+            return 3;
+        if (differenceDays < 225)
+            return 6;
+        if (differenceDays < 315)
+            return 9;
+        return 12;
+    };
+    FactPeriodResolver.prototype.getOrSetReport = function (params) {
+        var _a;
+        var year = params.year, quarter = params.quarter;
+        var key = "".concat(year, "_").concat(quarter);
+        var report = (_a = this.unresolvedReports.get(key)) !== null && _a !== void 0 ? _a : new ReportRawResolvable_1.default({
+            cik: this.cik,
+            fiscalYear: year,
+            fiscalPeriod: quarter === 4 ? 'FY' : "Q".concat(quarter),
+            dateReport: '',
+            dateFiled: '',
+            url: null,
+            splitDate: null,
+            splitRatio: null,
+        });
+        if (!this.unresolvedReports.has(key)) {
+            this.unresolvedReports.set(key, report);
+        }
+        return report;
+    };
+    FactPeriodResolver.prototype.add = function (params) {
+        var year = params.year, value = params.value, propertyName = params.name, quarter = params.quarter, start = params.start, end = params.end, dateReport = params.dateReport, dateFiled = params.dateFiled;
+        var period = this.getPeriod({ start: start, end: end });
+        this.addPropertyByYear(this.propertiesByYear, year, propertyName);
+        if (typeof value === 'string') {
+            var bucket = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYearString, year, propertyName);
+            bucket.set(quarter - 1, value);
+            return;
+        }
+        if (period === 0) {
+            var bucket = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYear, year, propertyName);
+            var bucketSum = this.getOrSetBucketArr(this.sumByQuarterByPropertyByYear, year, propertyName);
+            bucket.set(quarter - 1, value);
+            bucketSum.set(quarter - 1, value);
+            return;
+        }
+        if (period === 3) {
+            var bucket = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYear, year, propertyName);
+            bucket.set(quarter - 1, value);
+        }
+        if (quarter === 1 || period > 3) {
+            var bucket = this.getOrSetBucketArr(this.sumByQuarterByPropertyByYear, year, propertyName);
+            bucket.set(quarter - 1, value);
+        }
+        this.addPropertyByYear(this.propertiesResolvableByYear, year, propertyName);
+    };
+    FactPeriodResolver.prototype.buildUnresolvedReports = function () {
+        var _this = this;
+        this.propertiesByYear.forEach(function (properties, year) {
+            properties.forEach(function (propertyName) {
+                var _a, _b;
+                for (var i = 0; i < 4; i++) {
+                    var bucketSum = (_a = _this.sumByQuarterByPropertyByYear.get(year)) === null || _a === void 0 ? void 0 : _a.get(propertyName);
+                    var bucketQuarter = _this.getOrSetBucketArr(_this.valueByQuarterByPropertyByYear, year, propertyName);
+                    if (bucketSum && !bucketSum.has(i)) {
+                        var prevSum = 0;
+                        var quarterSum = 0;
+                        for (var j = 0; j < i; j++) {
+                            prevSum = quarterSum;
+                            quarterSum = (_b = bucketSum.get(j)) !== null && _b !== void 0 ? _b : quarterSum;
+                        }
+                        bucketSum.set(i, quarterSum);
+                        bucketQuarter.set(i, quarterSum - prevSum);
+                    }
+                    var value = bucketSum === null || bucketSum === void 0 ? void 0 : bucketSum.get(i);
+                    if (value === undefined)
+                        continue;
+                    var report = _this.getOrSetReport({ year: year, quarter: i + 1 });
+                    report.report[propertyName] = value;
+                }
+            });
+        });
+    };
+    FactPeriodResolver.prototype.forEach = function (callback) {
+        var _this = this;
+        this.buildUnresolvedReports();
+        this.propertiesByYear.forEach(function (properties, year) {
+            properties.forEach(function (propertyName) {
+                var _a;
+                _this.resolveValues(propertyName, year);
+                for (var i = 0; i < 5; i++) {
+                    var isAnnual = i === 4;
+                    var _b = _this.getPropertyBuckets(year, propertyName), bucketQuarter = _b.bucketQuarter, bucketSum = _b.bucketSum, bucketString = _b.bucketString;
+                    var value = (_a = (isAnnual ? bucketSum.get(3) : bucketQuarter.get(i))) !== null && _a !== void 0 ? _a : bucketString.get(i);
+                    var fiscalPeriod = isAnnual ? 'FY' : "Q".concat(i + 1);
+                    callback({ year: year, fiscalPeriod: fiscalPeriod, propertyName: propertyName, value: value });
+                }
+            });
+        });
+    };
+    return FactPeriodResolver;
+}());
+exports.default = FactPeriodResolver;

package/build/services/ReportBuilder/FactRecordBuilder.d.ts

@@ -0,0 +1,7 @@
+import { FactItem } from './ReportBuilder';
+import { CompanyFactListData } from '../../types';
+export default class FactRecordBuilder {
+    createFacts(data: CompanyFactListData): {
+        facts: FactItem[];
+    };
+}

package/build/services/ReportBuilder/FactRecordBuilder.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactRecordBuilder = /** @class */ (function () {
+    function FactRecordBuilder() {
+    }
+    FactRecordBuilder.prototype.createFacts = function (data) {
+        var facts = data.facts, cik = data.cik;
+        var factItems = [];
+        for (var prefix in facts) {
+            var factByPropertyName = facts[prefix];
+            for (var propertyName in factByPropertyName) {
+                var units = factByPropertyName[propertyName].units;
+                for (var unit in units) {
+                    var factValues = units[unit];
+                    for (var _i = 0, factValues_1 = factValues; _i < factValues_1.length; _i++) {
+                        var factValue = factValues_1[_i];
+                        var end = factValue.end, start = factValue.start, val = factValue.val, filed = factValue.filed, accn = factValue.accn, form = factValue.form, fp = factValue.fp, frame = factValue.frame, fy = factValue.fy;
+                        var name_1 = "".concat(prefix, ":").concat(propertyName);
+                        var item = {
+                            cik: cik,
+                            end: end,
+                            filed: filed,
+                            name: name_1,
+                            unit: unit,
+                            value: val,
+                            accn: accn,
+                        };
+                        if (start)
+                            item.start = start;
+                        if (accn)
+                            item.accn = accn;
+                        if (form)
+                            item.form = form;
+                        if (fp)
+                            item.fp = fp;
+                        if (frame)
+                            item.frame = frame;
+                        if (fy)
+                            item.fy = fy;
+                        factItems.push(item);
+                    }
+                }
+            }
+        }
+        return { facts: factItems };
+    };
+    return FactRecordBuilder;
+}());
+exports.default = FactRecordBuilder;

package/build/services/ReportBuilder/FactSplitAdjuster.d.ts

@@ -0,0 +1,39 @@
+import { FiscalPeriod } from '../../types/report-raw.type';
+import { FactItemWithFiscals } from './ReportBuilder';
+interface SplitData {
+    end: string;
+    filed: string;
+    value: number;
+    firstFiled: string;
+    fiscalYear: number;
+}
+type FactItemWithFiscalsNumeric = Omit<FactItemWithFiscals, 'cik' | 'value'> & {
+    value: number;
+};
+export default class FactSplitAdjuster {
+    private readonly splitKey;
+    private readonly splitByFiscalYearAmount;
+    private readonly factsByYearQuarterByPropertyName;
+    private readonly factsAnnaulByYearByPropertyName;
+    private readonly resolvedProperties;
+    private sortedSplits;
+    private getMap;
+    add(fact: FactItemWithFiscalsNumeric): void;
+    getSplitsAsc(): SplitData[];
+    isSplitProperty(propertyName: string): boolean;
+    addSplitData(data: Omit<SplitData, 'firstFiled'>): void;
+    private didApplySplit;
+    isSplitAdjustableUnit(unit: string): boolean;
+    isShareRatioUnit(unit: string): boolean;
+    private getSortedFacts;
+    resolveProperty(propertyName: string): void;
+    get(propertyName: string, year: number, fiscalPeriod: FiscalPeriod): number | undefined;
+    forEach(callback: (params: {
+        propertyName: string;
+        year: number;
+        fiscalPeriod: FiscalPeriod;
+        value: number;
+    }) => void): void;
+    private adjustValuesForSplits;
+}
+export {};

package/build/services/ReportBuilder/FactSplitAdjuster.js

@@ -0,0 +1,192 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactSplitAdjuster = /** @class */ (function () {
+    function FactSplitAdjuster() {
+        this.splitKey = 'StockholdersEquityNoteStockSplitConversionRatio1';
+        this.splitByFiscalYearAmount = new Map();
+        this.factsByYearQuarterByPropertyName = new Map();
+        this.factsAnnaulByYearByPropertyName = new Map();
+        this.resolvedProperties = new Set();
+        this.sortedSplits = null;
+    }
+    FactSplitAdjuster.prototype.getMap = function (map, propertyName) {
+        var _a;
+        return (_a = map.get(propertyName)) !== null && _a !== void 0 ? _a : map.set(propertyName, new Map()).get(propertyName);
+    };
+    FactSplitAdjuster.prototype.add = function (fact) {
+        var propertyName = fact.name, year = fact.year, fiscalPeriod = fact.fiscalPeriod, unit = fact.unit, filed = fact.filed, value = fact.value, end = fact.end;
+        if (this.isSplitProperty(propertyName)) {
+            this.addSplitData({ end: end, filed: filed, fiscalYear: year, value: Number(value) });
+            return;
+        }
+        if (!this.isSplitAdjustableUnit(unit))
+            return;
+        if (this.resolvedProperties.has(propertyName)) {
+            throw new Error("Property ".concat(propertyName, " has already been resolved"));
+        }
+        var isAnnual = fiscalPeriod === 'FY';
+        var map = isAnnual
+            ? this.getMap(this.factsAnnaulByYearByPropertyName, propertyName)
+            : this.getMap(this.factsByYearQuarterByPropertyName, propertyName);
+        var key = "".concat(year, "_").concat(fiscalPeriod);
+        map.set(key, fact);
+    };
+    FactSplitAdjuster.prototype.getSplitsAsc = function () {
+        if (this.sortedSplits)
+            return this.sortedSplits;
+        var sortedSplits = Array.from(this.splitByFiscalYearAmount.values()).sort(function (a, b) {
+            return a.filed < b.filed ? -1 : 1;
+        });
+        this.sortedSplits = sortedSplits;
+        return sortedSplits;
+    };
+    FactSplitAdjuster.prototype.isSplitProperty = function (propertyName) {
+        return propertyName === this.splitKey;
+    };
+    FactSplitAdjuster.prototype.addSplitData = function (data) {
+        var end = data.end, filed = data.filed, fiscalYear = data.fiscalYear, value = data.value;
+        var split = value;
+        var key = "".concat(fiscalYear, "-").concat(split);
+        var prevSplit = this.splitByFiscalYearAmount.get(key);
+        if (!prevSplit) {
+            this.splitByFiscalYearAmount.set(key, __assign(__assign({}, data), { firstFiled: filed }));
+            this.sortedSplits = null;
+            return;
+        }
+        var curEnd = end;
+        var curFiled = filed;
+        var prevEnd = prevSplit.end;
+        var prevFiled = prevSplit.filed;
+        var shouldUpdateFactItem = !prevSplit || prevEnd < curEnd || (prevEnd === curEnd && prevFiled > curFiled);
+        var shouldUpdateFirstFiled = prevFiled > curFiled;
+        if (shouldUpdateFactItem) {
+            var curData = this.splitByFiscalYearAmount.get(key);
+            curData.end = end;
+            curData.filed = filed;
+            curData.value = value;
+            curData.fiscalYear = fiscalYear;
+            this.sortedSplits = null;
+        }
+        if (shouldUpdateFirstFiled) {
+            var curData = this.splitByFiscalYearAmount.get(key);
+            curData.firstFiled = curFiled;
+            this.sortedSplits = null;
+        }
+    };
+    FactSplitAdjuster.prototype.didApplySplit = function (params) {
+        var nextValue = params.nextValue, prevValue = params.prevValue, split = params.split, isShareRatio = params.isShareRatio, value = params.value, filed = params.filed;
+        if (filed > split.filed) {
+            return true;
+        }
+        if (filed < split.firstFiled) {
+            return false;
+        }
+        var valWithSplit = isShareRatio ? value / split.value : value * split.value;
+        if (nextValue !== null) {
+            var difference = Math.abs(nextValue - value);
+            var differenceSplit = Math.abs(nextValue - valWithSplit);
+            return difference < differenceSplit;
+        }
+        if (prevValue !== null) {
+            var difference = Math.abs(prevValue - value);
+            var differenceSplit = Math.abs(prevValue - valWithSplit);
+            return difference < differenceSplit;
+        }
+        return false;
+    };
+    FactSplitAdjuster.prototype.isSplitAdjustableUnit = function (unit) {
+        return unit.toLowerCase().includes('share');
+    };
+    FactSplitAdjuster.prototype.isShareRatioUnit = function (unit) {
+        var unitLower = unit.toLowerCase();
+        return unitLower !== 'shares' && unitLower.includes('share'); // ex: USD/shares or USD-per-share
+    };
+    FactSplitAdjuster.prototype.getSortedFacts = function (propertyName, isAnnual) {
+        var _a, _b, _c;
+        var bucket = isAnnual ? this.factsAnnaulByYearByPropertyName : this.factsByYearQuarterByPropertyName;
+        var facts = Array.from((_b = (_a = bucket.get(propertyName)) === null || _a === void 0 ? void 0 : _a.values()) !== null && _b !== void 0 ? _b : []);
+        return (_c = facts.sort(function (a, b) { return (a.filed < b.filed ? -1 : 1); })) !== null && _c !== void 0 ? _c : [];
+    };
+    FactSplitAdjuster.prototype.resolveProperty = function (propertyName) {
+        if (this.resolvedProperties.has(propertyName))
+            return;
+        var factsAscQuarter = this.getSortedFacts(propertyName, false);
+        var factsAscAnnual = this.getSortedFacts(propertyName, true);
+        this.adjustValuesForSplits({ facts: factsAscQuarter });
+        this.adjustValuesForSplits({ facts: factsAscAnnual });
+        this.resolvedProperties.add(propertyName);
+    };
+    FactSplitAdjuster.prototype.get = function (propertyName, year, fiscalPeriod) {
+        var _a;
+        this.resolveProperty(propertyName);
+        var key = "".concat(year, "_").concat(fiscalPeriod);
+        var isAnnual = fiscalPeriod === 'FY';
+        var bucket = isAnnual ? this.factsAnnaulByYearByPropertyName : this.factsByYearQuarterByPropertyName;
+        var fact = (_a = bucket.get(propertyName)) === null || _a === void 0 ? void 0 : _a.get(key);
+        return fact === null || fact === void 0 ? void 0 : fact.value;
+    };
+    FactSplitAdjuster.prototype.forEach = function (callback) {
+        var _this = this;
+        this.factsByYearQuarterByPropertyName.forEach(function (factsByYearQuarter, propertyName) {
+            _this.resolveProperty(propertyName);
+            factsByYearQuarter.forEach(function (fact, key) {
+                var _a = key.split('_'), year = _a[0], fiscalPeriod = _a[1];
+                callback({ propertyName: propertyName, year: Number(year), fiscalPeriod: fiscalPeriod, value: Number(fact.value) });
+            });
+        });
+        this.factsAnnaulByYearByPropertyName.forEach(function (factsByYear, propertyName) {
+            _this.resolveProperty(propertyName);
+            factsByYear.forEach(function (fact, key) {
+                var _a = key.split('_'), year = _a[0], fiscalPeriod = _a[1];
+                callback({ propertyName: propertyName, year: Number(year), fiscalPeriod: fiscalPeriod, value: Number(fact.value) });
+            });
+        });
+    };
+    FactSplitAdjuster.prototype.adjustValuesForSplits = function (params) {
+        var _a, _b, _c, _d;
+        var facts = params.facts;
+        var splits = this.getSplitsAsc();
+        if (facts.length === 0 || splits.length === 0)
+            return;
+        var isShareRatio = this.isShareRatioUnit(facts[0].unit);
+        for (var splitIndex = splits.length - 1; splitIndex >= 0; splitIndex--) {
+            var split = splits[splitIndex];
+            for (var factIndex = facts.length - 1; factIndex >= 0; factIndex--) {
+                var fact = facts[factIndex];
+                var value = fact.value, filed = fact.filed;
+                var nextValue = (_b = (_a = facts[factIndex + 1]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null;
+                var prevValue = (_d = (_c = facts[factIndex - 1]) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : null;
+                var didApplySplit = this.didApplySplit({
+                    filed: filed,
+                    isShareRatio: isShareRatio,
+                    nextValue: nextValue,
+                    prevValue: prevValue,
+                    split: split,
+                    value: value,
+                });
+                if (didApplySplit) {
+                    continue;
+                }
+                if (isShareRatio) {
+                    fact.value /= split.value;
+                }
+                else {
+                    fact.value *= split.value;
+                }
+            }
+        }
+    };
+    return FactSplitAdjuster;
+}());
+exports.default = FactSplitAdjuster;

package/build/services/ReportBuilder/ReportBuilder.d.ts

@@ -0,0 +1,37 @@
+import { CompanyFactListData, FiscalPeriod, ReportRaw } from '../../types';
+import { SetReportDatesParams } from './FactFiscalCalculator';
+export interface FactItem {
+    cik: number | string;
+    end: string;
+    filed: string;
+    name: string;
+    unit: string;
+    value: number | string;
+    start?: string;
+    hasSegments?: boolean;
+    accn?: string;
+    form?: string;
+    fp?: string;
+    frame?: string;
+    fy?: number;
+    /** For XBRL reports only */
+    segments?: {
+        value: string;
+        dimension: string;
+    }[];
+    uuid?: string;
+}
+export interface FactItemWithFiscals extends FactItem {
+    fiscalPeriod: FiscalPeriod;
+    year: number;
+}
+export default class ReportBuilder {
+    private readonly factRecordBuilder;
+    createFacts(companyFacts: CompanyFactListData): {
+        facts: FactItem[];
+    };
+    buildReports(params: {
+        facts: FactItem[];
+        reportDates?: SetReportDatesParams[];
+    }): ReportRaw[];
+}