@infomaximum/widget-sdk 3.14.0

package/dist/index.js

@@ -0,0 +1,1008 @@
+'use strict';
+
+var localization = require('@infomaximum/localization');
+var baseFilter = require('@infomaximum/base-filter');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(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);
+};
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.EWidgetActionInputMode = void 0;
+(function (EWidgetActionInputMode) {
+    EWidgetActionInputMode["FROM_COLUMN"] = "FROM_COLUMN";
+    EWidgetActionInputMode["FROM_VARIABLE"] = "FROM_VARIABLE";
+    EWidgetActionInputMode["STATIC_LIST"] = "STATIC_LIST";
+    EWidgetActionInputMode["DYNAMIC_LIST"] = "DYNAMIC_LIST";
+    EWidgetActionInputMode["FORMULA"] = "FORMULA";
+    EWidgetActionInputMode["MANUALLY"] = "MANUALLY";
+})(exports.EWidgetActionInputMode || (exports.EWidgetActionInputMode = {}));
+var isActionValid = function (action, _a) {
+    var _b;
+    var scripts = _a.scripts, tables = _a.tables;
+    var currentScript = scripts.get((_b = action.scriptGuid) !== null && _b !== void 0 ? _b : "");
+    if (!currentScript) {
+        return false;
+    }
+    var actionInputsMap = new Map(action.inputs.map(function (input) { return [input.guid, input]; }));
+    if (actionInputsMap.size < currentScript.fieldsGuids.size) {
+        return false;
+    }
+    return __spreadArray([], __read(currentScript.fieldsGuids), false).every(function (guid) {
+        var actionInput = actionInputsMap.get(guid !== null && guid !== void 0 ? guid : "");
+        if (!actionInput) {
+            return false;
+        }
+        var value = actionInput.value;
+        if (value.mode === exports.EWidgetActionInputMode.FROM_VARIABLE && !value.guid) {
+            return false;
+        }
+        if (value.mode === exports.EWidgetActionInputMode.FORMULA && !value.formula) {
+            return false;
+        }
+        if (value.mode === exports.EWidgetActionInputMode.DYNAMIC_LIST && !value.formula) {
+            return false;
+        }
+        if (value.mode === exports.EWidgetActionInputMode.FROM_COLUMN &&
+            !tables.has(value.tableName)) {
+            return false;
+        }
+        return true;
+    });
+};
+
+exports.ESimpleDataType = void 0;
+(function (ESimpleDataType) {
+    ESimpleDataType["OTHER"] = "OTHER";
+    ESimpleDataType["DATE"] = "DATE";
+    ESimpleDataType["FLOAT"] = "FLOAT";
+    ESimpleDataType["DATETIME"] = "DATETIME";
+    ESimpleDataType["STRING"] = "STRING";
+    ESimpleDataType["INTEGER"] = "INTEGER";
+    ESimpleDataType["DATETIME64"] = "DATETIME64";
+})(exports.ESimpleDataType || (exports.ESimpleDataType = {}));
+
+var prepareValuesForSql = function (dataType, values) {
+    return dataType === exports.ESimpleDataType.INTEGER || dataType === exports.ESimpleDataType.FLOAT
+        ? values
+        : values.map(function (value) { return "'".concat(escapeSingularQuotes(escapeReverseSlash(value)), "'"); });
+};
+var escapeReverseSlash = function (formula) {
+    return formula.replaceAll(/\\/gm, "\\\\");
+};
+var escapeSingularQuotes = function (formula) {
+    return formula.replaceAll("'", "\\'");
+};
+
+var compact = function (items) { return ((items === null || items === void 0 ? void 0 : items.filter(Boolean)) || []); };
+var compactMap = function (items, f) { return compact(items === null || items === void 0 ? void 0 : items.map(f)); };
+var isNil = function (value) {
+    return value === null || value === undefined;
+};
+
+function mapVariablesToInputs(variables) {
+    return new Map(compactMap(__spreadArray([], __read(variables.values()), false), function (_a) {
+        var name = _a.name, dataType = _a.dataType, value = _a.value;
+        return !isNil(value) ? [name, { dataType: dataType, value: value }] : null;
+    }));
+}
+
+exports.ECalculatorFilterMethods = void 0;
+(function (ECalculatorFilterMethods) {
+    ECalculatorFilterMethods["EQUAL_TO"] = "EQUAL_TO";
+    ECalculatorFilterMethods["NOT_EQUAL_TO"] = "NOT_EQUAL_TO";
+    ECalculatorFilterMethods["GREATER_THAN"] = "GREATER_THAN";
+    ECalculatorFilterMethods["LESS_THAN"] = "LESS_THAN";
+    ECalculatorFilterMethods["GREATER_THAN_OR_EQUAL_TO"] = "GREATER_THAN_OR_EQUAL_TO";
+    ECalculatorFilterMethods["LESS_THAN_OR_EQUAL_TO"] = "LESS_THAN_OR_EQUAL_TO";
+    ECalculatorFilterMethods["STARTS_WITH"] = "STARTS_WITH";
+    ECalculatorFilterMethods["ENDS_WITH"] = "ENDS_WITH";
+    ECalculatorFilterMethods["CONTAINS"] = "CONTAINS";
+    ECalculatorFilterMethods["NOT_CONTAINS"] = "NOT_CONTAINS";
+    ECalculatorFilterMethods["IN_RANGE"] = "IN_RANGE";
+    ECalculatorFilterMethods["NOT_IN_RANGE"] = "NOT_IN_RANGE";
+    ECalculatorFilterMethods["INCLUDE"] = "INCLUDE";
+    ECalculatorFilterMethods["EXCLUDE"] = "EXCLUDE";
+    ECalculatorFilterMethods["NONEMPTY"] = "NONEMPTY";
+    ECalculatorFilterMethods["EMPTY"] = "EMPTY";
+})(exports.ECalculatorFilterMethods || (exports.ECalculatorFilterMethods = {}));
+
+var formulaFilterMethods = __assign(__assign({}, exports.ECalculatorFilterMethods), { LAST_TIME: "LAST_TIME" });
+exports.EProcessFilterNames = void 0;
+(function (EProcessFilterNames) {
+    /** Наличие события */
+    EProcessFilterNames["presenceOfEvent"] = "presenceOfEvent";
+    /** Количество повторов события */
+    EProcessFilterNames["repetitionOfEvent"] = "repetitionOfEvent";
+    /** Наличие перехода */
+    EProcessFilterNames["presenceOfTransition"] = "presenceOfTransition";
+    /** Длительность перехода */
+    EProcessFilterNames["durationOfTransition"] = "durationOfTransition";
+})(exports.EProcessFilterNames || (exports.EProcessFilterNames = {}));
+exports.EFormulaFilterFieldKeys = void 0;
+(function (EFormulaFilterFieldKeys) {
+    EFormulaFilterFieldKeys["date"] = "date";
+    EFormulaFilterFieldKeys["dateRange"] = "dateRange";
+    EFormulaFilterFieldKeys["duration"] = "duration";
+    EFormulaFilterFieldKeys["number"] = "number";
+    EFormulaFilterFieldKeys["numberRange"] = "numberRange";
+    EFormulaFilterFieldKeys["string"] = "string";
+    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
+    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
+    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
+})(exports.EFormulaFilterFieldKeys || (exports.EFormulaFilterFieldKeys = {}));
+
+exports.EFormatTypes = void 0;
+(function (EFormatTypes) {
+    /** Дата */
+    EFormatTypes["DATE"] = "DATE";
+    /** Число */
+    EFormatTypes["NUMBER"] = "NUMBER";
+    /** Месяц */
+    EFormatTypes["MONTH"] = "MONTH";
+    /** Дата и время */
+    EFormatTypes["DATETIME"] = "DATETIME";
+    /** Строка */
+    EFormatTypes["STRING"] = "STRING";
+    /** День недели */
+    EFormatTypes["DAY_OF_WEEK"] = "DAY_OF_WEEK";
+    /** Длительность */
+    EFormatTypes["DURATION"] = "DURATION";
+    /** Час */
+    EFormatTypes["HOUR"] = "HOUR";
+    /** Месяц и год */
+    EFormatTypes["MONTH_YEAR"] = "MONTH_YEAR";
+    /** Год */
+    EFormatTypes["YEAR"] = "YEAR";
+    /** Квартал */
+    EFormatTypes["QUARTER"] = "QUARTER";
+    /** Квартал и год */
+    EFormatTypes["QUARTER_YEAR"] = "QUARTER_YEAR";
+    /** День месяца */
+    EFormatTypes["DAY_OF_MONTH"] = "DAY_OF_MONTH";
+    /** Неделя */
+    EFormatTypes["WEEK"] = "WEEK";
+})(exports.EFormatTypes || (exports.EFormatTypes = {}));
+exports.EFormattingPresets = void 0;
+(function (EFormattingPresets) {
+    //Общая группа шаблонов
+    EFormattingPresets["AUTO"] = "AUTO";
+    EFormattingPresets["TUNE"] = "TUNE";
+    //Группа шаблонов для формата DATE
+    EFormattingPresets["DD/M/YYYY"] = "DD/M/YYYY";
+    EFormattingPresets["YYYY-MM-DD"] = "YYYY-MM-DD";
+    EFormattingPresets["DD MM YYYY"] = "DD MM YYYY";
+    EFormattingPresets["DD MMM YYYY"] = "DD MMM YYYY";
+    EFormattingPresets["MM.DD.YYYY"] = "MM.DD.YYYY";
+    EFormattingPresets["DD MMMM YYYY"] = "DD MMMM YYYY";
+    EFormattingPresets["DD/MM/YYYY"] = "DD/MM/YYYY";
+    EFormattingPresets["MMMM DD, YYYY"] = "MMMM DD, YYYY";
+    EFormattingPresets["DD.MM.YYYY"] = "DD.MM.YYYY";
+    EFormattingPresets["MM.DD.YYYY hh:mm a"] = "MM.DD.YYYY hh:mm a";
+    //Группа шаблонов для формата DATETIME
+    EFormattingPresets["DD/M/YYYY HH:mm"] = "DD/M/YYYY HH:mm";
+    EFormattingPresets["YYYY-MM-DD HH:mm"] = "YYYY-MM-DD HH:mm";
+    EFormattingPresets["YYYY-MM-DD HH:mm:ss"] = "YYYY-MM-DD HH:mm:ss";
+    EFormattingPresets["DD MM YYYY HH:mm"] = "DD MM YYYY HH:mm";
+    EFormattingPresets["DD MMM YYYY, HH:mm"] = "DD MMM YYYY, HH:mm";
+    EFormattingPresets["DD MMMM YYYY, HH:mm"] = "DD MMMM YYYY, HH:mm";
+    EFormattingPresets["DD.MM.YYYY, HH:mm:ss"] = "DD.MM.YYYY, HH:mm:ss";
+    EFormattingPresets["DD.MM.YYYY HH:mm:ss"] = "DD.MM.YYYY HH:mm:ss";
+    EFormattingPresets["DD/MM/YYYY HH:mm:ss"] = "DD/MM/YYYY HH:mm:ss";
+    //Группа шаблонов для формата DAY_OF_WEEK
+    EFormattingPresets["DD"] = "DD";
+    EFormattingPresets["D"] = "D";
+    EFormattingPresets["DDDD"] = "DDDD";
+    //Группа шаблонов для формата MONTH
+    EFormattingPresets["MMM"] = "MMM";
+    EFormattingPresets["MM"] = "MM";
+    EFormattingPresets["MMMM"] = "MMMM";
+    //Группа шаблонов для формата NUMBER
+    EFormattingPresets["k"] = "k";
+    EFormattingPresets["#,##x"] = "#,##x";
+    EFormattingPresets["#,##x.x"] = "#,##x.x";
+    EFormattingPresets["#,##x.xx"] = "#,##x.xx";
+    EFormattingPresets["x[%]"] = "x[%]";
+    EFormattingPresets["x.x[%]"] = "x.x[%]";
+    EFormattingPresets["[$]x"] = "[$]x";
+    EFormattingPresets["zx.xx[%]"] = "zx.xx[%]";
+    //Группа шаблонов для преобразования DURATION
+    EFormattingPresets["hh:mm:ss"] = "hh:mm:ss";
+    EFormattingPresets["dd:hh:mm:ss"] = "dd:hh:mm:ss";
+    EFormattingPresets["d"] = "d";
+    EFormattingPresets["h"] = "h";
+    EFormattingPresets["dk"] = "dk";
+    EFormattingPresets["hk"] = "hk";
+    EFormattingPresets["dd"] = "dd";
+    //Группа шаблонов для преобразования Час
+    EFormattingPresets["HH"] = "HH";
+    EFormattingPresets["hh a"] = "hh a";
+    //Группа шаблонов для преобразования Month_Year
+    EFormattingPresets["MMM, YYYY"] = "MMM, YYYY";
+    EFormattingPresets["MM.YYYY"] = "MM.YYYY";
+    EFormattingPresets["MMMM YYYY"] = "MMMM YYYY";
+    //Группа шаблонов для преобразования Quarter
+    EFormattingPresets["[Q]q"] = "[Q]q";
+    EFormattingPresets["R"] = "R";
+    //Группа шаблонов для преобразования Quarter_Year
+    EFormattingPresets["[Q]q[-]YYYY"] = "[Q]q[-]YYYY";
+    EFormattingPresets["R[-]YYYY"] = "R[-]YYYY";
+})(exports.EFormattingPresets || (exports.EFormattingPresets = {}));
+
+exports.ELastTimeUnit = void 0;
+(function (ELastTimeUnit) {
+    ELastTimeUnit["DAYS"] = "DAYS";
+    ELastTimeUnit["MONTHS"] = "MONTHS";
+    ELastTimeUnit["YEARS"] = "YEARS";
+})(exports.ELastTimeUnit || (exports.ELastTimeUnit = {}));
+exports.EDurationUnit = void 0;
+(function (EDurationUnit) {
+    EDurationUnit["DAYS"] = "DAYS";
+    EDurationUnit["HOURS"] = "HOURS";
+    EDurationUnit["MINUTES"] = "MINUTES";
+    EDurationUnit["SECONDS"] = "SECONDS";
+})(exports.EDurationUnit || (exports.EDurationUnit = {}));
+var isRangeFilteringMethod = function (filteringMethod) {
+    return filteringMethod === formulaFilterMethods.IN_RANGE ||
+        filteringMethod === formulaFilterMethods.NOT_IN_RANGE;
+};
+var convertDateToClickHouse = function (date, showTime) {
+    var twoDigitValue = function (value) { return ("0" + value).slice(-2); };
+    var year = date.getFullYear();
+    var month = twoDigitValue(date.getMonth() + 1);
+    var day = twoDigitValue(date.getDate());
+    var hours = twoDigitValue(date.getHours());
+    var minutes = twoDigitValue(date.getMinutes());
+    var seconds = twoDigitValue(date.getSeconds());
+    var timeString = "".concat(hours, ":").concat(minutes, ":").concat(seconds);
+    var dateString = "".concat(year, "-").concat(month, "-").concat(day);
+    return showTime ? "".concat(dateString, " ").concat(timeString) : "".concat(dateString);
+};
+var subtractDurationFromDate = function (date, value, unitTime) {
+    switch (unitTime) {
+        case exports.ELastTimeUnit.DAYS:
+            date.setDate(date.getDate() - value);
+            break;
+        case exports.ELastTimeUnit.MONTHS:
+            date.setMonth(date.getMonth() - value);
+            break;
+        case exports.ELastTimeUnit.YEARS:
+            date.setFullYear(date.getFullYear() - value);
+            break;
+    }
+    return date;
+};
+var convertToSeconds = function (value, rangeUnit) {
+    if (rangeUnit === undefined) {
+        return value;
+    }
+    switch (rangeUnit) {
+        case exports.EDurationUnit.DAYS:
+            return value * 86400;
+        case exports.EDurationUnit.HOURS:
+            return value * 3600;
+        case exports.EDurationUnit.MINUTES:
+            return value * 60;
+    }
+    return value;
+};
+// todo: покрыть тестами
+var getFormulaFilterValues = function (filterValue) {
+    var _a;
+    var format = filterValue.format, filteringMethod = filterValue.filteringMethod, formValues = filterValue.formValues, checkedValues = filterValue.checkedValues;
+    if (checkedValues && checkedValues.length) {
+        return checkedValues;
+    }
+    function stringifyNumbersRange(range) {
+        if (range === void 0) { range = [undefined, undefined]; }
+        return range.map(function (value, index) {
+            if (isNil(value)) {
+                return String(index === 0 ? -Infinity : Infinity);
+            }
+            return String(value);
+        });
+    }
+    function convertDurationRangeToSecond(range, rangeUnit) {
+        if (range === void 0) { range = [undefined, undefined]; }
+        return range.map(function (value, index) {
+            if (isNil(value)) {
+                return String(index === 0 ? -Infinity : Infinity);
+            }
+            return String(convertToSeconds(value, rangeUnit));
+        });
+    }
+    switch (format) {
+        case exports.EFormatTypes.DATE:
+        case exports.EFormatTypes.DATETIME:
+            var _b = formValues, _c = exports.EFormulaFilterFieldKeys.date, datePickerValue = _b[_c], _d = exports.EFormulaFilterFieldKeys.dateRange, rangePickerValue = _b[_d], _e = exports.EFormulaFilterFieldKeys.lastTimeValue, lastTimeValue = _b[_e], _f = exports.EFormulaFilterFieldKeys.lastTimeUnit, lastTimeUnit = _b[_f];
+            if (isRangeFilteringMethod(filteringMethod)) {
+                return compact(rangePickerValue);
+            }
+            if (filteringMethod === formulaFilterMethods.LAST_TIME) {
+                var showTime = format === exports.EFormatTypes.DATETIME;
+                return compact([
+                    convertDateToClickHouse(subtractDurationFromDate(new Date(), lastTimeValue !== null && lastTimeValue !== void 0 ? lastTimeValue : 0, lastTimeUnit), showTime),
+                    convertDateToClickHouse(new Date(), showTime),
+                ]);
+            }
+            return compact([datePickerValue]);
+        case exports.EFormatTypes.STRING:
+            return compact([(_a = formValues === null || formValues === void 0 ? void 0 : formValues[exports.EFormulaFilterFieldKeys.string]) !== null && _a !== void 0 ? _a : null]);
+        case exports.EFormatTypes.NUMBER:
+        case exports.EFormatTypes.YEAR:
+        case exports.EFormatTypes.DAY_OF_MONTH:
+        case exports.EFormatTypes.WEEK:
+        case exports.EFormatTypes.HOUR:
+            var _g = formValues, _h = exports.EFormulaFilterFieldKeys.number, number = _g[_h], _j = exports.EFormulaFilterFieldKeys.numberRange, numberRange = _g[_j];
+            return isRangeFilteringMethod(filteringMethod)
+                ? stringifyNumbersRange(numberRange)
+                : [String(number !== null && number !== void 0 ? number : 0)];
+        case exports.EFormatTypes.DURATION:
+            var _k = formValues, _l = exports.EFormulaFilterFieldKeys.duration, duration = _k[_l], _m = exports.EFormulaFilterFieldKeys.numberRange, durationRange = _k[_m], _o = exports.EFormulaFilterFieldKeys.durationUnit, durationUnit = _k[_o];
+            return isRangeFilteringMethod(filteringMethod)
+                ? convertDurationRangeToSecond(durationRange, durationUnit)
+                : [String(duration !== null && duration !== void 0 ? duration : 0)];
+    }
+    return [];
+};
+var mapFormulaFilterToCalculatorInput = function (filterValue) {
+    if (!filterValue) {
+        return null;
+    }
+    if (typeof filterValue === "string") {
+        return {
+            dataType: exports.ESimpleDataType.OTHER,
+            formula: filterValue,
+            values: ["1"],
+            filteringMethod: formulaFilterMethods.EQUAL_TO,
+        };
+    }
+    var formula = filterValue.formula, filteringMethod = filterValue.filteringMethod, dataType = filterValue.dataType;
+    return {
+        formula: formula,
+        filteringMethod: filteringMethod,
+        dataType: dataType,
+        values: getFormulaFilterValues(filterValue),
+    };
+};
+var mapFormulaFiltersToInputs = function (filters) {
+    return compactMap(filters, mapFormulaFilterToCalculatorInput);
+};
+
+// Типы, используемые в значениях элементов управления.
+exports.EWidgetFilterMode = void 0;
+(function (EWidgetFilterMode) {
+    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
+    EWidgetFilterMode["SINGLE"] = "SINGLE";
+    EWidgetFilterMode["MULTI"] = "MULTI";
+    EWidgetFilterMode["DISABLED"] = "DISABLED";
+})(exports.EWidgetFilterMode || (exports.EWidgetFilterMode = {}));
+exports.EColorMode = void 0;
+(function (EColorMode) {
+    EColorMode["FORMULA"] = "FORMULA";
+    EColorMode["BASE"] = "BASE";
+    EColorMode["GRADIENT"] = "GRADIENT";
+    EColorMode["AUTO"] = "AUTO";
+})(exports.EColorMode || (exports.EColorMode = {}));
+exports.EDisplayConditionMode = void 0;
+(function (EDisplayConditionMode) {
+    EDisplayConditionMode["DISABLED"] = "DISABLED";
+    EDisplayConditionMode["FORMULA"] = "FORMULA";
+    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
+})(exports.EDisplayConditionMode || (exports.EDisplayConditionMode = {}));
+
+function checkDisplayCondition(displayCondition, variables) {
+    var _a;
+    if ((displayCondition === null || displayCondition === void 0 ? void 0 : displayCondition.mode) === exports.EDisplayConditionMode.VARIABLE) {
+        var variableGuid = displayCondition.variableGuid, variableValue = displayCondition.variableValue;
+        if (variableGuid &&
+            variableValue &&
+            ((_a = variables.get(variableGuid)) === null || _a === void 0 ? void 0 : _a.value) !== variableValue) {
+            return false;
+        }
+    }
+    return true;
+}
+function getDisplayConditionFormula(displayCondition) {
+    if ((displayCondition === null || displayCondition === void 0 ? void 0 : displayCondition.mode) === exports.EDisplayConditionMode.FORMULA) {
+        return displayCondition.formula;
+    }
+}
+var replaceDisplayCondition = function (dimension, displayCondition) {
+    return isNil(displayCondition)
+        ? dimension
+        : __assign(__assign({}, dimension), { displayCondition: displayCondition });
+};
+
+function generateColumnFormula(tableName, columnName) {
+    return "\"".concat(tableName, "\".\"").concat(columnName, "\"");
+}
+function fillTemplateString(templateString, params) {
+    return templateString.replace(/\{(.*?)\}/g, function (_, key) { var _a; return (_a = params[key]) !== null && _a !== void 0 ? _a : ""; });
+}
+
+exports.EWidgetIndicatorType = void 0;
+(function (EWidgetIndicatorType) {
+    EWidgetIndicatorType["MEASURE"] = "MEASURE";
+    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
+    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
+    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
+    EWidgetIndicatorType["DIMENSION_HIERARCHY"] = "DIMENSION_HIERARCHY";
+    EWidgetIndicatorType["VARIABLE"] = "VARIABLE";
+    EWidgetIndicatorType["SORTING"] = "SORTING";
+    EWidgetIndicatorType["CUSTOM"] = "CUSTOM";
+})(exports.EWidgetIndicatorType || (exports.EWidgetIndicatorType = {}));
+exports.EDbType = void 0;
+(function (EDbType) {
+    EDbType["CH"] = "CH";
+    EDbType["HADOOP"] = "HADOOP";
+})(exports.EDbType || (exports.EDbType = {}));
+/** Режимы значения показателя (на основе чего генерируется формула) */
+exports.EWidgetIndicatorValueModes = void 0;
+(function (EWidgetIndicatorValueModes) {
+    /** Готовая формула (как правило, введенная пользователем через редактор формул) */
+    EWidgetIndicatorValueModes["FORMULA"] = "FORMULA";
+    /** Шаблон формулы, предоставляемый системой */
+    EWidgetIndicatorValueModes["TEMPLATE"] = "TEMPLATE";
+})(exports.EWidgetIndicatorValueModes || (exports.EWidgetIndicatorValueModes = {}));
+/** Режимы сортировки (на что ссылается сортировка) */
+exports.ESortingValueModes = void 0;
+(function (ESortingValueModes) {
+    /** Сортировка по формуле */
+    ESortingValueModes["FORMULA"] = "FORMULA";
+    /** Пункт "Количество" */
+    ESortingValueModes["QUANTITY"] = "QUANTITY";
+    /** @deprecated Для сортировки по иерархии используется режим DIMENSION_IN_WIDGET */
+    ESortingValueModes["HIERARCHY"] = "HIERARCHY";
+    /** Сортировка по мере виджета */
+    ESortingValueModes["MEASURE_IN_WIDGET"] = "MEASURE_IN_WIDGET";
+    /** Сортировка по разрезу(в т.ч. по иерархии) виджета */
+    ESortingValueModes["DIMENSION_IN_WIDGET"] = "DIMENSION_IN_WIDGET";
+    /** Сортировка по мере отчета */
+    ESortingValueModes["IN_DASHBOARD"] = "IN_DASHBOARD";
+    /** Сортировка по мере пространства */
+    ESortingValueModes["IN_WORKSPACE"] = "IN_WORKSPACE";
+})(exports.ESortingValueModes || (exports.ESortingValueModes = {}));
+/** Тип показателя */
+exports.EIndicatorType = void 0;
+(function (EIndicatorType) {
+    /** Показатели процесса */
+    EIndicatorType["PROCESS_MEASURE"] = "PROCESS_MEASURE";
+    /** Статичное значение */
+    EIndicatorType["STATIC"] = "STATIC";
+    /** Статический список */
+    EIndicatorType["STATIC_LIST"] = "STATIC_LIST";
+    /** Динамический список */
+    EIndicatorType["DYNAMIC_LIST"] = "DYNAMIC_LIST";
+    /** Разрез */
+    EIndicatorType["DIMENSION"] = "DIMENSION";
+    /** Мера */
+    EIndicatorType["MEASURE"] = "MEASURE";
+    /** Иерархия */
+    EIndicatorType["DYNAMIC_DIMENSION"] = "DYNAMIC_DIMENSION";
+    /** Пользовательская сортировка */
+    EIndicatorType["USER_SORTING"] = "USER_SORTING";
+})(exports.EIndicatorType || (exports.EIndicatorType = {}));
+function isHierarchy(indicator) {
+    return indicator.type === exports.EWidgetIndicatorType.DIMENSION_HIERARCHY;
+}
+
+var _a$3;
+exports.EDimensionTemplateNames = void 0;
+(function (EDimensionTemplateNames) {
+    EDimensionTemplateNames["dateTime"] = "dateTime";
+    EDimensionTemplateNames["date"] = "date";
+    EDimensionTemplateNames["year"] = "year";
+    EDimensionTemplateNames["yearAndQuarter"] = "yearAndQuarter";
+    EDimensionTemplateNames["quarter"] = "quarter";
+    EDimensionTemplateNames["yearAndMonth"] = "yearAndMonth";
+    EDimensionTemplateNames["dayOfMonth"] = "dayOfMonth";
+    EDimensionTemplateNames["month"] = "month";
+    EDimensionTemplateNames["week"] = "week";
+    EDimensionTemplateNames["dayOfWeek"] = "dayOfWeek";
+    EDimensionTemplateNames["hour"] = "hour";
+})(exports.EDimensionTemplateNames || (exports.EDimensionTemplateNames = {}));
+var dimensionTemplateFormulas = (_a$3 = {},
+    _a$3[exports.EDimensionTemplateNames.dateTime] = "toDateTime({columnFormula})",
+    _a$3[exports.EDimensionTemplateNames.date] = "toDate({columnFormula})",
+    _a$3[exports.EDimensionTemplateNames.year] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.yearAndQuarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}) * 10 + toQuarter({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.quarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toQuarter({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.yearAndMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYYYYMM({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.month] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toMonth({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.dayOfMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfMonth({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.week] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toWeek({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.dayOfWeek] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfWeek({columnFormula}))",
+    _a$3[exports.EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
+    _a$3);
+function getDimensionFormula(_a) {
+    var value = _a.value;
+    if (!value) {
+        return "";
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.FORMULA) {
+        return value.formula;
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.TEMPLATE) {
+        var templateName = value.templateName, tableName = value.tableName, columnName = value.columnName;
+        var templateFormula = dimensionTemplateFormulas[templateName];
+        if (!templateFormula) {
+            return "";
+        }
+        return fillTemplateString(templateFormula, {
+            columnFormula: generateColumnFormula(tableName, columnName),
+        });
+    }
+    return "";
+}
+
+var _a$2;
+exports.EMeasureTemplateNames = void 0;
+(function (EMeasureTemplateNames) {
+    EMeasureTemplateNames["avg"] = "avg";
+    EMeasureTemplateNames["median"] = "median";
+    EMeasureTemplateNames["count"] = "count";
+    EMeasureTemplateNames["countDistinct"] = "countDistinct";
+    EMeasureTemplateNames["min"] = "min";
+    EMeasureTemplateNames["max"] = "max";
+    EMeasureTemplateNames["sum"] = "sum";
+})(exports.EMeasureTemplateNames || (exports.EMeasureTemplateNames = {}));
+var measureTemplateFormulas = (_a$2 = {},
+    _a$2[exports.EMeasureTemplateNames.avg] = "avg({columnFormula})",
+    _a$2[exports.EMeasureTemplateNames.count] = "count({columnFormula})",
+    _a$2[exports.EMeasureTemplateNames.countDistinct] = "count(distinct {columnFormula})",
+    _a$2[exports.EMeasureTemplateNames.median] = "medianExact({columnFormula})",
+    _a$2[exports.EMeasureTemplateNames.min] = "min({columnFormula})",
+    _a$2[exports.EMeasureTemplateNames.max] = "max({columnFormula})",
+    _a$2[exports.EMeasureTemplateNames.sum] = "sum({columnFormula})",
+    _a$2);
+function getMeasureFormula(_a) {
+    var value = _a.value;
+    if (!value) {
+        return "";
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.FORMULA) {
+        return value.formula;
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.TEMPLATE) {
+        var templateName = value.templateName, tableName = value.tableName, columnName = value.columnName;
+        var templateFormula = measureTemplateFormulas[templateName];
+        if (!templateFormula) {
+            return "";
+        }
+        return fillTemplateString(templateFormula, {
+            columnFormula: generateColumnFormula(tableName, columnName),
+        });
+    }
+    return "";
+}
+
+var _a$1;
+exports.EEventMeasureTemplateNames = void 0;
+(function (EEventMeasureTemplateNames) {
+    EEventMeasureTemplateNames["count"] = "count";
+    EEventMeasureTemplateNames["reworksCount"] = "reworksCount";
+})(exports.EEventMeasureTemplateNames || (exports.EEventMeasureTemplateNames = {}));
+var eventMeasureTemplateFormulas = (_a$1 = {},
+    _a$1[exports.EEventMeasureTemplateNames.count] = "count()",
+    _a$1[exports.EEventMeasureTemplateNames.reworksCount] = "count() - uniqExact({caseCaseIdFormula})",
+    _a$1);
+function getEventMeasureFormula(_a, process) {
+    var value = _a.value;
+    if (!value) {
+        return "";
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.FORMULA) {
+        return value.formula;
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.TEMPLATE) {
+        var templateFormula = eventMeasureTemplateFormulas[value.templateName];
+        return templateFormula && fillTemplateString(templateFormula, process);
+    }
+    return "";
+}
+
+var _a;
+exports.ETransitionMeasureTemplateNames = void 0;
+(function (ETransitionMeasureTemplateNames) {
+    ETransitionMeasureTemplateNames["count"] = "count";
+    ETransitionMeasureTemplateNames["medianTime"] = "medianTime";
+})(exports.ETransitionMeasureTemplateNames || (exports.ETransitionMeasureTemplateNames = {}));
+var transitionMeasureTemplateFormulas = (_a = {},
+    _a[exports.ETransitionMeasureTemplateNames.count] = "count()",
+    _a[exports.ETransitionMeasureTemplateNames.medianTime] = "medianExact(date_diff(second, begin({eventTimeFormula}), end({eventTimeFormula})))",
+    _a);
+function getTransitionMeasureFormula(_a, process) {
+    var value = _a.value;
+    if (!value) {
+        return "";
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.FORMULA) {
+        return value.formula;
+    }
+    if (value.mode === exports.EWidgetIndicatorValueModes.TEMPLATE) {
+        var templateFormula = transitionMeasureTemplateFormulas[value.templateName];
+        return templateFormula && fillTemplateString(templateFormula, process);
+    }
+    return "";
+}
+
+function mapMeasureToInput(measure, variables, addFormulas) {
+    if (addFormulas === void 0) { addFormulas = function () { return new Map(); }; }
+    var mainFormula = getMeasureFormula(measure);
+    if (!mainFormula) {
+        return null;
+    }
+    if (!checkDisplayCondition(measure.displayCondition, variables)) {
+        return null;
+    }
+    return {
+        alias: String(measure.id),
+        mainFormula: mainFormula,
+        displayConditionFormula: getDisplayConditionFormula(measure.displayCondition),
+        additionalFormulas: addFormulas(measure),
+    };
+}
+/** Конвертировать меры виджета во входы для вычислителя */
+function mapMeasuresToInputs(measures, variables, addFormulas) {
+    return compactMap(measures, function (measure) {
+        return mapMeasureToInput(measure, variables, addFormulas);
+    });
+}
+
+function mapDimensionToInput(dimension, variables) {
+    var formula = getDimensionFormula(dimension);
+    if (!formula) {
+        return null;
+    }
+    if (!checkDisplayCondition(dimension.displayCondition, variables)) {
+        return null;
+    }
+    return {
+        alias: String(dimension.id),
+        formula: formula,
+        hideEmpty: dimension.hideEmptyValues,
+        displayConditionFormula: getDisplayConditionFormula(dimension.displayCondition),
+    };
+}
+/** Конвертировать разрезы виджета во входы для вычислителя */
+function mapDimensionsToInputs(dimensions, variables) {
+    return compactMap(dimensions, function (dimension) {
+        return mapDimensionToInput(dimension, variables);
+    });
+}
+
+function mapTransitionMeasureToInput(indicator, process, variables, addFormulas) {
+    if (addFormulas === void 0) { addFormulas = function () { return new Map(); }; }
+    var mainFormula = getTransitionMeasureFormula(indicator, process);
+    if (!mainFormula) {
+        return null;
+    }
+    if (!checkDisplayCondition(indicator.displayCondition, variables)) {
+        return null;
+    }
+    return {
+        alias: String(indicator.id),
+        mainFormula: mainFormula,
+        displayConditionFormula: getDisplayConditionFormula(indicator.displayCondition),
+        additionalFormulas: addFormulas(indicator),
+    };
+}
+/** Конвертировать процессные показатели виджета во входы для вычислителя */
+function mapTransitionMeasuresToInputs(indicators, process, variables, addFormulas) {
+    return compactMap(indicators, function (indicator) {
+        return mapTransitionMeasureToInput(indicator, process, variables, addFormulas);
+    });
+}
+
+function mapEventMeasureToInput(indicator, process, variables, addFormulas) {
+    if (addFormulas === void 0) { addFormulas = function () { return new Map(); }; }
+    var mainFormula = getEventMeasureFormula(indicator, process);
+    if (!mainFormula) {
+        return null;
+    }
+    if (!checkDisplayCondition(indicator.displayCondition, variables)) {
+        return null;
+    }
+    return {
+        alias: String(indicator.id),
+        mainFormula: mainFormula,
+        displayConditionFormula: getDisplayConditionFormula(indicator.displayCondition),
+        additionalFormulas: addFormulas(indicator),
+    };
+}
+/** Конвертировать показатели процессных событий виджета во входы для вычислителя */
+function mapEventMeasuresToInputs(indicators, process, variables, addFormulas) {
+    return compactMap(indicators, function (indicator) {
+        return mapEventMeasureToInput(indicator, process, variables, addFormulas);
+    });
+}
+
+/**
+ * Преобразовать объекты сортировок из settings виджета в sortOrders вычислителя
+ * @param sortingIndicators объекты сортировок из settings виджета
+ * @param dimensionsInOriginalOrder разрезы виджета (конкретный разрез будет браться по индексу)
+ * @param measuresInOriginalOrder меры виджета (конкретная мера будет браться по индексу)
+ * @returns
+ */
+function mapSortingToInputs(sortingIndicators, dimensionsInOriginalOrder, measuresInOriginalOrder) {
+    if (sortingIndicators === void 0) { sortingIndicators = []; }
+    if (dimensionsInOriginalOrder === void 0) { dimensionsInOriginalOrder = []; }
+    if (measuresInOriginalOrder === void 0) { measuresInOriginalOrder = []; }
+    return compactMap(sortingIndicators, function (_a) {
+        var value = _a.value, direction = _a.direction;
+        if (value.mode === exports.ESortingValueModes.FORMULA ||
+            value.mode === exports.ESortingValueModes.QUANTITY ||
+            value.mode === exports.ESortingValueModes.IN_DASHBOARD ||
+            value.mode === exports.ESortingValueModes.IN_WORKSPACE) {
+            return value.formula ? { formula: value.formula, direction: direction } : undefined;
+        }
+        if (value.mode === exports.ESortingValueModes.DIMENSION_IN_WIDGET ||
+            value.mode === exports.ESortingValueModes.HIERARCHY) {
+            var dimension = dimensionsInOriginalOrder[value.index];
+            return (dimension && { formula: getDimensionFormula(dimension), direction: direction });
+        }
+        if (value.mode === exports.ESortingValueModes.MEASURE_IN_WIDGET) {
+            var measure = measuresInOriginalOrder[value.index];
+            return measure && { formula: getMeasureFormula(measure), direction: direction };
+        }
+    });
+}
+
+/**
+ * Выбрать активный разрез иерархии на основе активных фильтров.
+ * Принцип:
+ * Если к разрезу иерархии применяется INCLUDE-фильтр с одним значением - выбираем следующий за ним разрез
+ * Если к разрезу иерархии применяется INCLUDE-фильтр с несколькими значениями - выбираем данный разрез
+ */
+function selectDimensionFromHierarchy(_a, filters) {
+    var dimensions = _a.dimensions;
+    var _loop_1 = function (i) {
+        var dimension = dimensions[i];
+        // todo: widgets - возможно, стоит использовать Map фильтров для быстрого поиска
+        var matchedFilter = filters.find(function (_a) {
+            var formula = _a.formula, filteringMethod = _a.filteringMethod;
+            return formula === getDimensionFormula(dimension) &&
+                filteringMethod === exports.ECalculatorFilterMethods.INCLUDE;
+        });
+        if (!matchedFilter) {
+            return "continue";
+        }
+        var selectionIndex = matchedFilter.values.length > 1
+            ? i
+            : Math.min(i + 1, dimensions.length - 1);
+        return { value: dimensions[selectionIndex] };
+    };
+    for (var i = dimensions.length - 1; i >= 0; i--) {
+        var state_1 = _loop_1(i);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return dimensions[0];
+}
+
+var replaceHierarchiesWithDimensions = function (dimensions, filters) {
+    return compactMap(dimensions, function (indicator) {
+        if (isHierarchy(indicator)) {
+            var selectedDimension = selectDimensionFromHierarchy(indicator, filters);
+            return (selectedDimension &&
+                replaceDisplayCondition(selectedDimension, indicator.displayCondition));
+        }
+        return indicator;
+    });
+};
+
+function bindContentWithIndicator(outputs, indicator) {
+    var indicatorContent = outputs.get(String(indicator.id));
+    return indicatorContent && __assign(__assign({}, indicatorContent), { indicator: indicator });
+}
+/**
+ * Связать показатели с вычисленным для них контентом
+ * @param outputs Map выходов вычислителя по идентификатору показателя
+ * @param indicators массив показателей из settings виджета
+ * Массив объектов, каждый из которых содержит показатель и его контент
+ */
+function bindContentsWithIndicators(outputs, indicators) {
+    return compactMap(indicators, function (indicator) {
+        return bindContentWithIndicator(outputs, indicator);
+    });
+}
+
+exports.EControlType = void 0;
+(function (EControlType) {
+    EControlType["inputNumber"] = "inputNumber";
+    EControlType["switch"] = "switch";
+    EControlType["input"] = "input";
+    EControlType["formattingTemplate"] = "formattingTemplate";
+    EControlType["radioIconGroup"] = "radioIconGroup";
+    EControlType["select"] = "select";
+    EControlType["tagSet"] = "tagSet";
+    EControlType["formula"] = "formula";
+    EControlType["typedFormula"] = "typedFormula";
+    EControlType["inputRange"] = "inputRange";
+    EControlType["colorPicker"] = "colorPicker";
+    /**  @deprecated - удалится в ближайшее время */
+    EControlType["filterMode"] = "filterMode";
+    EControlType["displayCondition"] = "displayCondition";
+    EControlType["eventsColor"] = "eventsColor";
+    EControlType["inputMarkdown"] = "inputMarkdown";
+})(exports.EControlType || (exports.EControlType = {}));
+
+exports.ESortDirection = void 0;
+(function (ESortDirection) {
+    ESortDirection["descend"] = "DESC";
+    ESortDirection["ascend"] = "ASC";
+    ESortDirection["ASC"] = "ascend";
+    ESortDirection["DESC"] = "descend";
+})(exports.ESortDirection || (exports.ESortDirection = {}));
+
+var findFilterByFormula = function (filters, formula) {
+    var _a;
+    return ((_a = filters.find(function (filter) {
+        return filter.formula === formula;
+    })) !== null && _a !== void 0 ? _a : null);
+};
+var getSelectionItemValues = function (value, filterMode, currentSelectionItemValues) {
+    var selectionItemValues = new Set(currentSelectionItemValues);
+    if (selectionItemValues.has(value)) {
+        selectionItemValues.delete(value);
+    }
+    else if (filterMode === exports.EWidgetFilterMode.SINGLE) {
+        selectionItemValues = new Set([value]);
+    }
+    else {
+        selectionItemValues.add(value);
+    }
+    return selectionItemValues;
+};
+var updateDefaultModeSelection = function (selection, formula, value, filters) {
+    var _a, _b;
+    var selectionItemSaved = (_a = selection.get(formula)) === null || _a === void 0 ? void 0 : _a.replacedFilter;
+    if (selection.size && !selection.get(formula)) {
+        selection.clear();
+    }
+    var selectionItemValues = getSelectionItemValues(value, exports.EWidgetFilterMode.DEFAULT, (_b = selection.get(formula)) === null || _b === void 0 ? void 0 : _b.values);
+    var savedFilters = findFilterByFormula(filters, formula);
+    if (!selectionItemValues.size) {
+        selection.clear();
+        return;
+    }
+    selection.set(formula, {
+        values: selectionItemValues,
+        replacedFilter: selection.size ? selectionItemSaved !== null && selectionItemSaved !== void 0 ? selectionItemSaved : null : savedFilters,
+    });
+};
+var updateSingleModeSelection = function (selection, formula, value) {
+    var _a;
+    var selectionItemValues = getSelectionItemValues(value, exports.EWidgetFilterMode.SINGLE, (_a = selection.get(formula)) === null || _a === void 0 ? void 0 : _a.values);
+    if (!selectionItemValues.size) {
+        selection.delete(formula);
+        return;
+    }
+    selection.set(formula, {
+        values: selectionItemValues,
+        replacedFilter: null,
+    });
+};
+var updateMultiModeSelection = function (selection, formula, value) {
+    var _a;
+    var selectionItemValues = getSelectionItemValues(value, exports.EWidgetFilterMode.MULTI, (_a = selection.get(formula)) === null || _a === void 0 ? void 0 : _a.values);
+    if (!selectionItemValues.size) {
+        selection.delete(formula);
+        return;
+    }
+    selection.set(formula, {
+        values: selectionItemValues,
+        replacedFilter: null,
+    });
+};
+var replaceFiltersBySelection = function (filters, selection) {
+    return filters.reduce(function (acc, filter) {
+        var _a;
+        var calculatorFilter = selection.has(filter.formula)
+            ? (_a = selection.get(filter.formula)) === null || _a === void 0 ? void 0 : _a.replacedFilter
+            : filter;
+        if (!calculatorFilter) {
+            return acc;
+        }
+        acc.push(calculatorFilter);
+        return acc;
+    }, []);
+};
+
+Object.defineProperty(exports, 'ELanguages', {
+    enumerable: true,
+    get: function () { return localization.ELanguages; }
+});
+Object.defineProperty(exports, 'EFilteringMethodValues', {
+    enumerable: true,
+    get: function () { return baseFilter.EFilteringMethodValues; }
+});
+exports.bindContentWithIndicator = bindContentWithIndicator;
+exports.bindContentsWithIndicators = bindContentsWithIndicators;
+exports.checkDisplayCondition = checkDisplayCondition;
+exports.dimensionTemplateFormulas = dimensionTemplateFormulas;
+exports.eventMeasureTemplateFormulas = eventMeasureTemplateFormulas;
+exports.fillTemplateString = fillTemplateString;
+exports.formulaFilterMethods = formulaFilterMethods;
+exports.generateColumnFormula = generateColumnFormula;
+exports.getDimensionFormula = getDimensionFormula;
+exports.getDisplayConditionFormula = getDisplayConditionFormula;
+exports.getEventMeasureFormula = getEventMeasureFormula;
+exports.getMeasureFormula = getMeasureFormula;
+exports.getTransitionMeasureFormula = getTransitionMeasureFormula;
+exports.isActionValid = isActionValid;
+exports.isHierarchy = isHierarchy;
+exports.mapDimensionsToInputs = mapDimensionsToInputs;
+exports.mapEventMeasuresToInputs = mapEventMeasuresToInputs;
+exports.mapFormulaFilterToCalculatorInput = mapFormulaFilterToCalculatorInput;
+exports.mapFormulaFiltersToInputs = mapFormulaFiltersToInputs;
+exports.mapMeasuresToInputs = mapMeasuresToInputs;
+exports.mapSortingToInputs = mapSortingToInputs;
+exports.mapTransitionMeasuresToInputs = mapTransitionMeasuresToInputs;
+exports.mapVariablesToInputs = mapVariablesToInputs;
+exports.measureTemplateFormulas = measureTemplateFormulas;
+exports.prepareValuesForSql = prepareValuesForSql;
+exports.replaceDisplayCondition = replaceDisplayCondition;
+exports.replaceFiltersBySelection = replaceFiltersBySelection;
+exports.replaceHierarchiesWithDimensions = replaceHierarchiesWithDimensions;
+exports.selectDimensionFromHierarchy = selectDimensionFromHierarchy;
+exports.transitionMeasureTemplateFormulas = transitionMeasureTemplateFormulas;
+exports.updateDefaultModeSelection = updateDefaultModeSelection;
+exports.updateMultiModeSelection = updateMultiModeSelection;
+exports.updateSingleModeSelection = updateSingleModeSelection;