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

package/dist/index.esm.js

@@ -2,6 +2,40 @@ import { Localization } from '@infomaximum/localization';
 export { ELanguages } from '@infomaximum/localization';
 export { EFilteringMethodValues } from '@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);
+
 var EWidgetActionInputMethod;
 (function (EWidgetActionInputMethod) {
     EWidgetActionInputMethod["COLUMN"] = "COLUMN";
@@ -22,6 +56,7 @@ var EActionTypes;
     EActionTypes["UPDATE_VARIABLE"] = "UPDATE_VARIABLE";
     EActionTypes["EXECUTE_SCRIPT"] = "EXECUTE_SCRIPT";
     EActionTypes["OPEN_VIEW"] = "OPEN_VIEW";
+    EActionTypes["DRILL_DOWN"] = "DRILL_DOWN";
 })(EActionTypes || (EActionTypes = {}));
 var EViewMode;
 (function (EViewMode) {
@@ -64,6 +99,46 @@ var EActionButtonsTypes;
     EActionButtonsTypes["SECONDARY"] = "primary-outlined";
 })(EActionButtonsTypes || (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(EFontWeight).default(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(EWidgetFilterMode).default(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),
+    });
+};
+
 var ESimpleDataType;
 (function (ESimpleDataType) {
     ESimpleDataType["OTHER"] = "OTHER";
@@ -76,247 +151,6 @@ var ESimpleDataType;
     ESimpleDataType["BOOLEAN"] = "BOOLEAN";
 })(ESimpleDataType || (ESimpleDataType = {}));
 
