@infomaximum/widget-sdk 6.0.0-wefi344-2 → 7.0.0-2

package/dist/index.js

@@ -3,6 +3,40 @@
 var localization$1 = require('@infomaximum/localization');
 var baseFilter = require('@infomaximum/base-filter');
 
+/** Массив версий в строгом порядке, по которому последовательно выполняется миграция */
+var apiVersions = [
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7", // Версии от 7 и старше пока не удаляем [BI-15416]
+    "8",
+    "9",
+    "10",
+    "10.1",
+    "10.2",
+    "10.3", // 241223
+    "11",
+    "12",
+    "13", // 2503
+    "13.1", // 250314
+    "14",
+    "15", // Для версии системы 2505
+    "15.1", // Для версии системы 250609
+    "15.2", // Для версии системы 250614
+    "16", // Для версии системы 2507
+    "16.1", // Для версии системы 250703
+    "16.2", // Для версии системы 250709
+    "17", // 2508
+];
+/**
+ * Актуальная версия settings, с которой работает система.
+ * Используется единая версия для settings виджетов и показателей.
+ */
+var apiVersion = apiVersions.at(-1);
+
 exports.EWidgetActionInputMethod = void 0;
 (function (EWidgetActionInputMethod) {
     EWidgetActionInputMethod["COLUMN"] = "COLUMN";
@@ -23,6 +57,7 @@ exports.EActionTypes = void 0;
     EActionTypes["UPDATE_VARIABLE"] = "UPDATE_VARIABLE";
     EActionTypes["EXECUTE_SCRIPT"] = "EXECUTE_SCRIPT";
     EActionTypes["OPEN_VIEW"] = "OPEN_VIEW";
+    EActionTypes["DRILL_DOWN"] = "DRILL_DOWN";
 })(exports.EActionTypes || (exports.EActionTypes = {}));
 exports.EViewMode = void 0;
 (function (EViewMode) {
@@ -65,6 +100,46 @@ exports.EActionButtonsTypes = void 0;
     EActionButtonsTypes["SECONDARY"] = "primary-outlined";
 })(exports.EActionButtonsTypes || (exports.EActionButtonsTypes = {}));
 
+/**
+ * Глобальный счетчик для генерации ID.
+ *
+ * @todo
+ * В будущем можно заменить единый счетчик на изолированные счетчики в разных контекстах.
+ */
+var id = 1;
+var AutoIdentifiedArrayItemSchema = function (z) {
+    return z.object({
+        /**
+         * Идентификатор, добавляемый системой "на лету" для удобства разработки, не сохраняется на сервер.
+         * Гарантируется уникальность id в пределах settings виджета.
+         */
+        id: z
+            .number()
+            .default(-1)
+            .transform(function (currentId) { return (currentId === -1 ? id++ : currentId); }),
+    });
+};
+var BaseWidgetSettingsSchema = function (z) {
+    return z.object({
+        title: z.string().default(""),
+        titleSize: themed(z.number().default(14), function (theme) { return theme.widgets.titleSize; }),
+        titleColor: themed(ColorSchema(z), function (theme) { return theme.widgets.titleColor; }),
+        titleWeight: themed(z.enum(exports.EFontWeight).default(exports.EFontWeight.NORMAL), function (theme) { return theme.widgets.titleWeight; }),
+        stateName: z.string().nullable().default(null),
+        showMarkdown: z.boolean().default(false),
+        markdownMeasures: z.array(MarkdownMeasureSchema(z)).default([]),
+        markdownText: z.string().default(""),
+        markdownTextSize: z.number().default(14),
+        filters: z.array(SettingsFilterSchema(z)).default([]),
+        filterMode: z.enum(exports.EWidgetFilterMode).default(exports.EWidgetFilterMode.DEFAULT),
+        ignoreFilters: z.boolean().default(false),
+        sorting: z.array(WidgetSortingIndicatorSchema(z)).default([]),
+        actionButtons: z.array(ActionButtonSchema(z)).default([]),
+        paddings: themed(z.union([z.number(), z.string()]).default(8), function (theme) { return theme.widgets.paddings; }),
+        viewTheme: z.boolean().default(false),
+    });
+};
+
 exports.ESimpleDataType = void 0;
 (function (ESimpleDataType) {
     ESimpleDataType["OTHER"] = "OTHER";
@@ -77,247 +152,6 @@ exports.ESimpleDataType = void 0;
     ESimpleDataType["BOOLEAN"] = "BOOLEAN";
 })(exports.ESimpleDataType || (exports.ESimpleDataType = {}));
 
