@infomaximum/widget-sdk 6.0.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,285 +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 __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 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 EFormatTypes;
 (function (EFormatTypes) {
     /** Дата */
@@ -648,6 +444,1051 @@ var formattingConfig = {
     },
 };
 
+/******************************************************************************
+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) {
@@ -678,113 +1519,6 @@ var dimensionTemplateFormulas = (_a$5 = {},
     _a$5[EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
     _a$5);
 
-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 = {}));
-
 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})");
 }
@@ -819,13 +1553,6 @@ function sanitizeSingleLineComment(formula, wrapInBrackets) {
     return wrapInBrackets ? "(".concat(formula, "\n)") : "".concat(formula, "\n");
 }
 
-/** @deprecated - следует использовать fillTemplateSql */
-function fillTemplateString(templateString, params) {
-    return templateString.replace(/\{(.*?)\}/g, function (_, key) {
-        var _a;
-        return (_a = params[key]) !== null && _a !== void 0 ? _a : "";
-    });
-}
 /** Функция для безопасного заполнения SQL шаблонов с защитой от однострочных SQL комментариев в подставляемых значениях. */
 function fillTemplateSql(templateString, params) {
     var e_1, _a;
@@ -850,7 +1577,10 @@ function fillTemplateSql(templateString, params) {
         }
         finally { if (e_1) throw e_1.error; }
     }
-    return fillTemplateString(templateString, newParams);
+    return templateString.replace(/\{(.*?)\}/g, function (_, key) {
+        var _a;
+        return (_a = newParams[key]) !== null && _a !== void 0 ? _a : "";
+    });
 }
 
 /** Создать функцию экранирования переданных `specialChars` внутри `str` */
@@ -1467,30 +2197,6 @@ function getTransitionMeasureFormula(_a, 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) {
@@ -1624,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),
                 ]);
             }
@@ -1836,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 фильтров для быстрого поиска
@@ -1850,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) {
@@ -1873,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,
@@ -1932,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;
@@ -1948,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;
@@ -1965,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;
     });
@@ -2037,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) {
@@ -2225,4 +2942,118 @@ var getColorByIndex = function (index) {
     return color;
 };
 
-export { EActionButtonsTypes, EActionTypes, EActivateConditionMode, EAutoUpdateMode, ECalculatorFilterMethods, EClickHouseBaseTypes, EColorMode, EControlType, ECustomSelectTemplates, EDataModelOption, EDimensionAggregationTemplateName, EDimensionProcessFilterTimeUnit, EDimensionTemplateNames, EDisplayConditionMode, EDrawerPlacement, EDurationTemplateName, EDurationUnit, EEventAppearances, EEventMeasureTemplateNames, EFontWeight, EFormatOrFormattingMode, EFormatTypes, EFormattingPresets, EFormulaFilterFieldKeys, EIndicatorType, ELastTimeUnit, EMarkdownDisplayMode, EMeasureAggregationTemplateName, EMeasureInnerTemplateNames, 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, fillTemplateSql, fillTemplateString, formattingConfig, formulaFilterMethods, generateColumnFormula, getColorByIndex, getDefaultSortOrders, getDimensionFormula, getDisplayConditionFormula, getEventMeasureFormula, getLocalizedText, getMeasureFormula, getProcessDimensionValueFormula, getRuleColor, getTransitionMeasureFormula, 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, 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 };