-var prepareValuesForSql = function (simpleType, values) {
-    return simpleType === ESimpleDataType.INTEGER ||
-        simpleType === ESimpleDataType.FLOAT ||
-        simpleType === 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;
-};
-
-var ECalculatorFilterMethods;
-(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";
-})(ECalculatorFilterMethods || (ECalculatorFilterMethods = {}));
-
-var formulaFilterMethods = __assign(__assign({}, ECalculatorFilterMethods), { LAST_TIME: "LAST_TIME" });
-var EProcessFilterNames;
-(function (EProcessFilterNames) {
-    /** Наличие события */
-    EProcessFilterNames["presenceOfEvent"] = "presenceOfEvent";
-    /** Количество повторов события */
-    EProcessFilterNames["repetitionOfEvent"] = "repetitionOfEvent";
-    /** Наличие перехода */
-    EProcessFilterNames["presenceOfTransition"] = "presenceOfTransition";
-    /** Длительность перехода */
-    EProcessFilterNames["durationOfTransition"] = "durationOfTransition";
-})(EProcessFilterNames || (EProcessFilterNames = {}));
-var EFormulaFilterFieldKeys;
-(function (EFormulaFilterFieldKeys) {
-    EFormulaFilterFieldKeys["date"] = "date";
-    EFormulaFilterFieldKeys["dateRange"] = "dateRange";
-    EFormulaFilterFieldKeys["numberRange"] = "numberRange";
-    EFormulaFilterFieldKeys["string"] = "string";
-    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
-    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
-    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
-})(EFormulaFilterFieldKeys || (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;
-    };
-}
-
-var EClickHouseBaseTypes;
-(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";
-})(EClickHouseBaseTypes || (EClickHouseBaseTypes = {}));
-var stringTypes = ["String", "FixedString"];
-var parseClickHouseType = memoize(function (type) {
-    if (isNil(type)) {
-        return {
-            simpleBaseType: ESimpleDataType.OTHER,
-            dbBaseDataType: undefined,
-            containers: [],
-            simpleType: 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") ? 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 ESimpleDataType.INTEGER;
-    }
-    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
-        return ESimpleDataType.FLOAT;
-    }
-    if (stringTypes.some(isSourceTypeStartsWith)) {
-        return ESimpleDataType.STRING;
-    }
-    if (isSourceTypeStartsWith("DateTime64")) {
-        return ESimpleDataType.DATETIME64;
-    }
-    if (isSourceTypeStartsWith("DateTime")) {
-        return ESimpleDataType.DATETIME;
-    }
-    if (isSourceTypeStartsWith("Date")) {
-        return ESimpleDataType.DATE;
-    }
-    if (isSourceTypeStartsWith("Bool")) {
-        return ESimpleDataType.BOOLEAN;
-    }
-    return 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 EFormatTypes;
 (function (EFormatTypes) {
     /** Дата */
@@ -610,7 +444,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;
+};
+
+var EWidgetIndicatorType;
+(function (EWidgetIndicatorType) {
+    EWidgetIndicatorType["MEASURE"] = "MEASURE";
+    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
+    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
+    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
+    EWidgetIndicatorType["SORTING"] = "SORTING";
+})(EWidgetIndicatorType || (EWidgetIndicatorType = {}));
+var EOuterAggregation;
+(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";
+})(EOuterAggregation || (EOuterAggregation = {}));
+/** Режимы значения показателя (на основе чего генерируется формула) */
+var EWidgetIndicatorValueModes;
+(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";
+})(EWidgetIndicatorValueModes || (EWidgetIndicatorValueModes = {}));
+/** Режимы сортировки (на что ссылается сортировка) */
+var ESortingValueModes;
+(function (ESortingValueModes) {
+    /** Сортировка по формуле */
+    ESortingValueModes["FORMULA"] = "FORMULA";
+    /** Сортировка по показателю(разрезу или мере) виджета */
+    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
+})(ESortingValueModes || (ESortingValueModes = {}));
+var EFormatOrFormattingMode;
+(function (EFormatOrFormattingMode) {
+    EFormatOrFormattingMode["BASE"] = "BASE";
+    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
+})(EFormatOrFormattingMode || (EFormatOrFormattingMode = {}));
+function inheritDisplayConditionFromHierarchy(dimension, hierarchy) {
+    return __assign(__assign({}, dimension), { displayCondition: hierarchy.displayCondition });
+}
+/** Тип показателя */
+var EIndicatorType;
+(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";
+})(EIndicatorType || (EIndicatorType = {}));
+/** Обобщенные типы значений переменных */
+var ESimpleInputType;
+(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";
+})(ESimpleInputType || (ESimpleInputType = {}));
+function isDimensionsHierarchy(indicator) {
+    return "hierarchyDimensions" in indicator;
+}
+var OuterAggregation;
+(function (OuterAggregation) {
+    OuterAggregation["avg"] = "avgIf";
+    OuterAggregation["median"] = "medianIf";
+    OuterAggregation["count"] = "countIf";
+    OuterAggregation["countDistinct"] = "countIfDistinct";
+    OuterAggregation["min"] = "minIf";
+    OuterAggregation["max"] = "maxIf";
+    OuterAggregation["sum"] = "sumIf";
+})(OuterAggregation || (OuterAggregation = {}));
+var EDurationTemplateName;
+(function (EDurationTemplateName) {
+    EDurationTemplateName["avg"] = "avg";
+    EDurationTemplateName["median"] = "median";
+})(EDurationTemplateName || (EDurationTemplateName = {}));
+var EEventAppearances;
+(function (EEventAppearances) {
+    EEventAppearances["FIRST"] = "FIRST";
+    EEventAppearances["LAST"] = "LAST";
+})(EEventAppearances || (EEventAppearances = {}));
+
+// Типы, используемые в значениях элементов управления.
+var EWidgetFilterMode;
+(function (EWidgetFilterMode) {
+    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
+    EWidgetFilterMode["SINGLE"] = "SINGLE";
+    EWidgetFilterMode["DISABLED"] = "DISABLED";
+})(EWidgetFilterMode || (EWidgetFilterMode = {}));
+var EMarkdownDisplayMode;
+(function (EMarkdownDisplayMode) {
+    EMarkdownDisplayMode["NONE"] = "NONE";
+    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
+})(EMarkdownDisplayMode || (EMarkdownDisplayMode = {}));
+var EDisplayConditionMode;
+(function (EDisplayConditionMode) {
+    EDisplayConditionMode["DISABLED"] = "DISABLED";
+    EDisplayConditionMode["FORMULA"] = "FORMULA";
+    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
+})(EDisplayConditionMode || (EDisplayConditionMode = {}));
+var EFontWeight;
+(function (EFontWeight) {
+    EFontWeight["NORMAL"] = "NORMAL";
+    EFontWeight["BOLD"] = "BOLD";
+})(EFontWeight || (EFontWeight = {}));
+var EHeightMode;
+(function (EHeightMode) {
+    EHeightMode["FIXED"] = "FIXED";
+    EHeightMode["PERCENT"] = "PERCENT";
+})(EHeightMode || (EHeightMode = {}));
+
+var SortDirectionSchema = function (z) {
+    return z.union([z.literal(ESortDirection.ascend), z.literal(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(ESortingValueModes.FORMULA),
+            formula: FormulaSchema(z),
+            dbDataType: z.string().optional(),
+        }),
+        z.object({
+            mode: z.literal(ESortingValueModes.IN_WIDGET),
+            group: z.string(),
+            index: z.number(),
+        }),
+    ]);
+};
+
+/** Ключи мета-данных внутри схем настроек */
+var ESettingsSchemaMetaKey;
+(function (ESettingsSchemaMetaKey) {
+    /** Привязка значения из темы к настройке */
+    ESettingsSchemaMetaKey["themeValue"] = "themeValue";
+    /** Тип сущности */
+    ESettingsSchemaMetaKey["entity"] = "entity";
+})(ESettingsSchemaMetaKey || (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(EDisplayConditionMode.DISABLED),
+        }),
+        z.object({
+            mode: z.literal(EDisplayConditionMode.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(EDisplayConditionMode.VARIABLE),
+            variableName: NameNullableSchema(z),
+            variableValue: z.string().nullable().default(null),
+        }),
+    ])
+        .default({ mode: 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[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(EFormatOrFormattingMode),
+        value: z.enum(EFormatTypes).optional(),
+    })
+        .default({ mode: EFormatOrFormattingMode.BASE, value: EFormatTypes.STRING });
+};
+var FormattingSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(EFormatOrFormattingMode.BASE),
+            value: z.enum(EFormattingPresets).default(EFormattingPresets.AUTO),
+        }),
+        z.object({
+            mode: z.literal(EFormatOrFormattingMode.TEMPLATE),
+            value: z.string().default(""),
+        }),
+    ])
+        .default({ mode: EFormatOrFormattingMode.BASE, value: 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(EWidgetIndicatorValueModes.FORMULA),
+        formula: FormulaSchema(z).optional(),
+    });
+};
+var WidgetIndicatorTemplateValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(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(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(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(EOuterAggregation) });
+};
+var WidgetIndicatorTimeValueSchema = function (z) {
+    return z.object({
+        templateName: z.string(),
+        mode: z.union([
+            z.literal(EWidgetIndicatorValueModes.START_TIME),
+            z.literal(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(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(EWidgetIndicatorValueModes.DURATION),
+        templateName: z.string(),
+        startEventAppearances: z.enum(EEventAppearances),
+        endEventAppearances: z.enum(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(EMarkdownDisplayMode).default(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(EWidgetIndicatorValueModes.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(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(EFormatTypes),
+        filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+        checkedValues: z.array(z.string().nullable()).optional(),
+        formValues: z
+            .object((_a = {},
+            _a[EFormulaFilterFieldKeys.date] = z.string().nullable(),
+            _a[EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
+            _a[EFormulaFilterFieldKeys.numberRange] = z.tuple([
+                z.number().optional(),
+                z.number().optional(),
+            ]),
+            _a[EFormulaFilterFieldKeys.string] = z.string(),
+            // todo: отказаться от использования z.string(), оставить только z.number() [BI-15912]
+            _a[EFormulaFilterFieldKeys.lastTimeValue] = z.number().or(z.string()),
+            _a[EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(ELastTimeUnit),
+            _a[EFormulaFilterFieldKeys.durationUnit] = z.enum(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(EOuterAggregation),
+            }),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                innerTemplateName: z.string().optional(),
+            }),
+            WidgetIndicatorTimeValueSchema(z),
+            z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
+                formula: z.string().optional(),
+            }),
+        ]),
+        dbDataType: z.string(),
+        condition: z.object({
+            filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+            timeUnit: z.enum(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(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(EWidgetActionInputMethod.VARIABLE),
+        sourceVariable: z.string().nullable().default(null),
+    });
+};
+var ParameterFromFormulaSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(EWidgetActionInputMethod.FORMULA),
+        formula: FormulaSchema(z),
+        considerFilters: z.boolean().default(false),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(EWidgetActionInputMethod.EVENT),
+    });
+};
+var ParameterFromStartEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(EWidgetActionInputMethod.START_EVENT),
+    });
+};
+var ParameterFromEndEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(EWidgetActionInputMethod.FINISH_EVENT),
+    });
+};
+var ParameterFromAggregationSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(EWidgetActionInputMethod.AGGREGATION),
+        formula: FormulaSchema(z),
+        considerFilters: z.boolean().default(false),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromManualInputSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(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(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(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(EWidgetActionInputMethod.DATA_MODEL),
+        option: z.enum(EDataModelOption).default(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(EActionTypes.DRILL_DOWN) });
+};
+var ActionGoToURLSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(EActionTypes.OPEN_URL),
+        url: z.string(),
+        newWindow: z.boolean().default(true),
+    });
+};
+var ActivateConditionSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(EActivateConditionMode.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(EActivateConditionMode.VARIABLE),
+            variableName: z.string().nullable().default(null),
+            variableValue: z.string().nullable().default(null),
+        }),
+    ])
+        .default({ mode: EActivateConditionMode.FORMULA, formula: "" });
+};
+var ActionRunScriptSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(EAutoUpdateMode).default(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(EActionTypes.UPDATE_VARIABLE),
+        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
+    });
+};
+var ActionOpenInSchema = function (z) {
+    return z.discriminatedUnion("openIn", [
+        z.object({
+            openIn: z.literal(EViewOpenIn.DRAWER_WINDOW),
+            alignment: z.enum(EDrawerPlacement).default(EDrawerPlacement.RIGHT),
+            inheritFilter: z.boolean().default(true),
+        }),
+        z.object({
+            openIn: z.literal(EViewOpenIn.PLACEHOLDER),
+            placeholderName: z.string(),
+        }),
+        z.object({
+            openIn: z.literal(EViewOpenIn.MODAL_WINDOW),
+            positionByClick: z.boolean().default(false),
+            inheritFilter: z.boolean().default(true),
+        }),
+        z.object({
+            openIn: z.literal(EViewOpenIn.WINDOW),
+            newWindow: z.boolean().default(true),
+            inheritFilter: z.boolean().default(true),
+        }),
+    ]);
+};
+var ActionOpenViewCommonSchema = function (z) {
+    return ActionCommonSchema(z).extend({ type: z.literal(EActionTypes.OPEN_VIEW) });
+};
+var ActionOpenViewSchema = function (z) {
+    return z.intersection(z.discriminatedUnion("mode", [
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(EViewMode.GENERATED_BY_SCRIPT),
+            scriptKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+            displayName: z.string().default(""),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(EViewMode.EXISTED_VIEW),
+            viewKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(EViewMode.EMPTY),
+            placeholderName: z.string(),
+            openIn: z.literal(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(EActionTypes.EXECUTE_SCRIPT),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(EAutoUpdateMode).default(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(EActionButtonsTypes).default(EActionButtonsTypes.BASE),
+        type: z.literal(EActionTypes.EXECUTE_SCRIPT).default(EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ViewActionParameterSchema(z)).default([]),
+        scriptKey: KeyNullableSchema(z),
+        autoUpdate: z
+            .union([z.literal(EAutoUpdateMode.NONE), z.literal(EAutoUpdateMode.ALL_VIEWS)])
+            .default(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(EActionButtonsTypes).default(EActionButtonsTypes.BASE),
+        backgroundColor: ColorSchema(z),
+        borderColor: ColorSchema(z),
+        color: ColorSchema(z),
+        hint: z.string().default(""),
+    });
+};
+
+var prepareValuesForSql = function (simpleType, values) {
+    return simpleType === ESimpleDataType.INTEGER ||
+        simpleType === ESimpleDataType.FLOAT ||
+        simpleType === 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("'", "\\'");
+};
+
+var ECalculatorFilterMethods;
+(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";
+})(ECalculatorFilterMethods || (ECalculatorFilterMethods = {}));
+
+var formulaFilterMethods = __assign(__assign({}, ECalculatorFilterMethods), { LAST_TIME: "LAST_TIME" });
+var EProcessFilterNames;
+(function (EProcessFilterNames) {
+    /** Наличие события */
+    EProcessFilterNames["presenceOfEvent"] = "presenceOfEvent";
+    /** Количество повторов события */
+    EProcessFilterNames["repetitionOfEvent"] = "repetitionOfEvent";
+    /** Наличие перехода */
+    EProcessFilterNames["presenceOfTransition"] = "presenceOfTransition";
+    /** Длительность перехода */
+    EProcessFilterNames["durationOfTransition"] = "durationOfTransition";
+})(EProcessFilterNames || (EProcessFilterNames = {}));
+var EFormulaFilterFieldKeys;
+(function (EFormulaFilterFieldKeys) {
+    EFormulaFilterFieldKeys["date"] = "date";
+    EFormulaFilterFieldKeys["dateRange"] = "dateRange";
+    EFormulaFilterFieldKeys["numberRange"] = "numberRange";
+    EFormulaFilterFieldKeys["string"] = "string";
+    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
+    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
+    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
+})(EFormulaFilterFieldKeys || (EFormulaFilterFieldKeys = {}));
+var EDimensionProcessFilterTimeUnit;
+(function (EDimensionProcessFilterTimeUnit) {
+    EDimensionProcessFilterTimeUnit["YEARS"] = "YEARS";
+    EDimensionProcessFilterTimeUnit["MONTHS"] = "MONTHS";
+    EDimensionProcessFilterTimeUnit["HOURS"] = "HOURS";
+    EDimensionProcessFilterTimeUnit["DAYS"] = "DAYS";
+    EDimensionProcessFilterTimeUnit["MINUTES"] = "MINUTES";
+})(EDimensionProcessFilterTimeUnit || (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;
+    };
+}
+
+var EClickHouseBaseTypes;
+(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";
+})(EClickHouseBaseTypes || (EClickHouseBaseTypes = {}));
+var stringTypes = ["String", "FixedString"];
+var parseClickHouseType = memoize(function (type) {
+    if (isNil(type)) {
+        return {
+            simpleBaseType: ESimpleDataType.OTHER,
+            dbBaseDataType: undefined,
+            containers: [],
+            simpleType: 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") ? 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 ESimpleDataType.INTEGER;
+    }
+    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
+        return ESimpleDataType.FLOAT;
+    }
+    if (stringTypes.some(isSourceTypeStartsWith)) {
+        return ESimpleDataType.STRING;
+    }
+    if (isSourceTypeStartsWith("DateTime64")) {
+        return ESimpleDataType.DATETIME64;
+    }
+    if (isSourceTypeStartsWith("DateTime")) {
+        return ESimpleDataType.DATETIME;
+    }
+    if (isSourceTypeStartsWith("Date")) {
+        return ESimpleDataType.DATE;
+    }
+    if (isSourceTypeStartsWith("Bool")) {
+        return ESimpleDataType.BOOLEAN;
+    }
+    return 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;
 var EDimensionTemplateNames;
 (function (EDimensionTemplateNames) {
     EDimensionTemplateNames["dateTime"] = "dateTime";
@@ -626,136 +1505,29 @@ var EDimensionTemplateNames;
     EDimensionTemplateNames["hour"] = "hour";
 })(EDimensionTemplateNames || (EDimensionTemplateNames = {}));
 /** Стандартные шаблоны разреза */
-var dimensionTemplateFormulas = (_a$4 = {},
-    _a$4[EDimensionTemplateNames.dateTime] = "toDateTime({columnFormula})",
-    _a$4[EDimensionTemplateNames.date] = "toDate({columnFormula})",
-    _a$4[EDimensionTemplateNames.year] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}))",
-    _a$4[EDimensionTemplateNames.yearAndQuarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}) * 10 + toQuarter({columnFormula}))",
-    _a$4[EDimensionTemplateNames.quarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toQuarter({columnFormula}))",
-    _a$4[EDimensionTemplateNames.yearAndMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYYYYMM({columnFormula}))",
-    _a$4[EDimensionTemplateNames.month] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toMonth({columnFormula}))",
-    _a$4[EDimensionTemplateNames.dayOfMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfMonth({columnFormula}))",
-    _a$4[EDimensionTemplateNames.week] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toWeek({columnFormula}))",
-    _a$4[EDimensionTemplateNames.dayOfWeek] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfWeek({columnFormula}))",
-    _a$4[EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
-    _a$4);
-
-var EWidgetIndicatorType;
-(function (EWidgetIndicatorType) {
-    EWidgetIndicatorType["MEASURE"] = "MEASURE";
-    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
-    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
-    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
-    EWidgetIndicatorType["SORTING"] = "SORTING";
-})(EWidgetIndicatorType || (EWidgetIndicatorType = {}));
-var EOuterAggregation;
-(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";
-})(EOuterAggregation || (EOuterAggregation = {}));
-/** Режимы значения показателя (на основе чего генерируется формула) */
-var EWidgetIndicatorValueModes;
-(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";
-})(EWidgetIndicatorValueModes || (EWidgetIndicatorValueModes = {}));
-/** Режимы сортировки (на что ссылается сортировка) */
-var ESortingValueModes;
-(function (ESortingValueModes) {
-    /** Сортировка по формуле */
-    ESortingValueModes["FORMULA"] = "FORMULA";
-    /** Сортировка по показателю(разрезу или мере) виджета */
-    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
-})(ESortingValueModes || (ESortingValueModes = {}));
-var EFormatOrFormattingMode;
-(function (EFormatOrFormattingMode) {
-    EFormatOrFormattingMode["BASE"] = "BASE";
-    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
-})(EFormatOrFormattingMode || (EFormatOrFormattingMode = {}));
-/** Тип показателя */
-var EIndicatorType;
-(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";
-})(EIndicatorType || (EIndicatorType = {}));
-/** Обобщенные типы значений переменных */
-var ESimpleInputType;
-(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";
-})(ESimpleInputType || (ESimpleInputType = {}));
-function isDimensionsHierarchy(indicator) {
-    return "hierarchyDimensions" in indicator;
-}
-var OuterAggregation;
-(function (OuterAggregation) {
-    OuterAggregation["avg"] = "avgIf";
-    OuterAggregation["median"] = "medianIf";
-    OuterAggregation["count"] = "countIf";
-    OuterAggregation["countDistinct"] = "countIfDistinct";
-    OuterAggregation["min"] = "minIf";
-    OuterAggregation["max"] = "maxIf";
-    OuterAggregation["sum"] = "sumIf";
-})(OuterAggregation || (OuterAggregation = {}));
-var EDurationTemplateName;
-(function (EDurationTemplateName) {
-    EDurationTemplateName["avg"] = "avg";
-    EDurationTemplateName["median"] = "median";
-})(EDurationTemplateName || (EDurationTemplateName = {}));
-var EEventAppearances;
-(function (EEventAppearances) {
-    EEventAppearances["FIRST"] = "FIRST";
-    EEventAppearances["LAST"] = "LAST";
-})(EEventAppearances || (EEventAppearances = {}));
+var dimensionTemplateFormulas = (_a$5 = {},
+    _a$5[EDimensionTemplateNames.dateTime] = "toDateTime({columnFormula})",
+    _a$5[EDimensionTemplateNames.date] = "toDate({columnFormula})",
+    _a$5[EDimensionTemplateNames.year] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}))",
+    _a$5[EDimensionTemplateNames.yearAndQuarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}) * 10 + toQuarter({columnFormula}))",
+    _a$5[EDimensionTemplateNames.quarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toQuarter({columnFormula}))",
+    _a$5[EDimensionTemplateNames.yearAndMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYYYYMM({columnFormula}))",
+    _a$5[EDimensionTemplateNames.month] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toMonth({columnFormula}))",
+    _a$5[EDimensionTemplateNames.dayOfMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfMonth({columnFormula}))",
+    _a$5[EDimensionTemplateNames.week] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toWeek({columnFormula}))",
+    _a$5[EDimensionTemplateNames.dayOfWeek] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfWeek({columnFormula}))",
+    _a$5[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");
@@ -764,8 +1536,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` */
@@ -839,7 +1654,7 @@ var escapeSingularQuotes = function (formula) {
 };
 
 var prepareFormulaForSql = function (formula, simpleType) {
-    formula = clearSingleLineComments(clearMultiLineComments(formula)).trim();
+    formula = sanitizeSingleLineComment(formula, true);
     return simpleType === ESimpleDataType.OTHER ? "toString(".concat(formula, ")") : formula;
 };
 var clearSingleLineComments = function (formula) {
@@ -921,7 +1736,7 @@ var convertFiltersToFormula = function (filters) {
     return filters.length > 0 ? " AND ".concat(convertToFormulasChain(filters)) : "";
 };
 
-var _a$3;
+var _a$4;
 var EDimensionAggregationTemplateName;
 (function (EDimensionAggregationTemplateName) {
     EDimensionAggregationTemplateName["avg"] = "avg";
@@ -938,20 +1753,20 @@ var EDimensionAggregationTemplateName;
     EDimensionAggregationTemplateName["countReworks"] = "countReworks";
 })(EDimensionAggregationTemplateName || (EDimensionAggregationTemplateName = {}));
 /** Шаблоны процессных метрик разреза с режимом AGGREGATION */
-var dimensionAggregationTemplates = (_a$3 = {},
-    _a$3[EDimensionAggregationTemplateName.avg] = avgTemplate,
-    _a$3[EDimensionAggregationTemplateName.median] = medianTemplate,
-    _a$3[EDimensionAggregationTemplateName.count] = countTemplate,
-    _a$3[EDimensionAggregationTemplateName.countDistinct] = countDistinctTemplate,
-    _a$3[EDimensionAggregationTemplateName.min] = minTemplate,
-    _a$3[EDimensionAggregationTemplateName.max] = maxTemplate,
-    _a$3[EDimensionAggregationTemplateName.sum] = sumTemplate,
-    _a$3[EDimensionAggregationTemplateName.top] = topTemplate,
-    _a$3[EDimensionAggregationTemplateName.firstValue] = firstValueTemplate,
-    _a$3[EDimensionAggregationTemplateName.lastValue] = lastValueTemplate,
-    _a$3[EDimensionAggregationTemplateName.countExecutions] = countExecutionsTemplate,
-    _a$3[EDimensionAggregationTemplateName.countReworks] = countReworksTemplate,
-    _a$3);
+var dimensionAggregationTemplates = (_a$4 = {},
+    _a$4[EDimensionAggregationTemplateName.avg] = avgTemplate,
+    _a$4[EDimensionAggregationTemplateName.median] = medianTemplate,
+    _a$4[EDimensionAggregationTemplateName.count] = countTemplate,
+    _a$4[EDimensionAggregationTemplateName.countDistinct] = countDistinctTemplate,
+    _a$4[EDimensionAggregationTemplateName.min] = minTemplate,
+    _a$4[EDimensionAggregationTemplateName.max] = maxTemplate,
+    _a$4[EDimensionAggregationTemplateName.sum] = sumTemplate,
+    _a$4[EDimensionAggregationTemplateName.top] = topTemplate,
+    _a$4[EDimensionAggregationTemplateName.firstValue] = firstValueTemplate,
+    _a$4[EDimensionAggregationTemplateName.lastValue] = lastValueTemplate,
+    _a$4[EDimensionAggregationTemplateName.countExecutions] = countExecutionsTemplate,
+    _a$4[EDimensionAggregationTemplateName.countReworks] = countReworksTemplate,
+    _a$4);
 /** На основе значения режима AGGREGATION подготовить параметры для подстановки в шаблонную формулу */
 var prepareDimensionAggregationParams = function (value) {
     if (!value.eventName ||
@@ -964,8 +1779,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: "",
@@ -994,13 +1808,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[EWidgetIndicatorValueModes.START_TIME] = generateTemplates("process(minIf({eventTimeFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula})"),
-        _a[EWidgetIndicatorValueModes.END_TIME] = generateTemplates("process(maxIf({eventTimeFormula}, {eventNameFormula} = '{eventName}'{filters}), {caseCaseIdFormula})"),
+        _a[EWidgetIndicatorValueModes.START_TIME] = generateTemplates("process(minIf({eventTimeFormula}, {eventNameFormula} = {eventName}{filters}), {caseCaseIdFormula})"),
+        _a[EWidgetIndicatorValueModes.END_TIME] = generateTemplates("process(maxIf({eventTimeFormula}, {eventNameFormula} = {eventName}{filters}), {caseCaseIdFormula})"),
         _a;
 })();
 /** На основе значения режимов START_TIME/END_TIME подготовить параметры для подстановки в шаблонную формулу */
@@ -1018,12 +1832,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 "";
@@ -1037,10 +1851,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 === EWidgetIndicatorValueModes.AGGREGATION) {
         var preparedParams = prepareDimensionAggregationParams(value);
         if (!preparedParams) {
@@ -1050,10 +1867,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 === EWidgetIndicatorValueModes.START_TIME ||
         value.mode === EWidgetIndicatorValueModes.END_TIME) {
@@ -1062,9 +1879,8 @@ function getDimensionFormula(_a) {
             return "";
         }
         var templateFormula = timeTemplates[value.mode][value.templateName];
-        return fillTemplateString(templateFormula, preparedParams);
+        return fillTemplateSql(templateFormula, preparedParams);
     }
-    return "";
 }
 
 var EMeasureAggregationTemplateName;
@@ -1096,8 +1912,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: "",
@@ -1118,7 +1933,7 @@ var prepareMeasureAggregationParams = function (value) {
     return columnParams;
 };
 
-var _a$2;
+var _a$3, _b;
 var EMeasureTemplateNames;
 (function (EMeasureTemplateNames) {
     EMeasureTemplateNames["avg"] = "avg";
@@ -1129,19 +1944,28 @@ var EMeasureTemplateNames;
     EMeasureTemplateNames["max"] = "max";
     EMeasureTemplateNames["sum"] = "sum";
 })(EMeasureTemplateNames || (EMeasureTemplateNames = {}));
+var EMeasureInnerTemplateNames;
+(function (EMeasureInnerTemplateNames) {
+    EMeasureInnerTemplateNames["begin"] = "begin";
+    EMeasureInnerTemplateNames["end"] = "end";
+})(EMeasureInnerTemplateNames || (EMeasureInnerTemplateNames = {}));
 /** Стандартные шаблоны меры */
-var measureTemplateFormulas = (_a$2 = {},
-    _a$2[EMeasureTemplateNames.avg] = "avg({columnFormula})",
-    _a$2[EMeasureTemplateNames.count] = "count({columnFormula})",
-    _a$2[EMeasureTemplateNames.countDistinct] = "count(distinct {columnFormula})",
-    _a$2[EMeasureTemplateNames.median] = "medianExact({columnFormula})",
-    _a$2[EMeasureTemplateNames.min] = "min({columnFormula})",
-    _a$2[EMeasureTemplateNames.max] = "max({columnFormula})",
-    _a$2[EMeasureTemplateNames.sum] = "sum({columnFormula})",
-    _a$2);
+var measureTemplateFormulas = (_a$3 = {},
+    _a$3[EMeasureTemplateNames.avg] = "avg({columnFormula})",
+    _a$3[EMeasureTemplateNames.count] = "count({columnFormula})",
+    _a$3[EMeasureTemplateNames.countDistinct] = "count(distinct {columnFormula})",
+    _a$3[EMeasureTemplateNames.median] = "medianExact({columnFormula})",
+    _a$3[EMeasureTemplateNames.min] = "min({columnFormula})",
+    _a$3[EMeasureTemplateNames.max] = "max({columnFormula})",
+    _a$3[EMeasureTemplateNames.sum] = "sum({columnFormula})",
+    _a$3);
+var measureInnerTemplateFormulas = (_b = {},
+    _b[EMeasureInnerTemplateNames.begin] = "begin({columnFormula})",
+    _b[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 ||
@@ -1156,15 +1980,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),
     };
 };
@@ -1172,7 +1995,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[EDurationTemplateName.avg] = "avgIf(".concat(innerTemplate, ")"),
         _a[EDurationTemplateName.median] = "medianIf(".concat(innerTemplate, ")"),
@@ -1195,32 +2018,31 @@ var prepareDurationParams = function (value) {
         return appearance === 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 === 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) {
@@ -1267,9 +2089,9 @@ function createAggregationTemplate(templateName, _a) {
                 ? createAnyEventTemplate("argMax({columnFormula}, {eventTimeFormula})")
                 : createTopLikeTemplate(lastValueTemplate)(outerAggregation);
         case EMeasureAggregationTemplateName.countExecutions:
-            return "{outerAggregation}If(".concat(countExecutionsTemplate, ", {objectFilters})");
+            return "{outerAggregation}(".concat(countExecutionsTemplate, ")");
         case EMeasureAggregationTemplateName.countReworks:
-            return "{outerAggregation}If(".concat(countReworksTemplate, ", {objectFilters})");
+            return "{outerAggregation}(".concat(countReworksTemplate, ")");
     }
 }
 
@@ -1283,19 +2105,24 @@ function getMeasureFormula(_a) {
         return (_b = value.formula) !== null && _b !== void 0 ? _b : "";
     }
     if (value.mode === 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 === EWidgetIndicatorValueModes.AGGREGATION) {
         var preparedParams = prepareMeasureAggregationParams(value);
         return preparedParams
-            ? fillTemplateString(createAggregationTemplate(value.templateName, {
+            ? fillTemplateSql(createAggregationTemplate(value.templateName, {
                 outerAggregation: preparedParams.outerAggregation,
                 anyEvent: value.anyEvent,
             }), preparedParams)
@@ -1306,28 +2133,28 @@ function getMeasureFormula(_a) {
         if (!preparedParams) {
             return "";
         }
-        return fillTemplateString(conversionTemplate, preparedParams);
+        return fillTemplateSql(conversionTemplate, preparedParams);
     }
     if (value.mode === 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;
 var EEventMeasureTemplateNames;
 (function (EEventMeasureTemplateNames) {
     EEventMeasureTemplateNames["eventsCount"] = "eventsCount";
     EEventMeasureTemplateNames["reworksCount"] = "reworksCount";
 })(EEventMeasureTemplateNames || (EEventMeasureTemplateNames = {}));
-var eventMeasureTemplateFormulas = (_a$1 = {},
-    _a$1[EEventMeasureTemplateNames.eventsCount] = "count()",
-    _a$1[EEventMeasureTemplateNames.reworksCount] = "count() - uniqExact({caseCaseIdFormula})",
-    _a$1);
+var eventMeasureTemplateFormulas = (_a$2 = {},
+    _a$2[EEventMeasureTemplateNames.eventsCount] = "count()",
+    _a$2[EEventMeasureTemplateNames.reworksCount] = "count() - uniqExact({caseCaseIdFormula})",
+    _a$2);
 
 function getEventMeasureFormula(_a, process) {
     var value = _a.value;
@@ -1339,21 +2166,21 @@ function getEventMeasureFormula(_a, process) {
     }
     if (value.mode === EWidgetIndicatorValueModes.TEMPLATE) {
         var templateFormula = eventMeasureTemplateFormulas[value.templateName];
-        return templateFormula && fillTemplateString(templateFormula, process);
+        return templateFormula && fillTemplateSql(templateFormula, process);
     }
     return "";
 }
 
-var _a;
+var _a$1;
 var ETransitionMeasureTemplateNames;
 (function (ETransitionMeasureTemplateNames) {
     ETransitionMeasureTemplateNames["transitionsCount"] = "transitionsCount";
     ETransitionMeasureTemplateNames["medianTime"] = "medianTime";
 })(ETransitionMeasureTemplateNames || (ETransitionMeasureTemplateNames = {}));
-var transitionMeasureTemplateFormulas = (_a = {},
-    _a[ETransitionMeasureTemplateNames.transitionsCount] = "count()",
-    _a[ETransitionMeasureTemplateNames.medianTime] = "medianExact(date_diff(second, begin({eventTimeFormula}), end({eventTimeFormula})))",
-    _a);
+var transitionMeasureTemplateFormulas = (_a$1 = {},
+    _a$1[ETransitionMeasureTemplateNames.transitionsCount] = "count()",
+    _a$1[ETransitionMeasureTemplateNames.medianTime] = "medianExact(date_diff(second, begin({eventTimeFormula}), end({eventTimeFormula})))",
+    _a$1);
 
 function getTransitionMeasureFormula(_a, process) {
     var value = _a.value;
@@ -1365,35 +2192,11 @@ function getTransitionMeasureFormula(_a, process) {
     }
     if (value.mode === EWidgetIndicatorValueModes.TEMPLATE) {
         var templateFormula = transitionMeasureTemplateFormulas[value.templateName];
-        return templateFormula && fillTemplateString(templateFormula, process);
+        return templateFormula && fillTemplateSql(templateFormula, process);
     }
     return "";
 }
 
-// Типы, используемые в значениях элементов управления.
-var EWidgetFilterMode;
-(function (EWidgetFilterMode) {
-    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
-    EWidgetFilterMode["SINGLE"] = "SINGLE";
-    EWidgetFilterMode["DISABLED"] = "DISABLED";
-})(EWidgetFilterMode || (EWidgetFilterMode = {}));
-var EMarkdownDisplayMode;
-(function (EMarkdownDisplayMode) {
-    EMarkdownDisplayMode["NONE"] = "NONE";
-    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
-})(EMarkdownDisplayMode || (EMarkdownDisplayMode = {}));
-var EDisplayConditionMode;
-(function (EDisplayConditionMode) {
-    EDisplayConditionMode["DISABLED"] = "DISABLED";
-    EDisplayConditionMode["FORMULA"] = "FORMULA";
-    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
-})(EDisplayConditionMode || (EDisplayConditionMode = {}));
-var EFontWeight;
-(function (EFontWeight) {
-    EFontWeight["NORMAL"] = "NORMAL";
-    EFontWeight["BOLD"] = "BOLD";
-})(EFontWeight || (EFontWeight = {}));
-
 function checkDisplayCondition(displayCondition, variables) {
     var _a;
     if ((displayCondition === null || displayCondition === void 0 ? void 0 : displayCondition.mode) === EDisplayConditionMode.VARIABLE) {
@@ -1527,7 +2330,7 @@ var getFormulaFilterValues = function (filterValue) {
             if (filteringMethod === formulaFilterMethods.LAST_TIME) {
                 var showTime = format === 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),
                 ]);
             }
@@ -1549,7 +2352,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;
@@ -1557,7 +2362,7 @@ var mapFormulaFilterToCalculatorInput = function (filterValue) {
     if (!isFormulaFilterValue(filterValue)) {
         return {
             dbDataType: EClickHouseBaseTypes.Bool,
-            formula: fillTemplateString(displayConditionTemplate, {
+            formula: fillTemplateSql(displayConditionTemplate, {
                 formula: prepareFormulaForSql(filterValue.formula),
             }),
             values: ["true"],
@@ -1592,6 +2397,46 @@ var mapFormulaFiltersToInputs = function (filters) {
     return compactMap(filters, mapFormulaFilterToCalculatorInput);
 };
 
+var _a;
+var intervalByUnit = (_a = {},
+    _a[EDimensionProcessFilterTimeUnit.YEARS] = "year",
+    _a[EDimensionProcessFilterTimeUnit.MONTHS] = "month",
+    _a[EDimensionProcessFilterTimeUnit.DAYS] = "day",
+    _a[EDimensionProcessFilterTimeUnit.HOURS] = "hour",
+    _a[EDimensionProcessFilterTimeUnit.MINUTES] = "minute",
+    _a);
+function mapDimensionProcessFilterToCalculatorInput(filter) {
+    var formula = filter.value.mode === 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: 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);
@@ -1697,8 +2542,8 @@ var ESortDirection;
  * Если к разрезу иерархии применяется 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 фильтров для быстрого поиска
@@ -1711,14 +2556,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) {
@@ -1734,7 +2583,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) === EFormatOrFormattingMode.BASE &&
+            dimension.format.value !== undefined &&
             [
                 EFormatTypes.DATE,
                 EFormatTypes.MONTH,
@@ -1793,9 +2643,9 @@ function mapSortingToInputs(_a) {
             return;
         }
         if (getIndicatorType(value.group, indicator) === 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;
@@ -1809,10 +2659,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;
@@ -1826,8 +2677,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;
     });
@@ -1898,6 +2748,12 @@ var EUnitMode;
     EUnitMode["PIXEL"] = "PIXEL";
     EUnitMode["PERCENT"] = "PERCENT";
 })(EUnitMode || (EUnitMode = {}));
+var defaultActionsConfig = {
+    OPEN_URL: { availability: true },
+    UPDATE_VARIABLE: { availability: true },
+    EXECUTE_SCRIPT: { availability: true },
+    OPEN_VIEW: { availability: true },
+};
 
 var ESelectOptionTypes;
 (function (ESelectOptionTypes) {
@@ -2086,4 +2942,118 @@ var getColorByIndex = function (index) {
     return color;
 };
 
-export { EActionButtonsTypes, EActionTypes, EActivateConditionMode, EAutoUpdateMode, ECalculatorFilterMethods, EClickHouseBaseTypes, EColorMode, EControlType, ECustomSelectTemplates, EDataModelOption, EDimensionAggregationTemplateName, EDimensionTemplateNames, EDisplayConditionMode, EDrawerPlacement, EDurationTemplateName, EDurationUnit, EEventAppearances, EEventMeasureTemplateNames, EFontWeight, EFormatOrFormattingMode, EFormatTypes, EFormattingPresets, EFormulaFilterFieldKeys, EIndicatorType, ELastTimeUnit, EMarkdownDisplayMode, EMeasureAggregationTemplateName, EMeasureTemplateNames, EOuterAggregation, EProcessFilterNames, ESelectOptionTypes, ESimpleDataType, ESimpleInputType, ESortDirection, ESortingValueModes, ESystemRecordKey, ETransitionMeasureTemplateNames, EUnitMode, EViewMode, EViewOpenIn, EWidgetActionInputMethod, EWidgetFilterMode, EWidgetIndicatorType, EWidgetIndicatorValueModes, OuterAggregation, applyIndexToArrayFormula, bindContentWithIndicator, bindContentsWithIndicators, checkDisplayCondition, clearMultiLineComments, clearSingleLineComments, colors, conversionTemplate, convertFiltersToFormula, convertToFormulasChain, countExecutionsTemplate, createEscaper, createAggregationTemplate as createMeasureAggregationTemplate, curlyBracketsContentPattern, dashboardLinkRegExp, dimensionAggregationTemplates, dimensionTemplateFormulas, displayConditionTemplate, doubleQuoteContentPattern, durationTemplates, escapeCurlyBracketLinkName, escapeDoubleQuoteLinkName, eventMeasureTemplateFormulas, fillTemplateString, formattingConfig, formulaFilterMethods, generateColumnFormula, getColorByIndex, getDefaultSortOrders, getDimensionFormula, getDisplayConditionFormula, getEventMeasureFormula, getLocalizedText, getMeasureFormula, getRuleColor, getTransitionMeasureFormula, isDimensionsHierarchy, isFormulaFilterValue, isValidColor, mapDimensionsToInputs, mapEventMeasuresToInputs, mapFormulaFilterToCalculatorInput, mapFormulaFiltersToInputs, mapMeasuresToInputs, mapSortingToInputs, mapTransitionMeasuresToInputs, measureTemplateFormulas, parseClickHouseType, parseIndicatorLink, prepareConversionParams, prepareDimensionAggregationParams, prepareDurationParams, prepareFormulaForSql, prepareMeasureAggregationParams, prepareSortOrders, prepareTimeParams, prepareValuesForSql, replaceDisplayCondition, replaceFiltersBySelection, replaceHierarchiesWithDimensions, selectDimensionFromHierarchy, timeTemplates, transitionMeasureTemplateFormulas, unescapeSpecialCharacters, updateDefaultModeSelection, updateSingleModeSelection, workspaceLinkRegExp };
+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[ESettingsSchemaMetaKey.themeValue] = selectThemeValue, _a));
+};
+
+var ColorBaseSchema = function (z) {
+    return z.object({
+        mode: z.literal(EColorMode.BASE),
+        value: z.string(),
+    });
+};
+var ColorRuleSchema = function (z) {
+    return z.object({
+        mode: z.literal(EColorMode.RULE),
+        formula: FormulaSchema(z),
+    });
+};
+var ColorAutoSchema = function (z) {
+    return z.object({
+        mode: z.literal(EColorMode.AUTO),
+    });
+};
+var ColorDisabledSchema = function (z) {
+    return z.object({
+        mode: z.literal(EColorMode.DISABLED),
+    });
+};
+var ColorGradientSchema = function (z) {
+    return z.object({
+        mode: z.literal(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(EColorMode.FORMULA),
+        formula: FormulaSchema(z),
+    });
+};
+var ColorValuesSchema = function (z) {
+    return z.object({
+        mode: z.literal(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(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: EColorMode.AUTO });
+};
+
+export { ActionButtonSchema, ActionDrillDownSchema, ActionGoToURLSchema, ActionOnClickParameterSchema, ActionOpenInSchema, ActionOpenViewSchema, ActionRunScriptSchema, ActionSchema, ActionUpdateVariableSchema, ActionsOnClickSchema, AutoIdentifiedArrayItemSchema, BaseWidgetSettingsSchema, ColorAutoSchema, ColorBaseSchema, ColorByDimensionSchema, ColorDisabledSchema, ColorFormulaSchema, ColorGradientSchema, ColorRuleSchema, ColorSchema, ColorValuesSchema, ColoredValueSchema, ColumnIndicatorValueSchema, DimensionProcessFilterSchema, DimensionValueSchema, DisplayConditionSchema, EActionButtonsTypes, EActionTypes, EActivateConditionMode, EAutoUpdateMode, ECalculatorFilterMethods, EClickHouseBaseTypes, EColorMode, EControlType, ECustomSelectTemplates, EDataModelOption, EDimensionAggregationTemplateName, EDimensionProcessFilterTimeUnit, EDimensionTemplateNames, EDisplayConditionMode, EDrawerPlacement, EDurationTemplateName, EDurationUnit, EEventAppearances, EEventMeasureTemplateNames, EFontWeight, EFormatOrFormattingMode, EFormatTypes, EFormattingPresets, EFormulaFilterFieldKeys, EHeightMode, EIndicatorType, ELastTimeUnit, EMarkdownDisplayMode, EMeasureAggregationTemplateName, EMeasureInnerTemplateNames, EMeasureTemplateNames, EOuterAggregation, EProcessFilterNames, ESelectOptionTypes, ESettingsSchemaMetaKey, ESimpleDataType, ESimpleInputType, ESortDirection, ESortingValueModes, ESystemRecordKey, ETransitionMeasureTemplateNames, EUnitMode, EViewMode, EViewOpenIn, EWidgetActionInputMethod, EWidgetFilterMode, EWidgetIndicatorType, EWidgetIndicatorValueModes, ExtendedFormulaFilterValueSchema, FormatSchema, FormattingSchema, FormulaFilterValueSchema, FormulaNullableSchema, FormulaSchema, KeyNullableSchema, MarkdownMeasureSchema, MeasureValueSchema, NameNullableSchema, OuterAggregation, ParameterFromAggregationSchema, ParameterFromColumnSchema, ParameterFromDataModelSchema, ParameterFromDynamicListSchema, ParameterFromEndEventSchema, ParameterFromEventSchema, ParameterFromFormulaSchema, ParameterFromManualInputSchema, ParameterFromStartEventSchema, ParameterFromStaticListSchema, ParameterFromVariableSchema, ProcessIndicatorSchema, ProcessIndicatorValueSchema, RangeSchema, SettingsFilterSchema, SortDirectionSchema, SortOrderSchema, ViewActionParameterSchema, ViewActionSchema, WidgetActionParameterSchema, WidgetActionSchema, WidgetColumnIndicatorSchema, WidgetDimensionHierarchySchema, WidgetDimensionInHierarchySchema, WidgetDimensionSchema, WidgetIndicatorAggregationValueSchema, WidgetIndicatorConversionValueSchema, WidgetIndicatorDurationValueSchema, WidgetIndicatorFormulaValueSchema, WidgetIndicatorSchema, WidgetIndicatorTemplateValueSchema, WidgetIndicatorTimeValueSchema, WidgetMeasureAggregationValueSchema, WidgetMeasureSchema, WidgetPresetSettingsSchema, WidgetSortingIndicatorSchema, WidgetSortingValueSchema, apiVersion, apiVersions, applyIndexToArrayFormula, bindContentWithIndicator, bindContentsWithIndicators, checkDisplayCondition, clearMultiLineComments, clearSingleLineComments, colors, conversionTemplate, convertFiltersToFormula, convertToFormulasChain, countExecutionsTemplate, createEscaper, createAggregationTemplate as createMeasureAggregationTemplate, curlyBracketsContentPattern, dashboardLinkRegExp, defaultActionsConfig, dimensionAggregationTemplates, dimensionTemplateFormulas, displayConditionTemplate, doubleQuoteContentPattern, durationTemplates, escapeCurlyBracketLinkName, escapeDoubleQuoteLinkName, eventMeasureTemplateFormulas, fillTemplateSql, formattingConfig, formulaFilterMethods, generateColumnFormula, getColorByIndex, getDefaultSortOrders, getDimensionFormula, getDisplayConditionFormula, getEventMeasureFormula, getLocalizedText, getMeasureFormula, getProcessDimensionValueFormula, getRuleColor, getTransitionMeasureFormula, inheritDisplayConditionFromHierarchy, isDimensionProcessFilter, isDimensionsHierarchy, isFormulaFilterValue, isValidColor, mapDimensionsToInputs, mapEventMeasuresToInputs, mapFormulaFilterToCalculatorInput, mapFormulaFiltersToInputs, mapMeasuresToInputs, mapSettingsFiltersToInputs, mapSortingToInputs, mapTransitionMeasuresToInputs, measureInnerTemplateFormulas, measureTemplateFormulas, parseClickHouseType, parseIndicatorLink, prepareConversionParams, prepareDimensionAggregationParams, prepareDurationParams, prepareFormulaForSql, prepareMeasureAggregationParams, prepareSortOrders, prepareTimeParams, prepareValuesForSql, replaceDisplayCondition, replaceFiltersBySelection, replaceHierarchiesWithDimensions, selectDimensionFromHierarchy, themed, timeTemplates, transitionMeasureTemplateFormulas, unescapeSpecialCharacters, updateDefaultModeSelection, updateSingleModeSelection, workspaceLinkRegExp };