-var prepareValuesForSql = function (simpleType, values) {
-    return simpleType === exports.ESimpleDataType.INTEGER ||
-        simpleType === exports.ESimpleDataType.FLOAT ||
-        simpleType === exports.ESimpleDataType.BOOLEAN
-        ? values
-        : values.map(function (value) {
-            return value === null ? null : "'".concat(escapeSingularQuotes$1(escapeReverseSlash(value)), "'");
-        });
-};
-var escapeReverseSlash = function (formula) {
-    return formula.replaceAll(/\\/gm, "\\\\");
-};
-var escapeSingularQuotes$1 = function (formula) {
-    return formula.replaceAll("'", "\\'");
-};
-
-/******************************************************************************
-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 __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __makeTemplateObject(cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-}
-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.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["numberRange"] = "numberRange";
-    EFormulaFilterFieldKeys["string"] = "string";
-    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
-    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
-    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
-})(exports.EFormulaFilterFieldKeys || (exports.EFormulaFilterFieldKeys = {}));
-var isFormulaFilterValue = function (value) {
-    return "filteringMethod" in value;
-};
-
-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 memoize(fn) {
-    var cache = new Map();
-    return function (arg) {
-        if (cache.has(arg)) {
-            return cache.get(arg);
-        }
-        var result = fn(arg);
-        cache.set(arg, result);
-        return result;
-    };
-}
-
-exports.EClickHouseBaseTypes = void 0;
-(function (EClickHouseBaseTypes) {
-    // DATE
-    EClickHouseBaseTypes["Date"] = "Date";
-    EClickHouseBaseTypes["Date32"] = "Date32";
-    // DATETIME
-    EClickHouseBaseTypes["DateTime"] = "DateTime";
-    EClickHouseBaseTypes["DateTime32"] = "DateTime32";
-    // DATETIME64
-    EClickHouseBaseTypes["DateTime64"] = "DateTime64";
-    // STRING
-    EClickHouseBaseTypes["FixedString"] = "FixedString";
-    EClickHouseBaseTypes["String"] = "String";
-    // FLOAT
-    EClickHouseBaseTypes["Decimal"] = "Decimal";
-    EClickHouseBaseTypes["Decimal32"] = "Decimal32";
-    EClickHouseBaseTypes["Decimal64"] = "Decimal64";
-    EClickHouseBaseTypes["Decimal128"] = "Decimal128";
-    EClickHouseBaseTypes["Decimal256"] = "Decimal256";
-    EClickHouseBaseTypes["Float32"] = "Float32";
-    EClickHouseBaseTypes["Float64"] = "Float64";
-    // INTEGER
-    EClickHouseBaseTypes["Int8"] = "Int8";
-    EClickHouseBaseTypes["Int16"] = "Int16";
-    EClickHouseBaseTypes["Int32"] = "Int32";
-    EClickHouseBaseTypes["Int64"] = "Int64";
-    EClickHouseBaseTypes["Int128"] = "Int128";
-    EClickHouseBaseTypes["Int256"] = "Int256";
-    EClickHouseBaseTypes["UInt8"] = "UInt8";
-    EClickHouseBaseTypes["UInt16"] = "UInt16";
-    EClickHouseBaseTypes["UInt32"] = "UInt32";
-    EClickHouseBaseTypes["UInt64"] = "UInt64";
-    EClickHouseBaseTypes["UInt128"] = "UInt128";
-    EClickHouseBaseTypes["UInt256"] = "UInt256";
-    // BOOLEAN
-    EClickHouseBaseTypes["Bool"] = "Bool";
-})(exports.EClickHouseBaseTypes || (exports.EClickHouseBaseTypes = {}));
-var stringTypes = ["String", "FixedString"];
-var parseClickHouseType = memoize(function (type) {
-    if (isNil(type)) {
-        return {
-            simpleBaseType: exports.ESimpleDataType.OTHER,
-            dbBaseDataType: undefined,
-            containers: [],
-            simpleType: exports.ESimpleDataType.OTHER,
-        };
-    }
-    var _a = extractInnerType(type), containers = _a.containers, dbBaseDataType = _a.dbBaseDataType;
-    if (!dbBaseDataType) {
-        throw new Error("Invalid ClickHouse type: ".concat(type));
-    }
-    return {
-        dbBaseDataType: dbBaseDataType,
-        simpleBaseType: simplifyBaseType(dbBaseDataType),
-        containers: containers,
-        get simpleType() {
-            return containers.includes("Array") ? exports.ESimpleDataType.OTHER : this.simpleBaseType;
-        },
-    };
-});
-/** 'A(B(C))' -> ['A', 'B', 'C'] */
-var splitByBrackets = function (input) { return input.split(/[\(\)]/).filter(Boolean); };
-/**
- * Отделить внутренний тип от оберток.
- * Не поддерживаются обертки Tuple и LowCardinality.
- */
-var extractInnerType = function (type) {
-    var tokens = splitByBrackets(type);
-    // Удаление параметров типа.
-    if (tokens.length > 0 && isTypeParameters(tokens.at(-1))) {
-        tokens.pop();
-    }
-    var dbBaseDataType = tokens.pop();
-    return { containers: tokens, dbBaseDataType: dbBaseDataType };
-};
-var simplifyBaseType = function (dbBaseType) {
-    var isSourceTypeStartsWith = function (prefix) { return dbBaseType.startsWith(prefix); };
-    if (isSourceTypeStartsWith("Int") || isSourceTypeStartsWith("UInt")) {
-        return exports.ESimpleDataType.INTEGER;
-    }
-    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
-        return exports.ESimpleDataType.FLOAT;
-    }
-    if (stringTypes.some(isSourceTypeStartsWith)) {
-        return exports.ESimpleDataType.STRING;
-    }
-    if (isSourceTypeStartsWith("DateTime64")) {
-        return exports.ESimpleDataType.DATETIME64;
-    }
-    if (isSourceTypeStartsWith("DateTime")) {
-        return exports.ESimpleDataType.DATETIME;
-    }
-    if (isSourceTypeStartsWith("Date")) {
-        return exports.ESimpleDataType.DATE;
-    }
-    if (isSourceTypeStartsWith("Bool")) {
-        return exports.ESimpleDataType.BOOLEAN;
-    }
-    return exports.ESimpleDataType.OTHER;
-};
-/**
- * - `3` -> true
- * - `3, 'Europe/Moscow'` -> true
- * - `3, Europe/Moscow` -> false
- *
- * Пример типа с параметрами: `DateTime64(3, 'Europe/Moscow')`
- */
-var isTypeParameters = function (stringifiedParameters) {
-    return stringifiedParameters.split(", ").some(function (p) { return !Number.isNaN(Number(p)) || p.startsWith("'"); });
-};
-
 exports.EFormatTypes = void 0;
 (function (EFormatTypes) {
     /** Дата */
@@ -611,7 +445,1052 @@ var formattingConfig = {
     },
 };
 
-var _a$4;
+/******************************************************************************
+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 __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+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 __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+}
+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.EWidgetIndicatorType = void 0;
+(function (EWidgetIndicatorType) {
+    EWidgetIndicatorType["MEASURE"] = "MEASURE";
+    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
+    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
+    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
+    EWidgetIndicatorType["SORTING"] = "SORTING";
+})(exports.EWidgetIndicatorType || (exports.EWidgetIndicatorType = {}));
+exports.EOuterAggregation = void 0;
+(function (EOuterAggregation) {
+    EOuterAggregation["avg"] = "avg";
+    EOuterAggregation["median"] = "median";
+    EOuterAggregation["count"] = "count";
+    EOuterAggregation["countDistinct"] = "countDistinct";
+    EOuterAggregation["min"] = "min";
+    EOuterAggregation["max"] = "max";
+    EOuterAggregation["sum"] = "sum";
+    EOuterAggregation["top"] = "top";
+})(exports.EOuterAggregation || (exports.EOuterAggregation = {}));
+/** Режимы значения показателя (на основе чего генерируется формула) */
+exports.EWidgetIndicatorValueModes = void 0;
+(function (EWidgetIndicatorValueModes) {
+    /** Готовая формула (как правило, введенная пользователем через редактор формул) */
+    EWidgetIndicatorValueModes["FORMULA"] = "FORMULA";
+    /** Шаблон формулы, предоставляемый системой */
+    EWidgetIndicatorValueModes["TEMPLATE"] = "TEMPLATE";
+    EWidgetIndicatorValueModes["AGGREGATION"] = "AGGREGATION";
+    EWidgetIndicatorValueModes["DURATION"] = "DURATION";
+    EWidgetIndicatorValueModes["CONVERSION"] = "CONVERSION";
+    EWidgetIndicatorValueModes["START_TIME"] = "START_TIME";
+    EWidgetIndicatorValueModes["END_TIME"] = "END_TIME";
+})(exports.EWidgetIndicatorValueModes || (exports.EWidgetIndicatorValueModes = {}));
+/** Режимы сортировки (на что ссылается сортировка) */
+exports.ESortingValueModes = void 0;
+(function (ESortingValueModes) {
+    /** Сортировка по формуле */
+    ESortingValueModes["FORMULA"] = "FORMULA";
+    /** Сортировка по показателю(разрезу или мере) виджета */
+    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
+})(exports.ESortingValueModes || (exports.ESortingValueModes = {}));
+exports.EFormatOrFormattingMode = void 0;
+(function (EFormatOrFormattingMode) {
+    EFormatOrFormattingMode["BASE"] = "BASE";
+    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
+})(exports.EFormatOrFormattingMode || (exports.EFormatOrFormattingMode = {}));
+function inheritDisplayConditionFromHierarchy(dimension, hierarchy) {
+    return __assign(__assign({}, dimension), { displayCondition: hierarchy.displayCondition });
+}
+/** Тип показателя */
+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["COLUMN_LIST"] = "COLUMN_LIST";
+    /** Разрез */
+    EIndicatorType["DIMENSION"] = "DIMENSION";
+    /** Мера */
+    EIndicatorType["MEASURE"] = "MEASURE";
+    /** Иерархия */
+    EIndicatorType["DYNAMIC_DIMENSION"] = "DYNAMIC_DIMENSION";
+    /** Пользовательская сортировка */
+    EIndicatorType["USER_SORTING"] = "USER_SORTING";
+})(exports.EIndicatorType || (exports.EIndicatorType = {}));
+/** Обобщенные типы значений переменных */
+exports.ESimpleInputType = void 0;
+(function (ESimpleInputType) {
+    /** Число (точность Float64) */
+    ESimpleInputType["NUMBER"] = "FLOAT";
+    /** Целое число (точность Int64) */
+    ESimpleInputType["INTEGER_NUMBER"] = "INTEGER";
+    /** Текст */
+    ESimpleInputType["TEXT"] = "STRING";
+    /** Дата (точность Date) */
+    ESimpleInputType["DATE"] = "DATE";
+    /** Дата и время (точность DateTime64) */
+    ESimpleInputType["DATE_AND_TIME"] = "DATETIME";
+    /** Логический тип */
+    ESimpleInputType["BOOLEAN"] = "BOOLEAN";
+})(exports.ESimpleInputType || (exports.ESimpleInputType = {}));
+function isDimensionsHierarchy(indicator) {
+    return "hierarchyDimensions" in indicator;
+}
+exports.OuterAggregation = void 0;
+(function (OuterAggregation) {
+    OuterAggregation["avg"] = "avgIf";
+    OuterAggregation["median"] = "medianIf";
+    OuterAggregation["count"] = "countIf";
+    OuterAggregation["countDistinct"] = "countIfDistinct";
+    OuterAggregation["min"] = "minIf";
+    OuterAggregation["max"] = "maxIf";
+    OuterAggregation["sum"] = "sumIf";
+})(exports.OuterAggregation || (exports.OuterAggregation = {}));
+exports.EDurationTemplateName = void 0;
+(function (EDurationTemplateName) {
+    EDurationTemplateName["avg"] = "avg";
+    EDurationTemplateName["median"] = "median";
+})(exports.EDurationTemplateName || (exports.EDurationTemplateName = {}));
+exports.EEventAppearances = void 0;
+(function (EEventAppearances) {
+    EEventAppearances["FIRST"] = "FIRST";
+    EEventAppearances["LAST"] = "LAST";
+})(exports.EEventAppearances || (exports.EEventAppearances = {}));
+
+// Типы, используемые в значениях элементов управления.
+exports.EWidgetFilterMode = void 0;
+(function (EWidgetFilterMode) {
+    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
+    EWidgetFilterMode["SINGLE"] = "SINGLE";
+    EWidgetFilterMode["DISABLED"] = "DISABLED";
+})(exports.EWidgetFilterMode || (exports.EWidgetFilterMode = {}));
+exports.EMarkdownDisplayMode = void 0;
+(function (EMarkdownDisplayMode) {
+    EMarkdownDisplayMode["NONE"] = "NONE";
+    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
+})(exports.EMarkdownDisplayMode || (exports.EMarkdownDisplayMode = {}));
+exports.EDisplayConditionMode = void 0;
+(function (EDisplayConditionMode) {
+    EDisplayConditionMode["DISABLED"] = "DISABLED";
+    EDisplayConditionMode["FORMULA"] = "FORMULA";
+    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
+})(exports.EDisplayConditionMode || (exports.EDisplayConditionMode = {}));
+exports.EFontWeight = void 0;
+(function (EFontWeight) {
+    EFontWeight["NORMAL"] = "NORMAL";
+    EFontWeight["BOLD"] = "BOLD";
+})(exports.EFontWeight || (exports.EFontWeight = {}));
+exports.EHeightMode = void 0;
+(function (EHeightMode) {
+    EHeightMode["FIXED"] = "FIXED";
+    EHeightMode["PERCENT"] = "PERCENT";
+})(exports.EHeightMode || (exports.EHeightMode = {}));
+
+var SortDirectionSchema = function (z) {
+    return z.union([z.literal(exports.ESortDirection.ascend), z.literal(exports.ESortDirection.descend)]);
+};
+var SortOrderSchema = function (z) {
+    return z.object({
+        /** Формула сортировки */
+        formula: FormulaSchema(z),
+        /** Тип данных формулы */
+        dbDataType: z.string().optional(),
+        /** Направление сортировки */
+        direction: SortDirectionSchema(z),
+        /** Условие применения сортировки */
+        displayCondition: FormulaSchema(z).optional(),
+    });
+};
+var WidgetSortingValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.ESortingValueModes.FORMULA),
+            formula: FormulaSchema(z),
+            dbDataType: z.string().optional(),
+        }),
+        z.object({
+            mode: z.literal(exports.ESortingValueModes.IN_WIDGET),
+            group: z.string(),
+            index: z.number(),
+        }),
+    ]);
+};
+
+/** Ключи мета-данных внутри схем настроек */
+exports.ESettingsSchemaMetaKey = void 0;
+(function (ESettingsSchemaMetaKey) {
+    /** Привязка значения из темы к настройке */
+    ESettingsSchemaMetaKey["themeValue"] = "themeValue";
+    /** Тип сущности */
+    ESettingsSchemaMetaKey["entity"] = "entity";
+})(exports.ESettingsSchemaMetaKey || (exports.ESettingsSchemaMetaKey = {}));
+
+var _a$6;
+var RangeSchema = function (z) {
+    return z.object({
+        unit: z.string().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+    });
+};
+var DisplayConditionSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.DISABLED),
+        }),
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.VARIABLE),
+            variableName: NameNullableSchema(z),
+            variableValue: z.string().nullable().default(null),
+        }),
+    ])
+        .default({ mode: exports.EDisplayConditionMode.DISABLED });
+};
+/** Схема ключа сущности (с возможностью находиться в неинициализированном состоянии) */
+var KeyNullableSchema = function (z) { return z.string().nullable().default(null); };
+/** Схема имени сущности (с возможностью находиться в неинициализированном состоянии) */
+var NameNullableSchema = function (z) { return z.string().nullable().default(null); };
+/**
+ * Перечисление системных типов сущностей в схеме настроек виджетов.
+ * @note при расширении лучше положить на более общий уровень.
+ */
+var EEntity;
+(function (EEntity) {
+    EEntity["formula"] = "formula";
+})(EEntity || (EEntity = {}));
+var formulaMeta = Object.freeze((_a$6 = {}, _a$6[exports.ESettingsSchemaMetaKey.entity] = EEntity.formula, _a$6));
+/** Схема формулы */
+var FormulaSchema = function (z) { return z.string().default("").meta(formulaMeta); };
+/**
+ * Схема формулы, которая не может быть пустой строкой, но может быть в
+ * неинициализированном состоянии null (вместо пустой строки)
+ *
+ * @note для обратной совместимости без необходимости писать миграции
+ */
+var FormulaNullableSchema = function (z) {
+    return z.string().nullable().default(null).meta(formulaMeta);
+};
+
+var WidgetIndicatorSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var FormatSchema = function (z) {
+    return z
+        .object({
+        mode: z.enum(exports.EFormatOrFormattingMode),
+        value: z.enum(exports.EFormatTypes).optional(),
+    })
+        .default({ mode: exports.EFormatOrFormattingMode.BASE, value: exports.EFormatTypes.STRING });
+};
+var FormattingSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EFormatOrFormattingMode.BASE),
+            value: z.enum(exports.EFormattingPresets).default(exports.EFormattingPresets.AUTO),
+        }),
+        z.object({
+            mode: z.literal(exports.EFormatOrFormattingMode.TEMPLATE),
+            value: z.string().default(""),
+        }),
+    ])
+        .default({ mode: exports.EFormatOrFormattingMode.BASE, value: exports.EFormattingPresets.AUTO });
+};
+var WidgetColumnIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        dbDataType: z.string().optional(),
+        format: FormatSchema(z).optional(),
+        formatting: FormattingSchema(z).optional(),
+        displayCondition: DisplayConditionSchema(z),
+        onClick: z.array(ActionsOnClickSchema(z)).optional(),
+    });
+};
+var WidgetIndicatorFormulaValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+        formula: FormulaSchema(z).optional(),
+    });
+};
+var WidgetIndicatorTemplateValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.TEMPLATE),
+        /** Имя шаблонной формулы, использующей колонку таблицы */
+        templateName: z.string().optional(),
+        /** Имя таблицы */
+        tableName: z.string().optional(),
+        /** Имя колонки */
+        columnName: z.string().optional(),
+    });
+};
+var ColumnIndicatorValueSchema = function (z) {
+    return z.union([MeasureValueSchema(z), DimensionValueSchema(z)]);
+};
+var MeasureValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        WidgetIndicatorFormulaValueSchema(z),
+        WidgetIndicatorTemplateValueSchema(z).extend({
+            innerTemplateName: z.enum(exports.EMeasureInnerTemplateNames).optional(),
+        }),
+    ]);
+};
+var DimensionValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        WidgetIndicatorFormulaValueSchema(z),
+        WidgetIndicatorTemplateValueSchema(z).extend({
+            innerTemplateName: z.never().optional(),
+        }),
+    ]);
+};
+var WidgetIndicatorAggregationValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.AGGREGATION),
+        templateName: z.string(),
+        processKey: KeyNullableSchema(z),
+        eventName: NameNullableSchema(z),
+        eventNameFormula: FormulaNullableSchema(z),
+        anyEvent: z.literal(true).optional(),
+        caseCaseIdFormula: FormulaNullableSchema(z),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        tableName: z.string().optional(),
+        columnName: z.string().optional(),
+        eventTimeFormula: FormulaNullableSchema(z).optional(),
+    });
+};
+var WidgetMeasureAggregationValueSchema = function (z) {
+    return WidgetIndicatorAggregationValueSchema(z).extend({ outerAggregation: z.enum(exports.EOuterAggregation) });
+};
+var WidgetIndicatorTimeValueSchema = function (z) {
+    return z.object({
+        templateName: z.string(),
+        mode: z.union([
+            z.literal(exports.EWidgetIndicatorValueModes.START_TIME),
+            z.literal(exports.EWidgetIndicatorValueModes.END_TIME),
+        ]),
+        processKey: KeyNullableSchema(z),
+        eventName: NameNullableSchema(z),
+        eventTimeFormula: FormulaNullableSchema(z),
+        caseCaseIdFormula: FormulaNullableSchema(z),
+        eventNameFormula: FormulaNullableSchema(z),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+    });
+};
+var WidgetDimensionSchema = function (z) {
+    return WidgetColumnIndicatorSchema(z).extend({
+        value: z
+            .discriminatedUnion("mode", [
+            DimensionValueSchema(z),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                innerTemplateName: z.string().optional(),
+            }),
+            WidgetIndicatorTimeValueSchema(z),
+        ])
+            .optional(),
+        hideEmptyValues: z.boolean().default(false),
+    });
+};
+var WidgetDimensionInHierarchySchema = function (z) {
+    return WidgetDimensionSchema(z).omit({ displayCondition: true });
+};
+var WidgetDimensionHierarchySchema = function (z, dimensionSchema) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        // Для иерархии является дискриминатором, для него нельзя задавать дефолтное значение.
+        hierarchyDimensions: z.array(dimensionSchema),
+        displayCondition: DisplayConditionSchema(z),
+    });
+};
+var WidgetIndicatorConversionValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.CONVERSION),
+        startEventNameFormula: FormulaNullableSchema(z),
+        startEventProcessKey: KeyNullableSchema(z),
+        startEventName: NameNullableSchema(z),
+        startEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        startEventTimeFormula: FormulaNullableSchema(z),
+        endEventNameFormula: FormulaNullableSchema(z),
+        endEventProcessKey: KeyNullableSchema(z),
+        endEventName: NameNullableSchema(z),
+        endEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        endCaseCaseIdFormula: FormulaNullableSchema(z),
+        endEventTimeFormula: FormulaNullableSchema(z),
+    });
+};
+var WidgetIndicatorDurationValueSchema = function (z) {
+    return WidgetIndicatorConversionValueSchema(z).extend({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.DURATION),
+        templateName: z.string(),
+        startEventAppearances: z.enum(exports.EEventAppearances),
+        endEventAppearances: z.enum(exports.EEventAppearances),
+    });
+};
+var WidgetMeasureSchema = function (z) {
+    return WidgetColumnIndicatorSchema(z).extend({
+        value: z
+            .discriminatedUnion("mode", [
+            MeasureValueSchema(z),
+            WidgetMeasureAggregationValueSchema(z),
+            WidgetIndicatorConversionValueSchema(z),
+            WidgetIndicatorDurationValueSchema(z),
+        ])
+            .optional(),
+    });
+};
+var MarkdownMeasureSchema = function (z) {
+    return WidgetMeasureSchema(z).extend({
+        displaySign: z.enum(exports.EMarkdownDisplayMode).default(exports.EMarkdownDisplayMode.NONE),
+    });
+};
+var WidgetSortingIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        direction: SortDirectionSchema(z),
+        value: WidgetSortingValueSchema(z),
+    });
+};
+var ProcessIndicatorValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(exports.EWidgetIndicatorValueModes.TEMPLATE),
+            /** Имя шаблонной формулы, использующей колонку таблицы */
+            templateName: z.string(),
+        }),
+    ]);
+};
+var ProcessIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        value: ProcessIndicatorValueSchema(z).optional(),
+        dbDataType: z.string().optional(),
+        format: FormatSchema(z).optional(),
+        formatting: FormattingSchema(z).optional(),
+        displayCondition: DisplayConditionSchema(z),
+    });
+};
+
+var FormulaFilterValueSchema = function (z) {
+    var _a;
+    return z.object({
+        name: z.string().nullish(),
+        formula: z.string(),
+        sliceIndex: z.number().optional(),
+        dbDataType: z.string(),
+        format: z.enum(exports.EFormatTypes),
+        filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+        checkedValues: z.array(z.string().nullable()).optional(),
+        formValues: z
+            .object((_a = {},
+            _a[exports.EFormulaFilterFieldKeys.date] = z.string().nullable(),
+            _a[exports.EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
+            _a[exports.EFormulaFilterFieldKeys.numberRange] = z.tuple([
+                z.number().optional(),
+                z.number().optional(),
+            ]),
+            _a[exports.EFormulaFilterFieldKeys.string] = z.string(),
+            // todo: отказаться от использования z.string(), оставить только z.number() [BI-15912]
+            _a[exports.EFormulaFilterFieldKeys.lastTimeValue] = z.number().or(z.string()),
+            _a[exports.EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(exports.ELastTimeUnit),
+            _a[exports.EFormulaFilterFieldKeys.durationUnit] = z.enum(exports.EDurationUnit),
+            _a))
+            .partial()
+            .optional(),
+    });
+};
+var ExtendedFormulaFilterValueSchema = function (z) {
+    return z.union([FormulaFilterValueSchema(z), z.object({ formula: z.string() })]);
+};
+var DimensionProcessFilterSchema = function (z) {
+    return z.object({
+        value: z.union([
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                outerAggregation: z.enum(exports.EOuterAggregation),
+            }),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                innerTemplateName: z.string().optional(),
+            }),
+            WidgetIndicatorTimeValueSchema(z),
+            z.object({
+                mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+                formula: z.string().optional(),
+            }),
+        ]),
+        dbDataType: z.string(),
+        condition: z.object({
+            filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+            timeUnit: z.enum(exports.EDimensionProcessFilterTimeUnit).optional(),
+            values: z.array(z.string().nullable()),
+        }),
+    });
+};
+var SettingsFilterSchema = function (z) {
+    return z.union([ExtendedFormulaFilterValueSchema(z), DimensionProcessFilterSchema(z)]);
+};
+
+var ActionOnClickParameterCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var ParameterFromColumnSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.COLUMN),
+        tableName: z.string().nullable().default(null),
+        columnName: z.string().nullable().default(null),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromVariableSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.VARIABLE),
+        sourceVariable: z.string().nullable().default(null),
+    });
+};
+var ParameterFromFormulaSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.FORMULA),
+        formula: FormulaSchema(z),
+        considerFilters: z.boolean().default(false),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.EVENT),
+    });
+};
+var ParameterFromStartEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.START_EVENT),
+    });
+};
+var ParameterFromEndEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.FINISH_EVENT),
+    });
+};
+var ParameterFromAggregationSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.AGGREGATION),
+        formula: FormulaSchema(z),
+        considerFilters: z.boolean().default(false),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromManualInputSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.MANUALLY),
+        description: z.string().default(""),
+        defaultValue: FormulaSchema(z),
+        dbDataType: z.string().optional(),
+        filterByRows: z.boolean().default(false),
+        validation: FormulaSchema(z),
+        acceptEmptyValue: z.boolean().default(false),
+    });
+};
+var ParameterFromStaticListSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.STATIC_LIST),
+        options: z.string().default(""),
+        defaultValue: z
+            .union([z.string(), z.array(z.string())])
+            .nullable()
+            .default(null),
+        acceptEmptyValue: z.boolean().default(false),
+    });
+};
+var ParameterFromDynamicListSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.DYNAMIC_LIST),
+        options: FormulaSchema(z),
+        defaultValue: FormulaSchema(z),
+        dbDataType: z.string().optional(),
+        displayOptions: FormulaSchema(z),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        filterByRows: z.boolean().default(false),
+        considerFilters: z.boolean().default(false),
+        insertAnyValues: z.boolean().default(false),
+        validation: FormulaSchema(z),
+        acceptEmptyValue: z.boolean().default(false),
+    });
+};
+var ParameterFromDataModelSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.DATA_MODEL),
+        option: z.enum(exports.EDataModelOption).default(exports.EDataModelOption.TABLE_LIST),
+        /**
+         * Используется только при COLUMN_LIST. Не делаем union по option, чтобы сохранить
+         * одновременно default для option и работоспособность внешнего discriminated union.
+         */
+        parent: NameNullableSchema(z),
+    });
+};
+var ActionOnClickParameterSchema = function (z) {
+    return z.intersection(ActionOnClickParameterCommonSchema(z), z.discriminatedUnion("inputMethod", [
+        ParameterFromColumnSchema(z),
+        ParameterFromVariableSchema(z),
+        ParameterFromFormulaSchema(z),
+        ParameterFromEventSchema(z),
+        ParameterFromStartEventSchema(z),
+        ParameterFromEndEventSchema(z),
+        ParameterFromAggregationSchema(z),
+        ParameterFromManualInputSchema(z),
+        ParameterFromStaticListSchema(z),
+        ParameterFromDynamicListSchema(z),
+        ParameterFromDataModelSchema(z),
+    ]));
+};
+var ActionCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var ActionDrillDownSchema = function (z) {
+    return ActionCommonSchema(z).extend({ type: z.literal(exports.EActionTypes.DRILL_DOWN) });
+};
+var ActionGoToURLSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.OPEN_URL),
+        url: z.string(),
+        newWindow: z.boolean().default(true),
+    });
+};
+var ActivateConditionSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EActivateConditionMode.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(exports.EActivateConditionMode.VARIABLE),
+            variableName: z.string().nullable().default(null),
+            variableValue: z.string().nullable().default(null),
+        }),
+    ])
+        .default({ mode: exports.EActivateConditionMode.FORMULA, formula: "" });
+};
+var ActionRunScriptSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.EAutoUpdateMode.THIS_WIDGET),
+        hideInactiveButton: z.boolean().default(false),
+        activateCondition: ActivateConditionSchema(z),
+        hint: z.string().default(""),
+    });
+};
+var ActionUpdateVariableSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.UPDATE_VARIABLE),
+        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
+    });
+};
+var ActionOpenInSchema = function (z) {
+    return z.discriminatedUnion("openIn", [
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.DRAWER_WINDOW),
+            alignment: z.enum(exports.EDrawerPlacement).default(exports.EDrawerPlacement.RIGHT),
+            inheritFilter: z.boolean().default(true),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
+            placeholderName: z.string(),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.MODAL_WINDOW),
+            positionByClick: z.boolean().default(false),
+            inheritFilter: z.boolean().default(true),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.WINDOW),
+            newWindow: z.boolean().default(true),
+            inheritFilter: z.boolean().default(true),
+        }),
+    ]);
+};
+var ActionOpenViewCommonSchema = function (z) {
+    return ActionCommonSchema(z).extend({ type: z.literal(exports.EActionTypes.OPEN_VIEW) });
+};
+var ActionOpenViewSchema = function (z) {
+    return z.intersection(z.discriminatedUnion("mode", [
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.GENERATED_BY_SCRIPT),
+            scriptKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+            displayName: z.string().default(""),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.EXISTED_VIEW),
+            viewKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.EMPTY),
+            placeholderName: z.string(),
+            openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
+        }),
+    ]), ActionOpenInSchema(z));
+};
+var ActionsOnClickSchema = function (z) {
+    return z.union([
+        ActionGoToURLSchema(z),
+        ActionRunScriptSchema(z),
+        ActionUpdateVariableSchema(z),
+        ActionOpenViewSchema(z),
+        ActionDrillDownSchema(z),
+    ]);
+};
+var WidgetActionParameterCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        displayName: z.string().default(""),
+        isHidden: z.boolean().default(false),
+    });
+};
+var WidgetActionParameterSchema = function (z) {
+    return z.intersection(WidgetActionParameterCommonSchema(z), z.discriminatedUnion("inputMethod", [
+        ParameterFromColumnSchema(z),
+        ParameterFromVariableSchema(z),
+        ParameterFromFormulaSchema(z),
+        ParameterFromManualInputSchema(z),
+        ParameterFromStaticListSchema(z),
+        ParameterFromDynamicListSchema(z),
+        ParameterFromAggregationSchema(z),
+        ParameterFromDataModelSchema(z),
+    ]));
+};
+var WidgetActionSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        parameters: z.array(WidgetActionParameterSchema(z)).default([]),
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.EAutoUpdateMode.THIS_WIDGET),
+        description: z.string().default(""),
+        hideInactiveButton: z.boolean().default(false),
+        hint: z.string().default(""),
+        activateCondition: ActivateConditionSchema(z),
+    });
+};
+var ViewActionParameterSchema = function (z) {
+    return z.intersection(AutoIdentifiedArrayItemSchema(z).extend({ name: z.string() }), z.discriminatedUnion("inputMethod", [
+        ParameterFromAggregationSchema(z),
+        ParameterFromVariableSchema(z),
+    ]));
+};
+var ViewActionSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        buttonType: z.enum(exports.EActionButtonsTypes).default(exports.EActionButtonsTypes.BASE),
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT).default(exports.EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ViewActionParameterSchema(z)).default([]),
+        scriptKey: KeyNullableSchema(z),
+        autoUpdate: z
+            .union([z.literal(exports.EAutoUpdateMode.NONE), z.literal(exports.EAutoUpdateMode.ALL_VIEWS)])
+            .default(exports.EAutoUpdateMode.NONE),
+    });
+};
+var ActionSchema = function (z) {
+    return z.union([ActionsOnClickSchema(z), WidgetActionSchema(z), ViewActionSchema(z)]);
+};
+var ActionButtonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        onClick: z.array(WidgetActionSchema(z)).default([]),
+        buttonType: z.enum(exports.EActionButtonsTypes).default(exports.EActionButtonsTypes.BASE),
+        backgroundColor: ColorSchema(z),
+        borderColor: ColorSchema(z),
+        color: ColorSchema(z),
+        hint: z.string().default(""),
+    });
+};
+
+var prepareValuesForSql = function (simpleType, values) {
+    return simpleType === exports.ESimpleDataType.INTEGER ||
+        simpleType === exports.ESimpleDataType.FLOAT ||
+        simpleType === exports.ESimpleDataType.BOOLEAN
+        ? values
+        : values.map(function (value) {
+            return value === null ? null : "'".concat(escapeSingularQuotes$1(escapeReverseSlash(value)), "'");
+        });
+};
+var escapeReverseSlash = function (formula) {
+    return formula.replaceAll(/\\/gm, "\\\\");
+};
+var escapeSingularQuotes$1 = function (formula) {
+    return formula.replaceAll("'", "\\'");
+};
+
+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["numberRange"] = "numberRange";
+    EFormulaFilterFieldKeys["string"] = "string";
+    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
+    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
+    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
+})(exports.EFormulaFilterFieldKeys || (exports.EFormulaFilterFieldKeys = {}));
+exports.EDimensionProcessFilterTimeUnit = void 0;
+(function (EDimensionProcessFilterTimeUnit) {
+    EDimensionProcessFilterTimeUnit["YEARS"] = "YEARS";
+    EDimensionProcessFilterTimeUnit["MONTHS"] = "MONTHS";
+    EDimensionProcessFilterTimeUnit["HOURS"] = "HOURS";
+    EDimensionProcessFilterTimeUnit["DAYS"] = "DAYS";
+    EDimensionProcessFilterTimeUnit["MINUTES"] = "MINUTES";
+})(exports.EDimensionProcessFilterTimeUnit || (exports.EDimensionProcessFilterTimeUnit = {}));
+var isFormulaFilterValue = function (value) {
+    return "filteringMethod" in value;
+};
+var isDimensionProcessFilter = function (filter) { return "value" in filter && "condition" in filter; };
+
+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 memoize(fn) {
+    var cache = new Map();
+    return function (arg) {
+        if (cache.has(arg)) {
+            return cache.get(arg);
+        }
+        var result = fn(arg);
+        cache.set(arg, result);
+        return result;
+    };
+}
+
+exports.EClickHouseBaseTypes = void 0;
+(function (EClickHouseBaseTypes) {
+    // DATE
+    EClickHouseBaseTypes["Date"] = "Date";
+    EClickHouseBaseTypes["Date32"] = "Date32";
+    // DATETIME
+    EClickHouseBaseTypes["DateTime"] = "DateTime";
+    EClickHouseBaseTypes["DateTime32"] = "DateTime32";
+    // DATETIME64
+    EClickHouseBaseTypes["DateTime64"] = "DateTime64";
+    // STRING
+    EClickHouseBaseTypes["FixedString"] = "FixedString";
+    EClickHouseBaseTypes["String"] = "String";
+    // FLOAT
+    EClickHouseBaseTypes["Decimal"] = "Decimal";
+    EClickHouseBaseTypes["Decimal32"] = "Decimal32";
+    EClickHouseBaseTypes["Decimal64"] = "Decimal64";
+    EClickHouseBaseTypes["Decimal128"] = "Decimal128";
+    EClickHouseBaseTypes["Decimal256"] = "Decimal256";
+    EClickHouseBaseTypes["Float32"] = "Float32";
+    EClickHouseBaseTypes["Float64"] = "Float64";
+    // INTEGER
+    EClickHouseBaseTypes["Int8"] = "Int8";
+    EClickHouseBaseTypes["Int16"] = "Int16";
+    EClickHouseBaseTypes["Int32"] = "Int32";
+    EClickHouseBaseTypes["Int64"] = "Int64";
+    EClickHouseBaseTypes["Int128"] = "Int128";
+    EClickHouseBaseTypes["Int256"] = "Int256";
+    EClickHouseBaseTypes["UInt8"] = "UInt8";
+    EClickHouseBaseTypes["UInt16"] = "UInt16";
+    EClickHouseBaseTypes["UInt32"] = "UInt32";
+    EClickHouseBaseTypes["UInt64"] = "UInt64";
+    EClickHouseBaseTypes["UInt128"] = "UInt128";
+    EClickHouseBaseTypes["UInt256"] = "UInt256";
+    // BOOLEAN
+    EClickHouseBaseTypes["Bool"] = "Bool";
+})(exports.EClickHouseBaseTypes || (exports.EClickHouseBaseTypes = {}));
+var stringTypes = ["String", "FixedString"];
+var parseClickHouseType = memoize(function (type) {
+    if (isNil(type)) {
+        return {
+            simpleBaseType: exports.ESimpleDataType.OTHER,
+            dbBaseDataType: undefined,
+            containers: [],
+            simpleType: exports.ESimpleDataType.OTHER,
+        };
+    }
+    var _a = extractInnerType(type), containers = _a.containers, dbBaseDataType = _a.dbBaseDataType;
+    if (!dbBaseDataType) {
+        throw new Error("Invalid ClickHouse type: ".concat(type));
+    }
+    return {
+        dbBaseDataType: dbBaseDataType,
+        simpleBaseType: simplifyBaseType(dbBaseDataType),
+        containers: containers,
+        get simpleType() {
+            return containers.includes("Array") ? exports.ESimpleDataType.OTHER : this.simpleBaseType;
+        },
+    };
+});
+/** 'A(B(C))' -> ['A', 'B', 'C'] */
+var splitByBrackets = function (input) { return input.split(/[\(\)]/).filter(Boolean); };
+/**
+ * Отделить внутренний тип от оберток.
+ * Не поддерживаются обертки Tuple и LowCardinality.
+ */
+var extractInnerType = function (type) {
+    var tokens = splitByBrackets(type);
+    // Удаление параметров типа.
+    if (tokens.length > 0 && isTypeParameters(tokens.at(-1))) {
+        tokens.pop();
+    }
+    var dbBaseDataType = tokens.pop();
+    return { containers: tokens, dbBaseDataType: dbBaseDataType };
+};
+var simplifyBaseType = function (dbBaseType) {
+    var isSourceTypeStartsWith = function (prefix) { return dbBaseType.startsWith(prefix); };
+    if (isSourceTypeStartsWith("Int") || isSourceTypeStartsWith("UInt")) {
+        return exports.ESimpleDataType.INTEGER;
+    }
+    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
+        return exports.ESimpleDataType.FLOAT;
+    }
+    if (stringTypes.some(isSourceTypeStartsWith)) {
+        return exports.ESimpleDataType.STRING;
+    }
+    if (isSourceTypeStartsWith("DateTime64")) {
+        return exports.ESimpleDataType.DATETIME64;
+    }
+    if (isSourceTypeStartsWith("DateTime")) {
+        return exports.ESimpleDataType.DATETIME;
+    }
+    if (isSourceTypeStartsWith("Date")) {
+        return exports.ESimpleDataType.DATE;
+    }
+    if (isSourceTypeStartsWith("Bool")) {
+        return exports.ESimpleDataType.BOOLEAN;
+    }
+    return exports.ESimpleDataType.OTHER;
+};
+/**
+ * - `3` -> true
+ * - `3, 'Europe/Moscow'` -> true
+ * - `3, Europe/Moscow` -> false
+ *
+ * Пример типа с параметрами: `DateTime64(3, 'Europe/Moscow')`
+ */
+var isTypeParameters = function (stringifiedParameters) {
+    return stringifiedParameters.split(", ").some(function (p) { return !Number.isNaN(Number(p)) || p.startsWith("'"); });
+};
+
+var _a$5;
 exports.EDimensionTemplateNames = void 0;
 (function (EDimensionTemplateNames) {
     EDimensionTemplateNames["dateTime"] = "dateTime";
@@ -627,136 +1506,29 @@ exports.EDimensionTemplateNames = void 0;
     EDimensionTemplateNames["hour"] = "hour";
 })(exports.EDimensionTemplateNames || (exports.EDimensionTemplateNames = {}));
 /** Стандартные шаблоны разреза */
-var dimensionTemplateFormulas = (_a$4 = {},
-    _a$4[exports.EDimensionTemplateNames.dateTime] = "toDateTime({columnFormula})",
-    _a$4[exports.EDimensionTemplateNames.date] = "toDate({columnFormula})",
-    _a$4[exports.EDimensionTemplateNames.year] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.yearAndQuarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}) * 10 + toQuarter({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.quarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toQuarter({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.yearAndMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYYYYMM({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.month] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toMonth({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.dayOfMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfMonth({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.week] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toWeek({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.dayOfWeek] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfWeek({columnFormula}))",
-    _a$4[exports.EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
-    _a$4);
-
-exports.EWidgetIndicatorType = void 0;
-(function (EWidgetIndicatorType) {
-    EWidgetIndicatorType["MEASURE"] = "MEASURE";
-    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
-    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
-    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
-    EWidgetIndicatorType["SORTING"] = "SORTING";
-})(exports.EWidgetIndicatorType || (exports.EWidgetIndicatorType = {}));
-exports.EOuterAggregation = void 0;
-(function (EOuterAggregation) {
-    EOuterAggregation["avg"] = "avg";
-    EOuterAggregation["median"] = "median";
-    EOuterAggregation["count"] = "count";
-    EOuterAggregation["countDistinct"] = "countDistinct";
-    EOuterAggregation["min"] = "min";
-    EOuterAggregation["max"] = "max";
-    EOuterAggregation["sum"] = "sum";
-    EOuterAggregation["top"] = "top";
-})(exports.EOuterAggregation || (exports.EOuterAggregation = {}));
-/** Режимы значения показателя (на основе чего генерируется формула) */
-exports.EWidgetIndicatorValueModes = void 0;
-(function (EWidgetIndicatorValueModes) {
-    /** Готовая формула (как правило, введенная пользователем через редактор формул) */
-    EWidgetIndicatorValueModes["FORMULA"] = "FORMULA";
-    /** Шаблон формулы, предоставляемый системой */
-    EWidgetIndicatorValueModes["TEMPLATE"] = "TEMPLATE";
-    EWidgetIndicatorValueModes["AGGREGATION"] = "AGGREGATION";
-    EWidgetIndicatorValueModes["DURATION"] = "DURATION";
-    EWidgetIndicatorValueModes["CONVERSION"] = "CONVERSION";
-    EWidgetIndicatorValueModes["START_TIME"] = "START_TIME";
-    EWidgetIndicatorValueModes["END_TIME"] = "END_TIME";
-})(exports.EWidgetIndicatorValueModes || (exports.EWidgetIndicatorValueModes = {}));
-/** Режимы сортировки (на что ссылается сортировка) */
-exports.ESortingValueModes = void 0;
-(function (ESortingValueModes) {
-    /** Сортировка по формуле */
-    ESortingValueModes["FORMULA"] = "FORMULA";
-    /** Сортировка по показателю(разрезу или мере) виджета */
-    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
-})(exports.ESortingValueModes || (exports.ESortingValueModes = {}));
-exports.EFormatOrFormattingMode = void 0;
-(function (EFormatOrFormattingMode) {
-    EFormatOrFormattingMode["BASE"] = "BASE";
-    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
-})(exports.EFormatOrFormattingMode || (exports.EFormatOrFormattingMode = {}));
-/** Тип показателя */
-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["COLUMN_LIST"] = "COLUMN_LIST";
-    /** Разрез */
-    EIndicatorType["DIMENSION"] = "DIMENSION";
-    /** Мера */
-    EIndicatorType["MEASURE"] = "MEASURE";
-    /** Иерархия */
-    EIndicatorType["DYNAMIC_DIMENSION"] = "DYNAMIC_DIMENSION";
-    /** Пользовательская сортировка */
-    EIndicatorType["USER_SORTING"] = "USER_SORTING";
-})(exports.EIndicatorType || (exports.EIndicatorType = {}));
-/** Обобщенные типы значений переменных */
-exports.ESimpleInputType = void 0;
-(function (ESimpleInputType) {
-    /** Число (точность Float64) */
-    ESimpleInputType["NUMBER"] = "FLOAT";
-    /** Целое число (точность Int64) */
-    ESimpleInputType["INTEGER_NUMBER"] = "INTEGER";
-    /** Текст */
-    ESimpleInputType["TEXT"] = "STRING";
-    /** Дата (точность Date) */
-    ESimpleInputType["DATE"] = "DATE";
-    /** Дата и время (точность DateTime64) */
-    ESimpleInputType["DATE_AND_TIME"] = "DATETIME";
-    /** Логический тип */
-    ESimpleInputType["BOOLEAN"] = "BOOLEAN";
-})(exports.ESimpleInputType || (exports.ESimpleInputType = {}));
-function isDimensionsHierarchy(indicator) {
-    return "hierarchyDimensions" in indicator;
-}
-exports.OuterAggregation = void 0;
-(function (OuterAggregation) {
-    OuterAggregation["avg"] = "avgIf";
-    OuterAggregation["median"] = "medianIf";
-    OuterAggregation["count"] = "countIf";
-    OuterAggregation["countDistinct"] = "countIfDistinct";
-    OuterAggregation["min"] = "minIf";
-    OuterAggregation["max"] = "maxIf";
-    OuterAggregation["sum"] = "sumIf";
-})(exports.OuterAggregation || (exports.OuterAggregation = {}));
-exports.EDurationTemplateName = void 0;
-(function (EDurationTemplateName) {
-    EDurationTemplateName["avg"] = "avg";
-    EDurationTemplateName["median"] = "median";
-})(exports.EDurationTemplateName || (exports.EDurationTemplateName = {}));
-exports.EEventAppearances = void 0;
-(function (EEventAppearances) {
-    EEventAppearances["FIRST"] = "FIRST";
-    EEventAppearances["LAST"] = "LAST";
-})(exports.EEventAppearances || (exports.EEventAppearances = {}));
+var dimensionTemplateFormulas = (_a$5 = {},
+    _a$5[exports.EDimensionTemplateNames.dateTime] = "toDateTime({columnFormula})",
+    _a$5[exports.EDimensionTemplateNames.date] = "toDate({columnFormula})",
+    _a$5[exports.EDimensionTemplateNames.year] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.yearAndQuarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}) * 10 + toQuarter({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.quarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toQuarter({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.yearAndMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYYYYMM({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.month] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toMonth({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.dayOfMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfMonth({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.week] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toWeek({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.dayOfWeek] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfWeek({columnFormula}))",
+    _a$5[exports.EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
+    _a$5);
 
 function createAggregationTemplate$1(functionName, options) {
-    return "process(".concat(functionName, "(").concat((options === null || options === void 0 ? void 0 : options.distinct) ? "distinct " : "", "{columnFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula})");
+    return "process(".concat(functionName, "(").concat((options === null || options === void 0 ? void 0 : options.distinct) ? "distinct " : "", "{columnFormula}, {eventNameFormula} ={eventName}{filters}), {caseCaseIdFormula})");
 }
 
-var countReworksTemplate = "process(if(countIf({eventNameFormula} = '{eventName}'{filters}) > 0, countIf({eventNameFormula}  = '{eventName}'{filters}) - 1, 0), {caseCaseIdFormula})";
-var countExecutionsTemplate = "process(countIf({eventNameFormula} in '{eventName}'{filters}), {caseCaseIdFormula})";
-var lastValueTemplate = "process(argMaxIf({columnFormula}, {eventTimeFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula})";
-var firstValueTemplate = "process(argMinIf({columnFormula}, {eventTimeFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula})";
-var topTemplate = "process(topKIf(1)({columnFormula}, {eventNameFormula} = '{eventName}'{filters})[1], {caseCaseIdFormula})";
+var countReworksTemplate = "process(if(countIf({eventNameFormula} = {eventName}{filters}) > 0, countIf({eventNameFormula}  = {eventName}{filters}) - 1, 0), {caseCaseIdFormula})";
+var countExecutionsTemplate = "process(countIf({eventNameFormula} in {eventName}{filters}), {caseCaseIdFormula})";
+var lastValueTemplate = "process(argMaxIf({columnFormula}, {eventTimeFormula}, {eventNameFormula} = {eventName}{filters}), {caseCaseIdFormula})";
+var firstValueTemplate = "process(argMinIf({columnFormula}, {eventTimeFormula}, {eventNameFormula} = {eventName}{filters}), {caseCaseIdFormula})";
+var topTemplate = "process(topKIf(1)({columnFormula}, {eventNameFormula} = {eventName}{filters})[1], {caseCaseIdFormula})";
 var avgTemplate = createAggregationTemplate$1("avgIf");
 var medianTemplate = createAggregationTemplate$1("medianIf");
 var countTemplate = createAggregationTemplate$1("countIf");
@@ -765,8 +1537,51 @@ var minTemplate = createAggregationTemplate$1("minIf");
 var maxTemplate = createAggregationTemplate$1("maxIf");
 var sumTemplate = createAggregationTemplate$1("sumIf");
 
-function fillTemplateString(templateString, params) {
-    return templateString.replace(/\{(.*?)\}/g, function (_, key) { var _a; return (_a = params[key]) !== null && _a !== void 0 ? _a : ""; });
+function hasPossibleSingleLineComment(str) {
+    return str.indexOf("--") >= 0;
+}
+function sanitizeSingleLineComment(formula, wrapInBrackets) {
+    if (!hasPossibleSingleLineComment(formula)) {
+        return formula;
+    }
+    var lines = formula.split("\n");
+    var lastLine = lines[lines.length - 1];
+    // Кейс, когда хотим избежать повторного добавления переноса строки:
+    // уже есть переносы и после последнего переноса нет комментария
+    if (lines.length > 1 && lastLine && !hasPossibleSingleLineComment(lastLine)) {
+        return formula;
+    }
+    return wrapInBrackets ? "(".concat(formula, "\n)") : "".concat(formula, "\n");
+}
+
+/** Функция для безопасного заполнения SQL шаблонов с защитой от однострочных SQL комментариев в подставляемых значениях. */
+function fillTemplateSql(templateString, params) {
+    var e_1, _a;
+    var newParams = {};
+    if (templateString.indexOf("'{") >= 0) {
+        throw new Error("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 \u0448\u0430\u0431\u043B\u043E\u043D: \u043F\u043B\u0435\u0439\u0441\u0445\u043E\u043B\u0434\u0435\u0440\u044B \u043D\u0435 \u0434\u043E\u043B\u0436\u043D\u044B \u0437\u0430\u043A\u043B\u044E\u0447\u0430\u0442\u044C\u0441\u044F \u0432 \u043E\u0434\u0438\u043D\u0430\u0440\u043D\u044B\u0435 \u043A\u0430\u0432\u044B\u0447\u043A\u0438.\n       \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 {placeholder} \u0432\u043C\u0435\u0441\u0442\u043E '{placeholder}'.\n       \u041A\u0430\u0432\u044B\u0447\u043A\u0438 \u0434\u043E\u043B\u0436\u043D\u044B \u0434\u043E\u0431\u0430\u0432\u043B\u044F\u0442\u044C\u0441\u044F \u0434\u043B\u044F \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u044B\u0445 \u043F\u043E\u043B\u0435\u0439 \u043F\u0440\u0438 \u0444\u043E\u0440\u043C\u0438\u0440\u043E\u0432\u0430\u043D\u0438\u0438 \u043E\u0431\u044A\u0435\u043A\u0442\u0430 \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u043E\u0432.");
+    }
+    try {
+        for (var _b = __values(Object.entries(params)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+            if (String(value).indexOf("--") >= 0) {
+                newParams[key] = "".concat(value, "\n");
+                continue;
+            }
+            newParams[key] = sanitizeSingleLineComment(String(value));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return templateString.replace(/\{(.*?)\}/g, function (_, key) {
+        var _a;
+        return (_a = newParams[key]) !== null && _a !== void 0 ? _a : "";
+    });
 }
 
 /** Создать функцию экранирования переданных `specialChars` внутри `str` */
@@ -840,7 +1655,7 @@ var escapeSingularQuotes = function (formula) {
 };
 
 var prepareFormulaForSql = function (formula, simpleType) {
-    formula = clearSingleLineComments(clearMultiLineComments(formula)).trim();
+    formula = sanitizeSingleLineComment(formula, true);
     return simpleType === exports.ESimpleDataType.OTHER ? "toString(".concat(formula, ")") : formula;
 };
 var clearSingleLineComments = function (formula) {
@@ -922,7 +1737,7 @@ var convertFiltersToFormula = function (filters) {
     return filters.length > 0 ? " AND ".concat(convertToFormulasChain(filters)) : "";
 };
 
-var _a$3;
+var _a$4;
 exports.EDimensionAggregationTemplateName = void 0;
 (function (EDimensionAggregationTemplateName) {
     EDimensionAggregationTemplateName["avg"] = "avg";
@@ -939,20 +1754,20 @@ exports.EDimensionAggregationTemplateName = void 0;
     EDimensionAggregationTemplateName["countReworks"] = "countReworks";
 })(exports.EDimensionAggregationTemplateName || (exports.EDimensionAggregationTemplateName = {}));
 /** Шаблоны процессных метрик разреза с режимом AGGREGATION */
-var dimensionAggregationTemplates = (_a$3 = {},
-    _a$3[exports.EDimensionAggregationTemplateName.avg] = avgTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.median] = medianTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.count] = countTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.countDistinct] = countDistinctTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.min] = minTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.max] = maxTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.sum] = sumTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.top] = topTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.firstValue] = firstValueTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.lastValue] = lastValueTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.countExecutions] = countExecutionsTemplate,
-    _a$3[exports.EDimensionAggregationTemplateName.countReworks] = countReworksTemplate,
-    _a$3);
+var dimensionAggregationTemplates = (_a$4 = {},
+    _a$4[exports.EDimensionAggregationTemplateName.avg] = avgTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.median] = medianTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.count] = countTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.countDistinct] = countDistinctTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.min] = minTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.max] = maxTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.sum] = sumTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.top] = topTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.firstValue] = firstValueTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.lastValue] = lastValueTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.countExecutions] = countExecutionsTemplate,
+    _a$4[exports.EDimensionAggregationTemplateName.countReworks] = countReworksTemplate,
+    _a$4);
 /** На основе значения режима AGGREGATION подготовить параметры для подстановки в шаблонную формулу */
 var prepareDimensionAggregationParams = function (value) {
     if (!value.eventName ||
@@ -965,8 +1780,7 @@ var prepareDimensionAggregationParams = function (value) {
     var commonParams = {
         eventNameFormula: value.eventNameFormula,
         caseCaseIdFormula: value.caseCaseIdFormula,
-        eventName: value.eventName,
-        objectFilters: "1",
+        eventName: "'".concat(escapeSingularQuotes(value.eventName), "'"),
         filters: convertFiltersToFormula(value.filters),
         eventTimeFormula: "",
         columnFormula: "",
@@ -995,13 +1809,13 @@ var timeTemplates = (function () {
     var generateTemplates = function (innerTemplate) {
         var templates = {};
         for (var key in dimensionTemplateFormulas) {
-            templates[key] = fillTemplateString(dimensionTemplateFormulas[key], { columnFormula: innerTemplate });
+            templates[key] = fillTemplateSql(dimensionTemplateFormulas[key], { columnFormula: innerTemplate });
         }
         return templates;
     };
     return _a = {},
-        _a[exports.EWidgetIndicatorValueModes.START_TIME] = generateTemplates("process(minIf({eventTimeFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula})"),
-        _a[exports.EWidgetIndicatorValueModes.END_TIME] = generateTemplates("process(maxIf({eventTimeFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula})"),
+        _a[exports.EWidgetIndicatorValueModes.START_TIME] = generateTemplates("process(minIf({eventTimeFormula}, {eventNameFormula} = {eventName}{filters}), {caseCaseIdFormula})"),
+        _a[exports.EWidgetIndicatorValueModes.END_TIME] = generateTemplates("process(maxIf({eventTimeFormula}, {eventNameFormula} = {eventName}{filters}), {caseCaseIdFormula})"),
         _a;
 })();
 /** На основе значения режимов START_TIME/END_TIME подготовить параметры для подстановки в шаблонную формулу */
@@ -1019,12 +1833,12 @@ var prepareTimeParams = function (value) {
         eventNameFormula: value.eventNameFormula,
         caseCaseIdFormula: value.caseCaseIdFormula,
         filters: convertFiltersToFormula(value.filters),
-        eventName: value.eventName,
+        eventName: "'".concat(escapeSingularQuotes(value.eventName), "'"),
     };
 };
 
 function getDimensionFormula(_a) {
-    var _b;
+    var _b, _c;
     var value = _a.value;
     if (!value) {
         return "";
@@ -1038,10 +1852,13 @@ function getDimensionFormula(_a) {
         if (!templateFormula || !tableName || !columnName) {
             return "";
         }
-        return fillTemplateString(templateFormula, {
+        return fillTemplateSql(templateFormula, {
             columnFormula: generateColumnFormula(tableName, columnName),
         });
     }
+    return (_c = getProcessDimensionValueFormula(value)) !== null && _c !== void 0 ? _c : "";
+}
+function getProcessDimensionValueFormula(value) {
     if (value.mode === exports.EWidgetIndicatorValueModes.AGGREGATION) {
         var preparedParams = prepareDimensionAggregationParams(value);
         if (!preparedParams) {
@@ -1051,10 +1868,10 @@ function getDimensionFormula(_a) {
             ? dimensionTemplateFormulas[value.innerTemplateName]
             : null;
         var columnFormula = innerTemplate
-            ? fillTemplateString(innerTemplate, { columnFormula: preparedParams.columnFormula })
+            ? fillTemplateSql(innerTemplate, { columnFormula: preparedParams.columnFormula })
             : preparedParams.columnFormula;
         var dimensionAggregationTemplate = dimensionAggregationTemplates[value.templateName];
-        return fillTemplateString(dimensionAggregationTemplate, __assign(__assign({}, preparedParams), { columnFormula: columnFormula }));
+        return fillTemplateSql(dimensionAggregationTemplate, __assign(__assign({}, preparedParams), { columnFormula: columnFormula }));
     }
     if (value.mode === exports.EWidgetIndicatorValueModes.START_TIME ||
         value.mode === exports.EWidgetIndicatorValueModes.END_TIME) {
@@ -1063,9 +1880,8 @@ function getDimensionFormula(_a) {
             return "";
         }
         var templateFormula = timeTemplates[value.mode][value.templateName];
-        return fillTemplateString(templateFormula, preparedParams);
+        return fillTemplateSql(templateFormula, preparedParams);
     }
-    return "";
 }
 
 exports.EMeasureAggregationTemplateName = void 0;
@@ -1097,8 +1913,7 @@ var prepareMeasureAggregationParams = function (value) {
         outerAggregation: value.outerAggregation,
         eventNameFormula: value.eventNameFormula,
         caseCaseIdFormula: value.caseCaseIdFormula,
-        eventName: value.eventName,
-        objectFilters: "1",
+        eventName: value.eventName ? "'".concat(escapeSingularQuotes(value.eventName), "'") : "",
         filters: convertFiltersToFormula(value.filters),
         eventTimeFormula: "",
         columnFormula: "",
@@ -1119,7 +1934,7 @@ var prepareMeasureAggregationParams = function (value) {
     return columnParams;
 };
 
-var _a$2;
+var _a$3, _b;
 exports.EMeasureTemplateNames = void 0;
 (function (EMeasureTemplateNames) {
     EMeasureTemplateNames["avg"] = "avg";
@@ -1130,19 +1945,28 @@ exports.EMeasureTemplateNames = void 0;
     EMeasureTemplateNames["max"] = "max";
     EMeasureTemplateNames["sum"] = "sum";
 })(exports.EMeasureTemplateNames || (exports.EMeasureTemplateNames = {}));
+exports.EMeasureInnerTemplateNames = void 0;
+(function (EMeasureInnerTemplateNames) {
+    EMeasureInnerTemplateNames["begin"] = "begin";
+    EMeasureInnerTemplateNames["end"] = "end";
+})(exports.EMeasureInnerTemplateNames || (exports.EMeasureInnerTemplateNames = {}));
 /** Стандартные шаблоны меры */
-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);
+var measureTemplateFormulas = (_a$3 = {},
+    _a$3[exports.EMeasureTemplateNames.avg] = "avg({columnFormula})",
+    _a$3[exports.EMeasureTemplateNames.count] = "count({columnFormula})",
+    _a$3[exports.EMeasureTemplateNames.countDistinct] = "count(distinct {columnFormula})",
+    _a$3[exports.EMeasureTemplateNames.median] = "medianExact({columnFormula})",
+    _a$3[exports.EMeasureTemplateNames.min] = "min({columnFormula})",
+    _a$3[exports.EMeasureTemplateNames.max] = "max({columnFormula})",
+    _a$3[exports.EMeasureTemplateNames.sum] = "sum({columnFormula})",
+    _a$3);
+var measureInnerTemplateFormulas = (_b = {},
+    _b[exports.EMeasureInnerTemplateNames.begin] = "begin({columnFormula})",
+    _b[exports.EMeasureInnerTemplateNames.end] = "end({columnFormula})",
+    _b);
 
 /** Шаблон процессной метрики меры с режимом CONVERSION */
-var conversionTemplate = "countIf(\n    process(\n        minIf(\n            {startEventTimeFormula}, \n            {startEventNameFormula} = '{startEventName}'{startEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) < \n    process(\n        maxIf(\n            {endEventTimeFormula}, \n            {endEventNameFormula} = '{endEventName}'{endEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) \n    and \n    process(\n        countIf(\n            {startEventNameFormula} = '{startEventName}'{startEventFilters}\n        ) != 0, \n        {endCaseCaseIdFormula}\n    ) != 0\n) / countIf(\n    process(\n        countIf(\n            {startEventNameFormula} = '{startEventName}'{startEventFilters}\n        ) != 0, \n        {endCaseCaseIdFormula}\n    ) != 0\n)";
+var conversionTemplate = "countIf(\n    process(\n        minIf(\n            {startEventTimeFormula}, \n            {startEventNameFormula} = {startEventName}{startEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) < \n    process(\n        maxIf(\n            {endEventTimeFormula}, \n            {endEventNameFormula} = {endEventName}{endEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) \n    and \n    process(\n        countIf(\n            {startEventNameFormula} = {startEventName}{startEventFilters}\n        ) != 0, \n        {endCaseCaseIdFormula}\n    ) != 0\n) / countIf(\n    process(\n        countIf(\n            {startEventNameFormula} = {startEventName}{startEventFilters}\n        ) != 0, \n        {endCaseCaseIdFormula}\n    ) != 0\n)";
 /** На основе значения режима CONVERSION подготовить параметры для подстановки в шаблонную формулу */
 var prepareConversionParams = function (value) {
     if (!value.startEventName ||
@@ -1157,15 +1981,14 @@ var prepareConversionParams = function (value) {
         return null;
     }
     return {
-        objectFilters: "1",
         startEventTimeFormula: value.startEventTimeFormula,
         startEventNameFormula: value.startEventNameFormula,
         startEventFilters: convertFiltersToFormula(value.startEventFilters),
-        startEventName: value.startEventName,
+        startEventName: "'".concat(escapeSingularQuotes(value.startEventName), "'"),
         endEventTimeFormula: value.endEventTimeFormula,
         endCaseCaseIdFormula: value.endCaseCaseIdFormula,
         endEventNameFormula: value.endEventNameFormula,
-        endEventName: value.endEventName,
+        endEventName: "'".concat(escapeSingularQuotes(value.endEventName), "'"),
         endEventFilters: convertFiltersToFormula(value.endEventFilters),
     };
 };
@@ -1173,7 +1996,7 @@ var prepareConversionParams = function (value) {
 /** Шаблоны процессных метрик меры с режимом DURATION */
 var durationTemplates = (function () {
     var _a;
-    var innerTemplate = "\n    timeDiff(\n        process(\n            {startEventAggregationName}(\n                {startEventTimeFormula}, \n                {startEventNameFormula} = '{startEventName}'{startEventFilters}\n            ), \n            {endCaseCaseIdFormula}\n        ), \n        process(\n            {endEventAggregationName}(\n                {endEventTimeFormula}, \n                {endEventNameFormula} = '{endEventName}'{endEventFilters}\n            ), \n            {endCaseCaseIdFormula}\n        )\n    ), \n    process(\n        {startEventAggregationName}(\n            {startEventTimeFormula}, \n            {startEventNameFormula} = '{startEventName}'{startEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) < \n    process(\n        {endEventAggregationName}(\n            {endEventTimeFormula}, \n            {endEventNameFormula} = '{endEventName}'{endEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) \n    and \n    process(\n        countIf(\n            {startEventNameFormula} = '{startEventName}'{startEventFilters}\n        ) != 0, \n        {endCaseCaseIdFormula}\n    ) != 0\n  ";
+    var innerTemplate = "\n    timeDiff(\n        process(\n            {startEventAggregationName}(\n                {startEventTimeFormula}, \n                {startEventNameFormula} = {startEventName}{startEventFilters}\n            ), \n            {endCaseCaseIdFormula}\n        ), \n        process(\n            {endEventAggregationName}(\n                {endEventTimeFormula}, \n                {endEventNameFormula} = {endEventName}{endEventFilters}\n            ), \n            {endCaseCaseIdFormula}\n        )\n    ), \n    process(\n        {startEventAggregationName}(\n            {startEventTimeFormula}, \n            {startEventNameFormula} = {startEventName}{startEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) < \n    process(\n        {endEventAggregationName}(\n            {endEventTimeFormula}, \n            {endEventNameFormula} = {endEventName}{endEventFilters}\n        ), \n        {endCaseCaseIdFormula}\n    ) \n    and \n    process(\n        countIf(\n            {startEventNameFormula} = {startEventName}{startEventFilters}\n        ) != 0, \n        {endCaseCaseIdFormula}\n    ) != 0\n  ";
     return _a = {},
         _a[exports.EDurationTemplateName.avg] = "avgIf(".concat(innerTemplate, ")"),
         _a[exports.EDurationTemplateName.median] = "medianIf(".concat(innerTemplate, ")"),
@@ -1196,32 +2019,31 @@ var prepareDurationParams = function (value) {
         return appearance === exports.EEventAppearances.FIRST ? "minIf" : "maxIf";
     };
     return {
-        objectFilters: "1",
         startEventTimeFormula: value.startEventTimeFormula,
         startEventNameFormula: value.startEventNameFormula,
         startEventFilters: convertFiltersToFormula(value.startEventFilters),
-        startEventName: value.startEventName,
+        startEventName: "'".concat(escapeSingularQuotes(value.startEventName), "'"),
         startEventAggregationName: getAggregationNameByAppearances(value.startEventAppearances),
         endEventTimeFormula: value.endEventTimeFormula,
         endCaseCaseIdFormula: value.endCaseCaseIdFormula,
         endEventNameFormula: value.endEventNameFormula,
-        endEventName: value.endEventName,
+        endEventName: "'".concat(escapeSingularQuotes(value.endEventName), "'"),
         endEventFilters: convertFiltersToFormula(value.endEventFilters),
         endEventAggregationName: getAggregationNameByAppearances(value.endEventAppearances),
     };
 };
 
 function createAnyEventTemplate(aggregatePart) {
-    return "{outerAggregation}If(process(".concat(aggregatePart, ", {caseCaseIdFormula}), {objectFilters})");
+    return "{outerAggregation}(process(".concat(aggregatePart, ", {caseCaseIdFormula}))");
 }
 function createSpecificEventTemplate(fn, additionalFn) {
-    return "{outerAggregation}If(process(".concat(fn, "(").concat(additionalFn ? "".concat(additionalFn, " ") : "", "{columnFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula}), {objectFilters})");
+    return "{outerAggregation}(process(".concat(fn, "(").concat(additionalFn ? "".concat(additionalFn, " ") : "", "{columnFormula}, {eventNameFormula} = {eventName}{filters}), {caseCaseIdFormula}))");
 }
 function createTopLikeTemplate(template) {
     return function (outerAggregation) {
         return outerAggregation === exports.EOuterAggregation.top
-            ? "{outerAggregation}KIf(1)(".concat(template, ", {objectFilters})[1]")
-            : "{outerAggregation}If(".concat(template, ", {objectFilters})");
+            ? "{outerAggregation}K(1)(".concat(template, ")[1]")
+            : "{outerAggregation}(".concat(template, ")");
     };
 }
 function createAggregationTemplate(templateName, _a) {
@@ -1268,9 +2090,9 @@ function createAggregationTemplate(templateName, _a) {
                 ? createAnyEventTemplate("argMax({columnFormula}, {eventTimeFormula})")
                 : createTopLikeTemplate(lastValueTemplate)(outerAggregation);
         case exports.EMeasureAggregationTemplateName.countExecutions:
-            return "{outerAggregation}If(".concat(countExecutionsTemplate, ", {objectFilters})");
+            return "{outerAggregation}(".concat(countExecutionsTemplate, ")");
         case exports.EMeasureAggregationTemplateName.countReworks:
-            return "{outerAggregation}If(".concat(countReworksTemplate, ", {objectFilters})");
+            return "{outerAggregation}(".concat(countReworksTemplate, ")");
     }
 }
 
@@ -1284,19 +2106,24 @@ function getMeasureFormula(_a) {
         return (_b = value.formula) !== null && _b !== void 0 ? _b : "";
     }
     if (value.mode === exports.EWidgetIndicatorValueModes.TEMPLATE) {
-        var templateName = value.templateName, tableName = value.tableName, columnName = value.columnName;
+        var templateName = value.templateName, tableName = value.tableName, columnName = value.columnName, innerTemplateName = value.innerTemplateName;
         var templateFormula = measureTemplateFormulas[templateName];
         if (!templateFormula || !tableName || !columnName) {
             return "";
         }
-        return fillTemplateString(templateFormula, {
-            columnFormula: generateColumnFormula(tableName, columnName),
+        var columnFormula = innerTemplateName
+            ? fillTemplateSql(measureInnerTemplateFormulas[innerTemplateName], {
+                columnFormula: generateColumnFormula(tableName, columnName),
+            })
+            : generateColumnFormula(tableName, columnName);
+        return fillTemplateSql(templateFormula, {
+            columnFormula: columnFormula,
         });
     }
     if (value.mode === exports.EWidgetIndicatorValueModes.AGGREGATION) {
         var preparedParams = prepareMeasureAggregationParams(value);
         return preparedParams
-            ? fillTemplateString(createAggregationTemplate(value.templateName, {
+            ? fillTemplateSql(createAggregationTemplate(value.templateName, {
                 outerAggregation: preparedParams.outerAggregation,
                 anyEvent: value.anyEvent,
             }), preparedParams)
@@ -1307,28 +2134,28 @@ function getMeasureFormula(_a) {
         if (!preparedParams) {
             return "";
         }
-        return fillTemplateString(conversionTemplate, preparedParams);
+        return fillTemplateSql(conversionTemplate, preparedParams);
     }
     if (value.mode === exports.EWidgetIndicatorValueModes.DURATION) {
         var preparedParams = prepareDurationParams(value);
         if (!preparedParams) {
             return "";
         }
-        return fillTemplateString(durationTemplates[value.templateName], preparedParams);
+        return fillTemplateSql(durationTemplates[value.templateName], preparedParams);
     }
     return "";
 }
 
-var _a$1;
+var _a$2;
 exports.EEventMeasureTemplateNames = void 0;
 (function (EEventMeasureTemplateNames) {
     EEventMeasureTemplateNames["eventsCount"] = "eventsCount";
     EEventMeasureTemplateNames["reworksCount"] = "reworksCount";
 })(exports.EEventMeasureTemplateNames || (exports.EEventMeasureTemplateNames = {}));
-var eventMeasureTemplateFormulas = (_a$1 = {},
-    _a$1[exports.EEventMeasureTemplateNames.eventsCount] = "count()",
-    _a$1[exports.EEventMeasureTemplateNames.reworksCount] = "count() - uniqExact({caseCaseIdFormula})",
-    _a$1);
+var eventMeasureTemplateFormulas = (_a$2 = {},
+    _a$2[exports.EEventMeasureTemplateNames.eventsCount] = "count()",
+    _a$2[exports.EEventMeasureTemplateNames.reworksCount] = "count() - uniqExact({caseCaseIdFormula})",
+    _a$2);
 
 function getEventMeasureFormula(_a, process) {
     var value = _a.value;
@@ -1340,21 +2167,21 @@ function getEventMeasureFormula(_a, process) {
     }
     if (value.mode === exports.EWidgetIndicatorValueModes.TEMPLATE) {
         var templateFormula = eventMeasureTemplateFormulas[value.templateName];
-        return templateFormula && fillTemplateString(templateFormula, process);
+        return templateFormula && fillTemplateSql(templateFormula, process);
     }
     return "";
 }
 
-var _a;
+var _a$1;
 exports.ETransitionMeasureTemplateNames = void 0;
 (function (ETransitionMeasureTemplateNames) {
     ETransitionMeasureTemplateNames["transitionsCount"] = "transitionsCount";
     ETransitionMeasureTemplateNames["medianTime"] = "medianTime";
 })(exports.ETransitionMeasureTemplateNames || (exports.ETransitionMeasureTemplateNames = {}));
-var transitionMeasureTemplateFormulas = (_a = {},
-    _a[exports.ETransitionMeasureTemplateNames.transitionsCount] = "count()",
-    _a[exports.ETransitionMeasureTemplateNames.medianTime] = "medianExact(date_diff(second, begin({eventTimeFormula}), end({eventTimeFormula})))",
-    _a);
+var transitionMeasureTemplateFormulas = (_a$1 = {},
+    _a$1[exports.ETransitionMeasureTemplateNames.transitionsCount] = "count()",
+    _a$1[exports.ETransitionMeasureTemplateNames.medianTime] = "medianExact(date_diff(second, begin({eventTimeFormula}), end({eventTimeFormula})))",
+    _a$1);
 
 function getTransitionMeasureFormula(_a, process) {
     var value = _a.value;
@@ -1366,35 +2193,11 @@ function getTransitionMeasureFormula(_a, process) {
     }
     if (value.mode === exports.EWidgetIndicatorValueModes.TEMPLATE) {
         var templateFormula = transitionMeasureTemplateFormulas[value.templateName];
-        return templateFormula && fillTemplateString(templateFormula, process);
+        return templateFormula && fillTemplateSql(templateFormula, process);
     }
     return "";
 }
 
-// Типы, используемые в значениях элементов управления.
-exports.EWidgetFilterMode = void 0;
-(function (EWidgetFilterMode) {
-    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
-    EWidgetFilterMode["SINGLE"] = "SINGLE";
-    EWidgetFilterMode["DISABLED"] = "DISABLED";
-})(exports.EWidgetFilterMode || (exports.EWidgetFilterMode = {}));
-exports.EMarkdownDisplayMode = void 0;
-(function (EMarkdownDisplayMode) {
-    EMarkdownDisplayMode["NONE"] = "NONE";
-    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
-})(exports.EMarkdownDisplayMode || (exports.EMarkdownDisplayMode = {}));
-exports.EDisplayConditionMode = void 0;
-(function (EDisplayConditionMode) {
-    EDisplayConditionMode["DISABLED"] = "DISABLED";
-    EDisplayConditionMode["FORMULA"] = "FORMULA";
-    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
-})(exports.EDisplayConditionMode || (exports.EDisplayConditionMode = {}));
-exports.EFontWeight = void 0;
-(function (EFontWeight) {
-    EFontWeight["NORMAL"] = "NORMAL";
-    EFontWeight["BOLD"] = "BOLD";
-})(exports.EFontWeight || (exports.EFontWeight = {}));
-
 function checkDisplayCondition(displayCondition, variables) {
     var _a;
     if ((displayCondition === null || displayCondition === void 0 ? void 0 : displayCondition.mode) === exports.EDisplayConditionMode.VARIABLE) {
@@ -1528,7 +2331,7 @@ var getFormulaFilterValues = function (filterValue) {
             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(subtractDurationFromDate(new Date(), Number(lastTimeValue !== null && lastTimeValue !== void 0 ? lastTimeValue : 0), lastTimeUnit), showTime),
                     convertDateToClickHouse(new Date(), showTime),
                 ]);
             }
@@ -1550,7 +2353,9 @@ var getFormulaFilterValues = function (filterValue) {
     }
     return [];
 };
-var applyIndexToArrayFormula = function (formula, index) { return "".concat(formula, "[").concat(index, "]"); };
+var applyIndexToArrayFormula = function (formula, index) {
+    return "(".concat(formula, ")[").concat(index, "]");
+};
 var mapFormulaFilterToCalculatorInput = function (filterValue) {
     if (!filterValue) {
         return null;
@@ -1558,7 +2363,7 @@ var mapFormulaFilterToCalculatorInput = function (filterValue) {
     if (!isFormulaFilterValue(filterValue)) {
         return {
             dbDataType: exports.EClickHouseBaseTypes.Bool,
-            formula: fillTemplateString(displayConditionTemplate, {
+            formula: fillTemplateSql(displayConditionTemplate, {
                 formula: prepareFormulaForSql(filterValue.formula),
             }),
             values: ["true"],
@@ -1593,6 +2398,46 @@ var mapFormulaFiltersToInputs = function (filters) {
     return compactMap(filters, mapFormulaFilterToCalculatorInput);
 };
 
+var _a;
+var intervalByUnit = (_a = {},
+    _a[exports.EDimensionProcessFilterTimeUnit.YEARS] = "year",
+    _a[exports.EDimensionProcessFilterTimeUnit.MONTHS] = "month",
+    _a[exports.EDimensionProcessFilterTimeUnit.DAYS] = "day",
+    _a[exports.EDimensionProcessFilterTimeUnit.HOURS] = "hour",
+    _a[exports.EDimensionProcessFilterTimeUnit.MINUTES] = "minute",
+    _a);
+function mapDimensionProcessFilterToCalculatorInput(filter) {
+    var formula = filter.value.mode === exports.EWidgetIndicatorValueModes.FORMULA
+        ? filter.value.formula
+        : getProcessDimensionValueFormula(filter.value);
+    if (formula === undefined) {
+        throw new Error("Formula generation error");
+    }
+    var _a = filter.condition, timeUnit = _a.timeUnit, filteringMethod = _a.filteringMethod, values = _a.values;
+    if (filteringMethod === "LAST_TIME") {
+        if (!timeUnit) {
+            throw new Error("Missing time unit");
+        }
+        return {
+            dbDataType: exports.EClickHouseBaseTypes.Bool,
+            formula: "date_diff('".concat(intervalByUnit[timeUnit], "', ").concat(formula, ", now())"),
+            values: values,
+            filteringMethod: formulaFilterMethods.LESS_THAN_OR_EQUAL_TO,
+        };
+    }
+    return { formula: formula, filteringMethod: filteringMethod, values: values, dbDataType: filter.dbDataType };
+}
+
+var mapSettingsFilterToCalculatorInput = function (filter) {
+    if (isDimensionProcessFilter(filter)) {
+        return mapDimensionProcessFilterToCalculatorInput(filter);
+    }
+    return mapFormulaFilterToCalculatorInput(filter);
+};
+var mapSettingsFiltersToInputs = function (filters) {
+    return compactMap(filters, mapSettingsFilterToCalculatorInput);
+};
+
 function mapMeasureToInput(measure, variables, addFormulas) {
     if (addFormulas === void 0) { addFormulas = function () { return new Map(); }; }
     var mainFormula = getMeasureFormula(measure);
@@ -1698,8 +2543,8 @@ exports.ESortDirection = void 0;
  * Если к разрезу иерархии применяется INCLUDE-фильтр с одним значением - выбираем следующий за ним разрез
  * Если к разрезу иерархии применяется INCLUDE-фильтр с несколькими значениями - выбираем данный разрез
  */
-function selectDimensionFromHierarchy(_a, filters) {
-    var hierarchyDimensions = _a.hierarchyDimensions;
+function selectDimensionFromHierarchy(hierarchy, filters) {
+    var hierarchyDimensions = hierarchy.hierarchyDimensions; hierarchy.displayCondition;
     var _loop_1 = function (i) {
         var dimension = hierarchyDimensions[i];
         // todo: widgets - возможно, стоит использовать Map фильтров для быстрого поиска
@@ -1712,14 +2557,18 @@ function selectDimensionFromHierarchy(_a, filters) {
             return "continue";
         }
         var selectionIndex = matchedFilter.values.length > 1 ? i : Math.min(i + 1, hierarchyDimensions.length - 1);
-        return { value: hierarchyDimensions[selectionIndex] };
+        var dimensionFromHierarchy_1 = hierarchyDimensions[selectionIndex];
+        return { value: (dimensionFromHierarchy_1 &&
+                inheritDisplayConditionFromHierarchy(dimensionFromHierarchy_1, hierarchy)) };
     };
     for (var i = hierarchyDimensions.length - 1; i >= 0; i--) {
         var state_1 = _loop_1(i);
         if (typeof state_1 === "object")
             return state_1.value;
     }
-    return hierarchyDimensions[0];
+    var dimensionFromHierarchy = hierarchyDimensions[0];
+    return (dimensionFromHierarchy &&
+        inheritDisplayConditionFromHierarchy(dimensionFromHierarchy, hierarchy));
 }
 
 var getDefaultSortOrders = function (_a) {
@@ -1735,7 +2584,8 @@ var getDefaultSortOrders = function (_a) {
     /** Если есть временной разрез, то авто-сортировка по первому такому разрезу (по возрастанию) */
     var timeDimension = dimensions.find(function (dimension) {
         var _a;
-        return ((_a = dimension.format) === null || _a === void 0 ? void 0 : _a.value) &&
+        return ((_a = dimension.format) === null || _a === void 0 ? void 0 : _a.mode) === exports.EFormatOrFormattingMode.BASE &&
+            dimension.format.value !== undefined &&
             [
                 exports.EFormatTypes.DATE,
                 exports.EFormatTypes.MONTH,
@@ -1794,9 +2644,9 @@ function mapSortingToInputs(_a) {
             return;
         }
         if (getIndicatorType(value.group, indicator) === exports.EWidgetIndicatorType.DIMENSION) {
-            var activeDimensions = isDimensionsHierarchy(indicator)
+            var activeDimensions = (isDimensionsHierarchy(indicator)
                 ? selectDimensionFromHierarchy(indicator, filters)
-                : indicator;
+                : indicator);
             var formula = activeDimensions && getDimensionFormula(activeDimensions);
             if (!formula || !checkDisplayCondition(indicator.displayCondition, variables)) {
                 return;
@@ -1810,10 +2660,11 @@ function mapSortingToInputs(_a) {
                     : undefined,
             };
         }
+        var measure = indicator;
         return {
-            formula: getMeasureFormula(indicator),
+            formula: getMeasureFormula(measure),
             direction: direction,
-            dbDataType: indicator.dbDataType,
+            dbDataType: measure.dbDataType,
         };
     });
     return sortOrder;
@@ -1827,8 +2678,7 @@ function prepareSortOrders(_a) {
 var replaceHierarchiesWithDimensions = function (dimensions, filters) {
     return compactMap(dimensions, function (indicator) {
         if (isDimensionsHierarchy(indicator)) {
-            var selectedDimension = selectDimensionFromHierarchy(indicator, filters);
-            return (selectedDimension && replaceDisplayCondition(selectedDimension, indicator.displayCondition));
+            return selectDimensionFromHierarchy(indicator, filters);
         }
         return indicator;
     });
@@ -1899,6 +2749,12 @@ exports.EUnitMode = void 0;
     EUnitMode["PIXEL"] = "PIXEL";
     EUnitMode["PERCENT"] = "PERCENT";
 })(exports.EUnitMode || (exports.EUnitMode = {}));
+var defaultActionsConfig = {
+    OPEN_URL: { availability: true },
+    UPDATE_VARIABLE: { availability: true },
+    EXECUTE_SCRIPT: { availability: true },
+    OPEN_VIEW: { availability: true },
+};
 
 exports.ESelectOptionTypes = void 0;
 (function (ESelectOptionTypes) {
@@ -2087,6 +2943,120 @@ var getColorByIndex = function (index) {
     return color;
 };
 
+var WidgetPresetSettingsSchema = function (z) {
+    return BaseWidgetSettingsSchema(z)
+        .pick({
+        filterMode: true,
+        ignoreFilters: true,
+        stateName: true,
+        titleColor: true,
+        titleSize: true,
+        titleWeight: true,
+        paddings: true,
+    })
+        .extend({
+        textSize: z.number().default(12),
+    });
+};
+
+/**
+ * Привязывает мета-информацию о теме к Zod-схеме
+ *
+ * @template Value - Тип значения схемы
+ * @template Theme - Тип темы (по умолчанию ITheme)
+ *
+ * @param scheme - Zod схема для привязки
+ * @param selectThemeValue - Функция, возвращающая значение из темы
+ *
+ * @returns Zod схему с мета-информацией о теме
+ *
+ * @example
+ * // Базовое использование
+ * textSize: themed(
+ *   z.number().default(12),
+ *   (theme) => theme.textSize
+ * )
+ */
+var themed = function (scheme, selectThemeValue) {
+    var _a;
+    return scheme.meta((_a = {}, _a[exports.ESettingsSchemaMetaKey.themeValue] = selectThemeValue, _a));
+};
+
+var ColorBaseSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.BASE),
+        value: z.string(),
+    });
+};
+var ColorRuleSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.RULE),
+        formula: FormulaSchema(z),
+    });
+};
+var ColorAutoSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.AUTO),
+    });
+};
+var ColorDisabledSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.DISABLED),
+    });
+};
+var ColorGradientSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.GRADIENT),
+        startValue: z.string(),
+        endValue: z.string(),
+        classCount: z.number().min(3).max(10).nullish(),
+    });
+};
+var ColorFormulaSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.FORMULA),
+        formula: FormulaSchema(z),
+    });
+};
+var ColorValuesSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.VALUES),
+        items: z
+            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
+            .default([]),
+    });
+};
+var ColorByDimensionSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.BY_DIMENSION),
+        /** Имя разреза из области видимости правила отображения */
+        dimensionName: z.string(),
+        items: z
+            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
+            .default([]),
+    });
+};
+var ColoredValueSchema = function (z) {
+    return z.object({
+        value: z.string(),
+        color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]),
+    });
+};
+var ColorSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        ColorAutoSchema(z),
+        ColorDisabledSchema(z),
+        ColorBaseSchema(z),
+        ColorRuleSchema(z),
+        ColorGradientSchema(z),
+        ColorFormulaSchema(z),
+        ColorValuesSchema(z),
+        ColorByDimensionSchema(z),
+    ])
+        .default({ mode: exports.EColorMode.AUTO });
+};
+
 Object.defineProperty(exports, "ELanguages", {
     enumerable: true,
     get: function () { return localization$1.ELanguages; }
@@ -2095,6 +3065,81 @@ Object.defineProperty(exports, "EFilteringMethodValues", {
     enumerable: true,
     get: function () { return baseFilter.EFilteringMethodValues; }
 });
+exports.ActionButtonSchema = ActionButtonSchema;
+exports.ActionDrillDownSchema = ActionDrillDownSchema;
+exports.ActionGoToURLSchema = ActionGoToURLSchema;
+exports.ActionOnClickParameterSchema = ActionOnClickParameterSchema;
+exports.ActionOpenInSchema = ActionOpenInSchema;
+exports.ActionOpenViewSchema = ActionOpenViewSchema;
+exports.ActionRunScriptSchema = ActionRunScriptSchema;
+exports.ActionSchema = ActionSchema;
+exports.ActionUpdateVariableSchema = ActionUpdateVariableSchema;
+exports.ActionsOnClickSchema = ActionsOnClickSchema;
+exports.AutoIdentifiedArrayItemSchema = AutoIdentifiedArrayItemSchema;
+exports.BaseWidgetSettingsSchema = BaseWidgetSettingsSchema;
+exports.ColorAutoSchema = ColorAutoSchema;
+exports.ColorBaseSchema = ColorBaseSchema;
+exports.ColorByDimensionSchema = ColorByDimensionSchema;
+exports.ColorDisabledSchema = ColorDisabledSchema;
+exports.ColorFormulaSchema = ColorFormulaSchema;
+exports.ColorGradientSchema = ColorGradientSchema;
+exports.ColorRuleSchema = ColorRuleSchema;
+exports.ColorSchema = ColorSchema;
+exports.ColorValuesSchema = ColorValuesSchema;
+exports.ColoredValueSchema = ColoredValueSchema;
+exports.ColumnIndicatorValueSchema = ColumnIndicatorValueSchema;
+exports.DimensionProcessFilterSchema = DimensionProcessFilterSchema;
+exports.DimensionValueSchema = DimensionValueSchema;
+exports.DisplayConditionSchema = DisplayConditionSchema;
+exports.ExtendedFormulaFilterValueSchema = ExtendedFormulaFilterValueSchema;
+exports.FormatSchema = FormatSchema;
+exports.FormattingSchema = FormattingSchema;
+exports.FormulaFilterValueSchema = FormulaFilterValueSchema;
+exports.FormulaNullableSchema = FormulaNullableSchema;
+exports.FormulaSchema = FormulaSchema;
+exports.KeyNullableSchema = KeyNullableSchema;
+exports.MarkdownMeasureSchema = MarkdownMeasureSchema;
+exports.MeasureValueSchema = MeasureValueSchema;
+exports.NameNullableSchema = NameNullableSchema;
+exports.ParameterFromAggregationSchema = ParameterFromAggregationSchema;
+exports.ParameterFromColumnSchema = ParameterFromColumnSchema;
+exports.ParameterFromDataModelSchema = ParameterFromDataModelSchema;
+exports.ParameterFromDynamicListSchema = ParameterFromDynamicListSchema;
+exports.ParameterFromEndEventSchema = ParameterFromEndEventSchema;
+exports.ParameterFromEventSchema = ParameterFromEventSchema;
+exports.ParameterFromFormulaSchema = ParameterFromFormulaSchema;
+exports.ParameterFromManualInputSchema = ParameterFromManualInputSchema;
+exports.ParameterFromStartEventSchema = ParameterFromStartEventSchema;
+exports.ParameterFromStaticListSchema = ParameterFromStaticListSchema;
+exports.ParameterFromVariableSchema = ParameterFromVariableSchema;
+exports.ProcessIndicatorSchema = ProcessIndicatorSchema;
+exports.ProcessIndicatorValueSchema = ProcessIndicatorValueSchema;
+exports.RangeSchema = RangeSchema;
+exports.SettingsFilterSchema = SettingsFilterSchema;
+exports.SortDirectionSchema = SortDirectionSchema;
+exports.SortOrderSchema = SortOrderSchema;
+exports.ViewActionParameterSchema = ViewActionParameterSchema;
+exports.ViewActionSchema = ViewActionSchema;
+exports.WidgetActionParameterSchema = WidgetActionParameterSchema;
+exports.WidgetActionSchema = WidgetActionSchema;
+exports.WidgetColumnIndicatorSchema = WidgetColumnIndicatorSchema;
+exports.WidgetDimensionHierarchySchema = WidgetDimensionHierarchySchema;
+exports.WidgetDimensionInHierarchySchema = WidgetDimensionInHierarchySchema;
+exports.WidgetDimensionSchema = WidgetDimensionSchema;
+exports.WidgetIndicatorAggregationValueSchema = WidgetIndicatorAggregationValueSchema;
+exports.WidgetIndicatorConversionValueSchema = WidgetIndicatorConversionValueSchema;
+exports.WidgetIndicatorDurationValueSchema = WidgetIndicatorDurationValueSchema;
+exports.WidgetIndicatorFormulaValueSchema = WidgetIndicatorFormulaValueSchema;
+exports.WidgetIndicatorSchema = WidgetIndicatorSchema;
+exports.WidgetIndicatorTemplateValueSchema = WidgetIndicatorTemplateValueSchema;
+exports.WidgetIndicatorTimeValueSchema = WidgetIndicatorTimeValueSchema;
+exports.WidgetMeasureAggregationValueSchema = WidgetMeasureAggregationValueSchema;
+exports.WidgetMeasureSchema = WidgetMeasureSchema;
+exports.WidgetPresetSettingsSchema = WidgetPresetSettingsSchema;
+exports.WidgetSortingIndicatorSchema = WidgetSortingIndicatorSchema;
+exports.WidgetSortingValueSchema = WidgetSortingValueSchema;
+exports.apiVersion = apiVersion;
+exports.apiVersions = apiVersions;
 exports.applyIndexToArrayFormula = applyIndexToArrayFormula;
 exports.bindContentWithIndicator = bindContentWithIndicator;
 exports.bindContentsWithIndicators = bindContentsWithIndicators;
@@ -2110,6 +3155,7 @@ exports.createEscaper = createEscaper;
 exports.createMeasureAggregationTemplate = createAggregationTemplate;
 exports.curlyBracketsContentPattern = curlyBracketsContentPattern;
 exports.dashboardLinkRegExp = dashboardLinkRegExp;
+exports.defaultActionsConfig = defaultActionsConfig;
 exports.dimensionAggregationTemplates = dimensionAggregationTemplates;
 exports.dimensionTemplateFormulas = dimensionTemplateFormulas;
 exports.displayConditionTemplate = displayConditionTemplate;
@@ -2118,7 +3164,7 @@ exports.durationTemplates = durationTemplates;
 exports.escapeCurlyBracketLinkName = escapeCurlyBracketLinkName;
 exports.escapeDoubleQuoteLinkName = escapeDoubleQuoteLinkName;
 exports.eventMeasureTemplateFormulas = eventMeasureTemplateFormulas;
-exports.fillTemplateString = fillTemplateString;
+exports.fillTemplateSql = fillTemplateSql;
 exports.formattingConfig = formattingConfig;
 exports.formulaFilterMethods = formulaFilterMethods;
 exports.generateColumnFormula = generateColumnFormula;
@@ -2129,8 +3175,11 @@ exports.getDisplayConditionFormula = getDisplayConditionFormula;
 exports.getEventMeasureFormula = getEventMeasureFormula;
 exports.getLocalizedText = getLocalizedText;
 exports.getMeasureFormula = getMeasureFormula;
+exports.getProcessDimensionValueFormula = getProcessDimensionValueFormula;
 exports.getRuleColor = getRuleColor;
 exports.getTransitionMeasureFormula = getTransitionMeasureFormula;
+exports.inheritDisplayConditionFromHierarchy = inheritDisplayConditionFromHierarchy;
+exports.isDimensionProcessFilter = isDimensionProcessFilter;
 exports.isDimensionsHierarchy = isDimensionsHierarchy;
 exports.isFormulaFilterValue = isFormulaFilterValue;
 exports.isValidColor = isValidColor;
@@ -2139,8 +3188,10 @@ exports.mapEventMeasuresToInputs = mapEventMeasuresToInputs;
 exports.mapFormulaFilterToCalculatorInput = mapFormulaFilterToCalculatorInput;
 exports.mapFormulaFiltersToInputs = mapFormulaFiltersToInputs;
 exports.mapMeasuresToInputs = mapMeasuresToInputs;
+exports.mapSettingsFiltersToInputs = mapSettingsFiltersToInputs;
 exports.mapSortingToInputs = mapSortingToInputs;
 exports.mapTransitionMeasuresToInputs = mapTransitionMeasuresToInputs;
+exports.measureInnerTemplateFormulas = measureInnerTemplateFormulas;
 exports.measureTemplateFormulas = measureTemplateFormulas;
 exports.parseClickHouseType = parseClickHouseType;
 exports.parseIndicatorLink = parseIndicatorLink;
@@ -2156,6 +3207,7 @@ exports.replaceDisplayCondition = replaceDisplayCondition;
 exports.replaceFiltersBySelection = replaceFiltersBySelection;
 exports.replaceHierarchiesWithDimensions = replaceHierarchiesWithDimensions;
 exports.selectDimensionFromHierarchy = selectDimensionFromHierarchy;
+exports.themed = themed;
 exports.timeTemplates = timeTemplates;
 exports.transitionMeasureTemplateFormulas = transitionMeasureTemplateFormulas;
 exports.unescapeSpecialCharacters = unescapeSpecialCharacters;