@infomaximum/widget-sdk 6.0.2 → 7.0.0-2

package/dist/index.js

@@ -3,6 +3,40 @@
 var localization$1 = require('@infomaximum/localization');
 var baseFilter = require('@infomaximum/base-filter');
 
+/** Массив версий в строгом порядке, по которому последовательно выполняется миграция */
+var apiVersions = [
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7", // Версии от 7 и старше пока не удаляем [BI-15416]
+    "8",
+    "9",
+    "10",
+    "10.1",
+    "10.2",
+    "10.3", // 241223
+    "11",
+    "12",
+    "13", // 2503
+    "13.1", // 250314
+    "14",
+    "15", // Для версии системы 2505
+    "15.1", // Для версии системы 250609
+    "15.2", // Для версии системы 250614
+    "16", // Для версии системы 2507
+    "16.1", // Для версии системы 250703
+    "16.2", // Для версии системы 250709
+    "17", // 2508
+];
+/**
+ * Актуальная версия settings, с которой работает система.
+ * Используется единая версия для settings виджетов и показателей.
+ */
+var apiVersion = apiVersions.at(-1);
+
 exports.EWidgetActionInputMethod = void 0;
 (function (EWidgetActionInputMethod) {
     EWidgetActionInputMethod["COLUMN"] = "COLUMN";
@@ -23,6 +57,7 @@ exports.EActionTypes = void 0;
     EActionTypes["UPDATE_VARIABLE"] = "UPDATE_VARIABLE";
     EActionTypes["EXECUTE_SCRIPT"] = "EXECUTE_SCRIPT";
     EActionTypes["OPEN_VIEW"] = "OPEN_VIEW";
+    EActionTypes["DRILL_DOWN"] = "DRILL_DOWN";
 })(exports.EActionTypes || (exports.EActionTypes = {}));
 exports.EViewMode = void 0;
 (function (EViewMode) {
@@ -65,6 +100,46 @@ exports.EActionButtonsTypes = void 0;
     EActionButtonsTypes["SECONDARY"] = "primary-outlined";
 })(exports.EActionButtonsTypes || (exports.EActionButtonsTypes = {}));
 
+/**
+ * Глобальный счетчик для генерации ID.
+ *
+ * @todo
+ * В будущем можно заменить единый счетчик на изолированные счетчики в разных контекстах.
+ */
+var id = 1;
+var AutoIdentifiedArrayItemSchema = function (z) {
+    return z.object({
+        /**
+         * Идентификатор, добавляемый системой "на лету" для удобства разработки, не сохраняется на сервер.
+         * Гарантируется уникальность id в пределах settings виджета.
+         */
+        id: z
+            .number()
+            .default(-1)
+            .transform(function (currentId) { return (currentId === -1 ? id++ : currentId); }),
+    });
+};
+var BaseWidgetSettingsSchema = function (z) {
+    return z.object({
+        title: z.string().default(""),
+        titleSize: themed(z.number().default(14), function (theme) { return theme.widgets.titleSize; }),
+        titleColor: themed(ColorSchema(z), function (theme) { return theme.widgets.titleColor; }),
+        titleWeight: themed(z.enum(exports.EFontWeight).default(exports.EFontWeight.NORMAL), function (theme) { return theme.widgets.titleWeight; }),
+        stateName: z.string().nullable().default(null),
+        showMarkdown: z.boolean().default(false),
+        markdownMeasures: z.array(MarkdownMeasureSchema(z)).default([]),
+        markdownText: z.string().default(""),
+        markdownTextSize: z.number().default(14),
+        filters: z.array(SettingsFilterSchema(z)).default([]),
+        filterMode: z.enum(exports.EWidgetFilterMode).default(exports.EWidgetFilterMode.DEFAULT),
+        ignoreFilters: z.boolean().default(false),
+        sorting: z.array(WidgetSortingIndicatorSchema(z)).default([]),
+        actionButtons: z.array(ActionButtonSchema(z)).default([]),
+        paddings: themed(z.union([z.number(), z.string()]).default(8), function (theme) { return theme.widgets.paddings; }),
+        viewTheme: z.boolean().default(false),
+    });
+};
+
 exports.ESimpleDataType = void 0;
 (function (ESimpleDataType) {
     ESimpleDataType["OTHER"] = "OTHER";
@@ -77,285 +152,6 @@ exports.ESimpleDataType = void 0;
     ESimpleDataType["BOOLEAN"] = "BOOLEAN";
 })(exports.ESimpleDataType || (exports.ESimpleDataType = {}));
 
-var prepareValuesForSql = function (simpleType, values) {
-    return simpleType === exports.ESimpleDataType.INTEGER ||
-        simpleType === exports.ESimpleDataType.FLOAT ||
-        simpleType === exports.ESimpleDataType.BOOLEAN
-        ? values
-        : values.map(function (value) {
-            return value === null ? null : "'".concat(escapeSingularQuotes$1(escapeReverseSlash(value)), "'");
-        });
-};
-var escapeReverseSlash = function (formula) {
-    return formula.replaceAll(/\\/gm, "\\\\");
-};
-var escapeSingularQuotes$1 = function (formula) {
-    return formula.replaceAll("'", "\\'");
-};
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __makeTemplateObject(cooked, raw) {
-    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-    return cooked;
-}
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-exports.ECalculatorFilterMethods = void 0;
-(function (ECalculatorFilterMethods) {
-    ECalculatorFilterMethods["EQUAL_TO"] = "EQUAL_TO";
-    ECalculatorFilterMethods["NOT_EQUAL_TO"] = "NOT_EQUAL_TO";
-    ECalculatorFilterMethods["GREATER_THAN"] = "GREATER_THAN";
-    ECalculatorFilterMethods["LESS_THAN"] = "LESS_THAN";
-    ECalculatorFilterMethods["GREATER_THAN_OR_EQUAL_TO"] = "GREATER_THAN_OR_EQUAL_TO";
-    ECalculatorFilterMethods["LESS_THAN_OR_EQUAL_TO"] = "LESS_THAN_OR_EQUAL_TO";
-    ECalculatorFilterMethods["STARTS_WITH"] = "STARTS_WITH";
-    ECalculatorFilterMethods["ENDS_WITH"] = "ENDS_WITH";
-    ECalculatorFilterMethods["CONTAINS"] = "CONTAINS";
-    ECalculatorFilterMethods["NOT_CONTAINS"] = "NOT_CONTAINS";
-    ECalculatorFilterMethods["IN_RANGE"] = "IN_RANGE";
-    ECalculatorFilterMethods["NOT_IN_RANGE"] = "NOT_IN_RANGE";
-    ECalculatorFilterMethods["INCLUDE"] = "INCLUDE";
-    ECalculatorFilterMethods["EXCLUDE"] = "EXCLUDE";
-    ECalculatorFilterMethods["NONEMPTY"] = "NONEMPTY";
-    ECalculatorFilterMethods["EMPTY"] = "EMPTY";
-})(exports.ECalculatorFilterMethods || (exports.ECalculatorFilterMethods = {}));
-
-var formulaFilterMethods = __assign(__assign({}, exports.ECalculatorFilterMethods), { LAST_TIME: "LAST_TIME" });
-exports.EProcessFilterNames = void 0;
-(function (EProcessFilterNames) {
-    /** Наличие события */
-    EProcessFilterNames["presenceOfEvent"] = "presenceOfEvent";
-    /** Количество повторов события */
-    EProcessFilterNames["repetitionOfEvent"] = "repetitionOfEvent";
-    /** Наличие перехода */
-    EProcessFilterNames["presenceOfTransition"] = "presenceOfTransition";
-    /** Длительность перехода */
-    EProcessFilterNames["durationOfTransition"] = "durationOfTransition";
-})(exports.EProcessFilterNames || (exports.EProcessFilterNames = {}));
-exports.EFormulaFilterFieldKeys = void 0;
-(function (EFormulaFilterFieldKeys) {
-    EFormulaFilterFieldKeys["date"] = "date";
-    EFormulaFilterFieldKeys["dateRange"] = "dateRange";
-    EFormulaFilterFieldKeys["numberRange"] = "numberRange";
-    EFormulaFilterFieldKeys["string"] = "string";
-    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
-    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
-    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
-})(exports.EFormulaFilterFieldKeys || (exports.EFormulaFilterFieldKeys = {}));
-exports.EDimensionProcessFilterTimeUnit = void 0;
-(function (EDimensionProcessFilterTimeUnit) {
-    EDimensionProcessFilterTimeUnit["YEARS"] = "YEARS";
-    EDimensionProcessFilterTimeUnit["MONTHS"] = "MONTHS";
-    EDimensionProcessFilterTimeUnit["HOURS"] = "HOURS";
-    EDimensionProcessFilterTimeUnit["DAYS"] = "DAYS";
-    EDimensionProcessFilterTimeUnit["MINUTES"] = "MINUTES";
-})(exports.EDimensionProcessFilterTimeUnit || (exports.EDimensionProcessFilterTimeUnit = {}));
-var isFormulaFilterValue = function (value) {
-    return "filteringMethod" in value;
-};
-var isDimensionProcessFilter = function (filter) { return "value" in filter && "condition" in filter; };
-
-var compact = function (items) { return ((items === null || items === void 0 ? void 0 : items.filter(Boolean)) || []); };
-var compactMap = function (items, f) {
-    return compact(items === null || items === void 0 ? void 0 : items.map(f));
-};
-var isNil = function (value) {
-    return value === null || value === undefined;
-};
-function memoize(fn) {
-    var cache = new Map();
-    return function (arg) {
-        if (cache.has(arg)) {
-            return cache.get(arg);
-        }
-        var result = fn(arg);
-        cache.set(arg, result);
-        return result;
-    };
-}
-
-exports.EClickHouseBaseTypes = void 0;
-(function (EClickHouseBaseTypes) {
-    // DATE
-    EClickHouseBaseTypes["Date"] = "Date";
-    EClickHouseBaseTypes["Date32"] = "Date32";
-    // DATETIME
-    EClickHouseBaseTypes["DateTime"] = "DateTime";
-    EClickHouseBaseTypes["DateTime32"] = "DateTime32";
-    // DATETIME64
-    EClickHouseBaseTypes["DateTime64"] = "DateTime64";
-    // STRING
-    EClickHouseBaseTypes["FixedString"] = "FixedString";
-    EClickHouseBaseTypes["String"] = "String";
-    // FLOAT
-    EClickHouseBaseTypes["Decimal"] = "Decimal";
-    EClickHouseBaseTypes["Decimal32"] = "Decimal32";
-    EClickHouseBaseTypes["Decimal64"] = "Decimal64";
-    EClickHouseBaseTypes["Decimal128"] = "Decimal128";
-    EClickHouseBaseTypes["Decimal256"] = "Decimal256";
-    EClickHouseBaseTypes["Float32"] = "Float32";
-    EClickHouseBaseTypes["Float64"] = "Float64";
-    // INTEGER
-    EClickHouseBaseTypes["Int8"] = "Int8";
-    EClickHouseBaseTypes["Int16"] = "Int16";
-    EClickHouseBaseTypes["Int32"] = "Int32";
-    EClickHouseBaseTypes["Int64"] = "Int64";
-    EClickHouseBaseTypes["Int128"] = "Int128";
-    EClickHouseBaseTypes["Int256"] = "Int256";
-    EClickHouseBaseTypes["UInt8"] = "UInt8";
-    EClickHouseBaseTypes["UInt16"] = "UInt16";
-    EClickHouseBaseTypes["UInt32"] = "UInt32";
-    EClickHouseBaseTypes["UInt64"] = "UInt64";
-    EClickHouseBaseTypes["UInt128"] = "UInt128";
-    EClickHouseBaseTypes["UInt256"] = "UInt256";
-    // BOOLEAN
-    EClickHouseBaseTypes["Bool"] = "Bool";
-})(exports.EClickHouseBaseTypes || (exports.EClickHouseBaseTypes = {}));
-var stringTypes = ["String", "FixedString"];
-var parseClickHouseType = memoize(function (type) {
-    if (isNil(type)) {
-        return {
-            simpleBaseType: exports.ESimpleDataType.OTHER,
-            dbBaseDataType: undefined,
-            containers: [],
-            simpleType: exports.ESimpleDataType.OTHER,
-        };
-    }
-    var _a = extractInnerType(type), containers = _a.containers, dbBaseDataType = _a.dbBaseDataType;
-    if (!dbBaseDataType) {
-        throw new Error("Invalid ClickHouse type: ".concat(type));
-    }
-    return {
-        dbBaseDataType: dbBaseDataType,
-        simpleBaseType: simplifyBaseType(dbBaseDataType),
-        containers: containers,
-        get simpleType() {
-            return containers.includes("Array") ? exports.ESimpleDataType.OTHER : this.simpleBaseType;
-        },
-    };
-});
-/** 'A(B(C))' -> ['A', 'B', 'C'] */
-var splitByBrackets = function (input) { return input.split(/[\(\)]/).filter(Boolean); };
-/**
- * Отделить внутренний тип от оберток.
- * Не поддерживаются обертки Tuple и LowCardinality.
- */
-var extractInnerType = function (type) {
-    var tokens = splitByBrackets(type);
-    // Удаление параметров типа.
-    if (tokens.length > 0 && isTypeParameters(tokens.at(-1))) {
-        tokens.pop();
-    }
-    var dbBaseDataType = tokens.pop();
-    return { containers: tokens, dbBaseDataType: dbBaseDataType };
-};
-var simplifyBaseType = function (dbBaseType) {
-    var isSourceTypeStartsWith = function (prefix) { return dbBaseType.startsWith(prefix); };
-    if (isSourceTypeStartsWith("Int") || isSourceTypeStartsWith("UInt")) {
-        return exports.ESimpleDataType.INTEGER;
-    }
-    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
-        return exports.ESimpleDataType.FLOAT;
-    }
-    if (stringTypes.some(isSourceTypeStartsWith)) {
-        return exports.ESimpleDataType.STRING;
-    }
-    if (isSourceTypeStartsWith("DateTime64")) {
-        return exports.ESimpleDataType.DATETIME64;
-    }
-    if (isSourceTypeStartsWith("DateTime")) {
-        return exports.ESimpleDataType.DATETIME;
-    }
-    if (isSourceTypeStartsWith("Date")) {
-        return exports.ESimpleDataType.DATE;
-    }
-    if (isSourceTypeStartsWith("Bool")) {
-        return exports.ESimpleDataType.BOOLEAN;
-    }
-    return exports.ESimpleDataType.OTHER;
-};
-/**
- * - `3` -> true
- * - `3, 'Europe/Moscow'` -> true
- * - `3, Europe/Moscow` -> false
- *
- * Пример типа с параметрами: `DateTime64(3, 'Europe/Moscow')`
- */
-var isTypeParameters = function (stringifiedParameters) {
-    return stringifiedParameters.split(", ").some(function (p) { return !Number.isNaN(Number(p)) || p.startsWith("'"); });
-};
-
 exports.EFormatTypes = void 0;
 (function (EFormatTypes) {
     /** Дата */
@@ -649,6 +445,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;
+};
+
+exports.EWidgetIndicatorType = void 0;
+(function (EWidgetIndicatorType) {
+    EWidgetIndicatorType["MEASURE"] = "MEASURE";
+    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
+    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
+    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
+    EWidgetIndicatorType["SORTING"] = "SORTING";
+})(exports.EWidgetIndicatorType || (exports.EWidgetIndicatorType = {}));
+exports.EOuterAggregation = void 0;
+(function (EOuterAggregation) {
+    EOuterAggregation["avg"] = "avg";
+    EOuterAggregation["median"] = "median";
+    EOuterAggregation["count"] = "count";
+    EOuterAggregation["countDistinct"] = "countDistinct";
+    EOuterAggregation["min"] = "min";
+    EOuterAggregation["max"] = "max";
+    EOuterAggregation["sum"] = "sum";
+    EOuterAggregation["top"] = "top";
+})(exports.EOuterAggregation || (exports.EOuterAggregation = {}));
+/** Режимы значения показателя (на основе чего генерируется формула) */
+exports.EWidgetIndicatorValueModes = void 0;
+(function (EWidgetIndicatorValueModes) {
+    /** Готовая формула (как правило, введенная пользователем через редактор формул) */
+    EWidgetIndicatorValueModes["FORMULA"] = "FORMULA";
+    /** Шаблон формулы, предоставляемый системой */
+    EWidgetIndicatorValueModes["TEMPLATE"] = "TEMPLATE";
+    EWidgetIndicatorValueModes["AGGREGATION"] = "AGGREGATION";
+    EWidgetIndicatorValueModes["DURATION"] = "DURATION";
+    EWidgetIndicatorValueModes["CONVERSION"] = "CONVERSION";
+    EWidgetIndicatorValueModes["START_TIME"] = "START_TIME";
+    EWidgetIndicatorValueModes["END_TIME"] = "END_TIME";
+})(exports.EWidgetIndicatorValueModes || (exports.EWidgetIndicatorValueModes = {}));
+/** Режимы сортировки (на что ссылается сортировка) */
+exports.ESortingValueModes = void 0;
+(function (ESortingValueModes) {
+    /** Сортировка по формуле */
+    ESortingValueModes["FORMULA"] = "FORMULA";
+    /** Сортировка по показателю(разрезу или мере) виджета */
+    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
+})(exports.ESortingValueModes || (exports.ESortingValueModes = {}));
+exports.EFormatOrFormattingMode = void 0;
+(function (EFormatOrFormattingMode) {
+    EFormatOrFormattingMode["BASE"] = "BASE";
+    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
+})(exports.EFormatOrFormattingMode || (exports.EFormatOrFormattingMode = {}));
+function inheritDisplayConditionFromHierarchy(dimension, hierarchy) {
+    return __assign(__assign({}, dimension), { displayCondition: hierarchy.displayCondition });
+}
+/** Тип показателя */
+exports.EIndicatorType = void 0;
+(function (EIndicatorType) {
+    /** Показатели процесса */
+    EIndicatorType["PROCESS_MEASURE"] = "PROCESS_MEASURE";
+    /** Вводимое значение */
+    EIndicatorType["STATIC"] = "STATIC";
+    /** Статический список */
+    EIndicatorType["STATIC_LIST"] = "STATIC_LIST";
+    /** Динамический список */
+    EIndicatorType["DYNAMIC_LIST"] = "DYNAMIC_LIST";
+    /** Список колонок */
+    EIndicatorType["COLUMN_LIST"] = "COLUMN_LIST";
+    /** Разрез */
+    EIndicatorType["DIMENSION"] = "DIMENSION";
+    /** Мера */
+    EIndicatorType["MEASURE"] = "MEASURE";
+    /** Иерархия */
+    EIndicatorType["DYNAMIC_DIMENSION"] = "DYNAMIC_DIMENSION";
+    /** Пользовательская сортировка */
+    EIndicatorType["USER_SORTING"] = "USER_SORTING";
+})(exports.EIndicatorType || (exports.EIndicatorType = {}));
+/** Обобщенные типы значений переменных */
+exports.ESimpleInputType = void 0;
+(function (ESimpleInputType) {
+    /** Число (точность Float64) */
+    ESimpleInputType["NUMBER"] = "FLOAT";
+    /** Целое число (точность Int64) */
+    ESimpleInputType["INTEGER_NUMBER"] = "INTEGER";
+    /** Текст */
+    ESimpleInputType["TEXT"] = "STRING";
+    /** Дата (точность Date) */
+    ESimpleInputType["DATE"] = "DATE";
+    /** Дата и время (точность DateTime64) */
+    ESimpleInputType["DATE_AND_TIME"] = "DATETIME";
+    /** Логический тип */
+    ESimpleInputType["BOOLEAN"] = "BOOLEAN";
+})(exports.ESimpleInputType || (exports.ESimpleInputType = {}));
+function isDimensionsHierarchy(indicator) {
+    return "hierarchyDimensions" in indicator;
+}
+exports.OuterAggregation = void 0;
+(function (OuterAggregation) {
+    OuterAggregation["avg"] = "avgIf";
+    OuterAggregation["median"] = "medianIf";
+    OuterAggregation["count"] = "countIf";
+    OuterAggregation["countDistinct"] = "countIfDistinct";
+    OuterAggregation["min"] = "minIf";
+    OuterAggregation["max"] = "maxIf";
+    OuterAggregation["sum"] = "sumIf";
+})(exports.OuterAggregation || (exports.OuterAggregation = {}));
+exports.EDurationTemplateName = void 0;
+(function (EDurationTemplateName) {
+    EDurationTemplateName["avg"] = "avg";
+    EDurationTemplateName["median"] = "median";
+})(exports.EDurationTemplateName || (exports.EDurationTemplateName = {}));
+exports.EEventAppearances = void 0;
+(function (EEventAppearances) {
+    EEventAppearances["FIRST"] = "FIRST";
+    EEventAppearances["LAST"] = "LAST";
+})(exports.EEventAppearances || (exports.EEventAppearances = {}));
+
+// Типы, используемые в значениях элементов управления.
+exports.EWidgetFilterMode = void 0;
+(function (EWidgetFilterMode) {
+    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
+    EWidgetFilterMode["SINGLE"] = "SINGLE";
+    EWidgetFilterMode["DISABLED"] = "DISABLED";
+})(exports.EWidgetFilterMode || (exports.EWidgetFilterMode = {}));
+exports.EMarkdownDisplayMode = void 0;
+(function (EMarkdownDisplayMode) {
+    EMarkdownDisplayMode["NONE"] = "NONE";
+    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
+})(exports.EMarkdownDisplayMode || (exports.EMarkdownDisplayMode = {}));
+exports.EDisplayConditionMode = void 0;
+(function (EDisplayConditionMode) {
+    EDisplayConditionMode["DISABLED"] = "DISABLED";
+    EDisplayConditionMode["FORMULA"] = "FORMULA";
+    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
+})(exports.EDisplayConditionMode || (exports.EDisplayConditionMode = {}));
+exports.EFontWeight = void 0;
+(function (EFontWeight) {
+    EFontWeight["NORMAL"] = "NORMAL";
+    EFontWeight["BOLD"] = "BOLD";
+})(exports.EFontWeight || (exports.EFontWeight = {}));
+exports.EHeightMode = void 0;
+(function (EHeightMode) {
+    EHeightMode["FIXED"] = "FIXED";
+    EHeightMode["PERCENT"] = "PERCENT";
+})(exports.EHeightMode || (exports.EHeightMode = {}));
+
+var SortDirectionSchema = function (z) {
+    return z.union([z.literal(exports.ESortDirection.ascend), z.literal(exports.ESortDirection.descend)]);
+};
+var SortOrderSchema = function (z) {
+    return z.object({
+        /** Формула сортировки */
+        formula: FormulaSchema(z),
+        /** Тип данных формулы */
+        dbDataType: z.string().optional(),
+        /** Направление сортировки */
+        direction: SortDirectionSchema(z),
+        /** Условие применения сортировки */
+        displayCondition: FormulaSchema(z).optional(),
+    });
+};
+var WidgetSortingValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.ESortingValueModes.FORMULA),
+            formula: FormulaSchema(z),
+            dbDataType: z.string().optional(),
+        }),
+        z.object({
+            mode: z.literal(exports.ESortingValueModes.IN_WIDGET),
+            group: z.string(),
+            index: z.number(),
+        }),
+    ]);
+};
+
+/** Ключи мета-данных внутри схем настроек */
+exports.ESettingsSchemaMetaKey = void 0;
+(function (ESettingsSchemaMetaKey) {
+    /** Привязка значения из темы к настройке */
+    ESettingsSchemaMetaKey["themeValue"] = "themeValue";
+    /** Тип сущности */
+    ESettingsSchemaMetaKey["entity"] = "entity";
+})(exports.ESettingsSchemaMetaKey || (exports.ESettingsSchemaMetaKey = {}));
+
+var _a$6;
+var RangeSchema = function (z) {
+    return z.object({
+        unit: z.string().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+    });
+};
+var DisplayConditionSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.DISABLED),
+        }),
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(exports.EDisplayConditionMode.VARIABLE),
+            variableName: NameNullableSchema(z),
+            variableValue: z.string().nullable().default(null),
+        }),
+    ])
+        .default({ mode: exports.EDisplayConditionMode.DISABLED });
+};
+/** Схема ключа сущности (с возможностью находиться в неинициализированном состоянии) */
+var KeyNullableSchema = function (z) { return z.string().nullable().default(null); };
+/** Схема имени сущности (с возможностью находиться в неинициализированном состоянии) */
+var NameNullableSchema = function (z) { return z.string().nullable().default(null); };
+/**
+ * Перечисление системных типов сущностей в схеме настроек виджетов.
+ * @note при расширении лучше положить на более общий уровень.
+ */
+var EEntity;
+(function (EEntity) {
+    EEntity["formula"] = "formula";
+})(EEntity || (EEntity = {}));
+var formulaMeta = Object.freeze((_a$6 = {}, _a$6[exports.ESettingsSchemaMetaKey.entity] = EEntity.formula, _a$6));
+/** Схема формулы */
+var FormulaSchema = function (z) { return z.string().default("").meta(formulaMeta); };
+/**
+ * Схема формулы, которая не может быть пустой строкой, но может быть в
+ * неинициализированном состоянии null (вместо пустой строки)
+ *
+ * @note для обратной совместимости без необходимости писать миграции
+ */
+var FormulaNullableSchema = function (z) {
+    return z.string().nullable().default(null).meta(formulaMeta);
+};
+
+var WidgetIndicatorSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var FormatSchema = function (z) {
+    return z
+        .object({
+        mode: z.enum(exports.EFormatOrFormattingMode),
+        value: z.enum(exports.EFormatTypes).optional(),
+    })
+        .default({ mode: exports.EFormatOrFormattingMode.BASE, value: exports.EFormatTypes.STRING });
+};
+var FormattingSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EFormatOrFormattingMode.BASE),
+            value: z.enum(exports.EFormattingPresets).default(exports.EFormattingPresets.AUTO),
+        }),
+        z.object({
+            mode: z.literal(exports.EFormatOrFormattingMode.TEMPLATE),
+            value: z.string().default(""),
+        }),
+    ])
+        .default({ mode: exports.EFormatOrFormattingMode.BASE, value: exports.EFormattingPresets.AUTO });
+};
+var WidgetColumnIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        dbDataType: z.string().optional(),
+        format: FormatSchema(z).optional(),
+        formatting: FormattingSchema(z).optional(),
+        displayCondition: DisplayConditionSchema(z),
+        onClick: z.array(ActionsOnClickSchema(z)).optional(),
+    });
+};
+var WidgetIndicatorFormulaValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+        formula: FormulaSchema(z).optional(),
+    });
+};
+var WidgetIndicatorTemplateValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.TEMPLATE),
+        /** Имя шаблонной формулы, использующей колонку таблицы */
+        templateName: z.string().optional(),
+        /** Имя таблицы */
+        tableName: z.string().optional(),
+        /** Имя колонки */
+        columnName: z.string().optional(),
+    });
+};
+var ColumnIndicatorValueSchema = function (z) {
+    return z.union([MeasureValueSchema(z), DimensionValueSchema(z)]);
+};
+var MeasureValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        WidgetIndicatorFormulaValueSchema(z),
+        WidgetIndicatorTemplateValueSchema(z).extend({
+            innerTemplateName: z.enum(exports.EMeasureInnerTemplateNames).optional(),
+        }),
+    ]);
+};
+var DimensionValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        WidgetIndicatorFormulaValueSchema(z),
+        WidgetIndicatorTemplateValueSchema(z).extend({
+            innerTemplateName: z.never().optional(),
+        }),
+    ]);
+};
+var WidgetIndicatorAggregationValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.AGGREGATION),
+        templateName: z.string(),
+        processKey: KeyNullableSchema(z),
+        eventName: NameNullableSchema(z),
+        eventNameFormula: FormulaNullableSchema(z),
+        anyEvent: z.literal(true).optional(),
+        caseCaseIdFormula: FormulaNullableSchema(z),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        tableName: z.string().optional(),
+        columnName: z.string().optional(),
+        eventTimeFormula: FormulaNullableSchema(z).optional(),
+    });
+};
+var WidgetMeasureAggregationValueSchema = function (z) {
+    return WidgetIndicatorAggregationValueSchema(z).extend({ outerAggregation: z.enum(exports.EOuterAggregation) });
+};
+var WidgetIndicatorTimeValueSchema = function (z) {
+    return z.object({
+        templateName: z.string(),
+        mode: z.union([
+            z.literal(exports.EWidgetIndicatorValueModes.START_TIME),
+            z.literal(exports.EWidgetIndicatorValueModes.END_TIME),
+        ]),
+        processKey: KeyNullableSchema(z),
+        eventName: NameNullableSchema(z),
+        eventTimeFormula: FormulaNullableSchema(z),
+        caseCaseIdFormula: FormulaNullableSchema(z),
+        eventNameFormula: FormulaNullableSchema(z),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+    });
+};
+var WidgetDimensionSchema = function (z) {
+    return WidgetColumnIndicatorSchema(z).extend({
+        value: z
+            .discriminatedUnion("mode", [
+            DimensionValueSchema(z),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                innerTemplateName: z.string().optional(),
+            }),
+            WidgetIndicatorTimeValueSchema(z),
+        ])
+            .optional(),
+        hideEmptyValues: z.boolean().default(false),
+    });
+};
+var WidgetDimensionInHierarchySchema = function (z) {
+    return WidgetDimensionSchema(z).omit({ displayCondition: true });
+};
+var WidgetDimensionHierarchySchema = function (z, dimensionSchema) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        // Для иерархии является дискриминатором, для него нельзя задавать дефолтное значение.
+        hierarchyDimensions: z.array(dimensionSchema),
+        displayCondition: DisplayConditionSchema(z),
+    });
+};
+var WidgetIndicatorConversionValueSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.CONVERSION),
+        startEventNameFormula: FormulaNullableSchema(z),
+        startEventProcessKey: KeyNullableSchema(z),
+        startEventName: NameNullableSchema(z),
+        startEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        startEventTimeFormula: FormulaNullableSchema(z),
+        endEventNameFormula: FormulaNullableSchema(z),
+        endEventProcessKey: KeyNullableSchema(z),
+        endEventName: NameNullableSchema(z),
+        endEventFilters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        endCaseCaseIdFormula: FormulaNullableSchema(z),
+        endEventTimeFormula: FormulaNullableSchema(z),
+    });
+};
+var WidgetIndicatorDurationValueSchema = function (z) {
+    return WidgetIndicatorConversionValueSchema(z).extend({
+        mode: z.literal(exports.EWidgetIndicatorValueModes.DURATION),
+        templateName: z.string(),
+        startEventAppearances: z.enum(exports.EEventAppearances),
+        endEventAppearances: z.enum(exports.EEventAppearances),
+    });
+};
+var WidgetMeasureSchema = function (z) {
+    return WidgetColumnIndicatorSchema(z).extend({
+        value: z
+            .discriminatedUnion("mode", [
+            MeasureValueSchema(z),
+            WidgetMeasureAggregationValueSchema(z),
+            WidgetIndicatorConversionValueSchema(z),
+            WidgetIndicatorDurationValueSchema(z),
+        ])
+            .optional(),
+    });
+};
+var MarkdownMeasureSchema = function (z) {
+    return WidgetMeasureSchema(z).extend({
+        displaySign: z.enum(exports.EMarkdownDisplayMode).default(exports.EMarkdownDisplayMode.NONE),
+    });
+};
+var WidgetSortingIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        direction: SortDirectionSchema(z),
+        value: WidgetSortingValueSchema(z),
+    });
+};
+var ProcessIndicatorValueSchema = function (z) {
+    return z.discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(exports.EWidgetIndicatorValueModes.TEMPLATE),
+            /** Имя шаблонной формулы, использующей колонку таблицы */
+            templateName: z.string(),
+        }),
+    ]);
+};
+var ProcessIndicatorSchema = function (z) {
+    return WidgetIndicatorSchema(z).extend({
+        value: ProcessIndicatorValueSchema(z).optional(),
+        dbDataType: z.string().optional(),
+        format: FormatSchema(z).optional(),
+        formatting: FormattingSchema(z).optional(),
+        displayCondition: DisplayConditionSchema(z),
+    });
+};
+
+var FormulaFilterValueSchema = function (z) {
+    var _a;
+    return z.object({
+        name: z.string().nullish(),
+        formula: z.string(),
+        sliceIndex: z.number().optional(),
+        dbDataType: z.string(),
+        format: z.enum(exports.EFormatTypes),
+        filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+        checkedValues: z.array(z.string().nullable()).optional(),
+        formValues: z
+            .object((_a = {},
+            _a[exports.EFormulaFilterFieldKeys.date] = z.string().nullable(),
+            _a[exports.EFormulaFilterFieldKeys.dateRange] = z.tuple([z.string(), z.string()]),
+            _a[exports.EFormulaFilterFieldKeys.numberRange] = z.tuple([
+                z.number().optional(),
+                z.number().optional(),
+            ]),
+            _a[exports.EFormulaFilterFieldKeys.string] = z.string(),
+            // todo: отказаться от использования z.string(), оставить только z.number() [BI-15912]
+            _a[exports.EFormulaFilterFieldKeys.lastTimeValue] = z.number().or(z.string()),
+            _a[exports.EFormulaFilterFieldKeys.lastTimeUnit] = z.enum(exports.ELastTimeUnit),
+            _a[exports.EFormulaFilterFieldKeys.durationUnit] = z.enum(exports.EDurationUnit),
+            _a))
+            .partial()
+            .optional(),
+    });
+};
+var ExtendedFormulaFilterValueSchema = function (z) {
+    return z.union([FormulaFilterValueSchema(z), z.object({ formula: z.string() })]);
+};
+var DimensionProcessFilterSchema = function (z) {
+    return z.object({
+        value: z.union([
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                outerAggregation: z.enum(exports.EOuterAggregation),
+            }),
+            WidgetIndicatorAggregationValueSchema(z).extend({
+                innerTemplateName: z.string().optional(),
+            }),
+            WidgetIndicatorTimeValueSchema(z),
+            z.object({
+                mode: z.literal(exports.EWidgetIndicatorValueModes.FORMULA),
+                formula: z.string().optional(),
+            }),
+        ]),
+        dbDataType: z.string(),
+        condition: z.object({
+            filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+            timeUnit: z.enum(exports.EDimensionProcessFilterTimeUnit).optional(),
+            values: z.array(z.string().nullable()),
+        }),
+    });
+};
+var SettingsFilterSchema = function (z) {
+    return z.union([ExtendedFormulaFilterValueSchema(z), DimensionProcessFilterSchema(z)]);
+};
+
+var ActionOnClickParameterCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var ParameterFromColumnSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.COLUMN),
+        tableName: z.string().nullable().default(null),
+        columnName: z.string().nullable().default(null),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromVariableSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.VARIABLE),
+        sourceVariable: z.string().nullable().default(null),
+    });
+};
+var ParameterFromFormulaSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.FORMULA),
+        formula: FormulaSchema(z),
+        considerFilters: z.boolean().default(false),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.EVENT),
+    });
+};
+var ParameterFromStartEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.START_EVENT),
+    });
+};
+var ParameterFromEndEventSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.FINISH_EVENT),
+    });
+};
+var ParameterFromAggregationSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.AGGREGATION),
+        formula: FormulaSchema(z),
+        considerFilters: z.boolean().default(false),
+        dbDataType: z.string().optional(),
+    });
+};
+var ParameterFromManualInputSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.MANUALLY),
+        description: z.string().default(""),
+        defaultValue: FormulaSchema(z),
+        dbDataType: z.string().optional(),
+        filterByRows: z.boolean().default(false),
+        validation: FormulaSchema(z),
+        acceptEmptyValue: z.boolean().default(false),
+    });
+};
+var ParameterFromStaticListSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.STATIC_LIST),
+        options: z.string().default(""),
+        defaultValue: z
+            .union([z.string(), z.array(z.string())])
+            .nullable()
+            .default(null),
+        acceptEmptyValue: z.boolean().default(false),
+    });
+};
+var ParameterFromDynamicListSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.DYNAMIC_LIST),
+        options: FormulaSchema(z),
+        defaultValue: FormulaSchema(z),
+        dbDataType: z.string().optional(),
+        displayOptions: FormulaSchema(z),
+        filters: z.array(ExtendedFormulaFilterValueSchema(z)).default([]),
+        filterByRows: z.boolean().default(false),
+        considerFilters: z.boolean().default(false),
+        insertAnyValues: z.boolean().default(false),
+        validation: FormulaSchema(z),
+        acceptEmptyValue: z.boolean().default(false),
+    });
+};
+var ParameterFromDataModelSchema = function (z) {
+    return z.object({
+        inputMethod: z.literal(exports.EWidgetActionInputMethod.DATA_MODEL),
+        option: z.enum(exports.EDataModelOption).default(exports.EDataModelOption.TABLE_LIST),
+        /**
+         * Используется только при COLUMN_LIST. Не делаем union по option, чтобы сохранить
+         * одновременно default для option и работоспособность внешнего discriminated union.
+         */
+        parent: NameNullableSchema(z),
+    });
+};
+var ActionOnClickParameterSchema = function (z) {
+    return z.intersection(ActionOnClickParameterCommonSchema(z), z.discriminatedUnion("inputMethod", [
+        ParameterFromColumnSchema(z),
+        ParameterFromVariableSchema(z),
+        ParameterFromFormulaSchema(z),
+        ParameterFromEventSchema(z),
+        ParameterFromStartEventSchema(z),
+        ParameterFromEndEventSchema(z),
+        ParameterFromAggregationSchema(z),
+        ParameterFromManualInputSchema(z),
+        ParameterFromStaticListSchema(z),
+        ParameterFromDynamicListSchema(z),
+        ParameterFromDataModelSchema(z),
+    ]));
+};
+var ActionCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+    });
+};
+var ActionDrillDownSchema = function (z) {
+    return ActionCommonSchema(z).extend({ type: z.literal(exports.EActionTypes.DRILL_DOWN) });
+};
+var ActionGoToURLSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.OPEN_URL),
+        url: z.string(),
+        newWindow: z.boolean().default(true),
+    });
+};
+var ActivateConditionSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        z.object({
+            mode: z.literal(exports.EActivateConditionMode.FORMULA),
+            formula: FormulaSchema(z),
+        }),
+        z.object({
+            mode: z.literal(exports.EActivateConditionMode.VARIABLE),
+            variableName: z.string().nullable().default(null),
+            variableValue: z.string().nullable().default(null),
+        }),
+    ])
+        .default({ mode: exports.EActivateConditionMode.FORMULA, formula: "" });
+};
+var ActionRunScriptSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.EAutoUpdateMode.THIS_WIDGET),
+        hideInactiveButton: z.boolean().default(false),
+        activateCondition: ActivateConditionSchema(z),
+        hint: z.string().default(""),
+    });
+};
+var ActionUpdateVariableSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        type: z.literal(exports.EActionTypes.UPDATE_VARIABLE),
+        variables: z.array(ActionOnClickParameterSchema(z)).default([]),
+    });
+};
+var ActionOpenInSchema = function (z) {
+    return z.discriminatedUnion("openIn", [
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.DRAWER_WINDOW),
+            alignment: z.enum(exports.EDrawerPlacement).default(exports.EDrawerPlacement.RIGHT),
+            inheritFilter: z.boolean().default(true),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
+            placeholderName: z.string(),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.MODAL_WINDOW),
+            positionByClick: z.boolean().default(false),
+            inheritFilter: z.boolean().default(true),
+        }),
+        z.object({
+            openIn: z.literal(exports.EViewOpenIn.WINDOW),
+            newWindow: z.boolean().default(true),
+            inheritFilter: z.boolean().default(true),
+        }),
+    ]);
+};
+var ActionOpenViewCommonSchema = function (z) {
+    return ActionCommonSchema(z).extend({ type: z.literal(exports.EActionTypes.OPEN_VIEW) });
+};
+var ActionOpenViewSchema = function (z) {
+    return z.intersection(z.discriminatedUnion("mode", [
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.GENERATED_BY_SCRIPT),
+            scriptKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+            displayName: z.string().default(""),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.EXISTED_VIEW),
+            viewKey: z.string(),
+            parameters: z.array(ActionOnClickParameterSchema(z)).default([]),
+        }),
+        ActionOpenViewCommonSchema(z).extend({
+            mode: z.literal(exports.EViewMode.EMPTY),
+            placeholderName: z.string(),
+            openIn: z.literal(exports.EViewOpenIn.PLACEHOLDER),
+        }),
+    ]), ActionOpenInSchema(z));
+};
+var ActionsOnClickSchema = function (z) {
+    return z.union([
+        ActionGoToURLSchema(z),
+        ActionRunScriptSchema(z),
+        ActionUpdateVariableSchema(z),
+        ActionOpenViewSchema(z),
+        ActionDrillDownSchema(z),
+    ]);
+};
+var WidgetActionParameterCommonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        displayName: z.string().default(""),
+        isHidden: z.boolean().default(false),
+    });
+};
+var WidgetActionParameterSchema = function (z) {
+    return z.intersection(WidgetActionParameterCommonSchema(z), z.discriminatedUnion("inputMethod", [
+        ParameterFromColumnSchema(z),
+        ParameterFromVariableSchema(z),
+        ParameterFromFormulaSchema(z),
+        ParameterFromManualInputSchema(z),
+        ParameterFromStaticListSchema(z),
+        ParameterFromDynamicListSchema(z),
+        ParameterFromAggregationSchema(z),
+        ParameterFromDataModelSchema(z),
+    ]));
+};
+var WidgetActionSchema = function (z) {
+    return ActionCommonSchema(z).extend({
+        parameters: z.array(WidgetActionParameterSchema(z)).default([]),
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT),
+        scriptKey: z.string(),
+        autoUpdate: z.enum(exports.EAutoUpdateMode).default(exports.EAutoUpdateMode.THIS_WIDGET),
+        description: z.string().default(""),
+        hideInactiveButton: z.boolean().default(false),
+        hint: z.string().default(""),
+        activateCondition: ActivateConditionSchema(z),
+    });
+};
+var ViewActionParameterSchema = function (z) {
+    return z.intersection(AutoIdentifiedArrayItemSchema(z).extend({ name: z.string() }), z.discriminatedUnion("inputMethod", [
+        ParameterFromAggregationSchema(z),
+        ParameterFromVariableSchema(z),
+    ]));
+};
+var ViewActionSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        buttonType: z.enum(exports.EActionButtonsTypes).default(exports.EActionButtonsTypes.BASE),
+        type: z.literal(exports.EActionTypes.EXECUTE_SCRIPT).default(exports.EActionTypes.EXECUTE_SCRIPT),
+        parameters: z.array(ViewActionParameterSchema(z)).default([]),
+        scriptKey: KeyNullableSchema(z),
+        autoUpdate: z
+            .union([z.literal(exports.EAutoUpdateMode.NONE), z.literal(exports.EAutoUpdateMode.ALL_VIEWS)])
+            .default(exports.EAutoUpdateMode.NONE),
+    });
+};
+var ActionSchema = function (z) {
+    return z.union([ActionsOnClickSchema(z), WidgetActionSchema(z), ViewActionSchema(z)]);
+};
+var ActionButtonSchema = function (z) {
+    return AutoIdentifiedArrayItemSchema(z).extend({
+        name: z.string(),
+        onClick: z.array(WidgetActionSchema(z)).default([]),
+        buttonType: z.enum(exports.EActionButtonsTypes).default(exports.EActionButtonsTypes.BASE),
+        backgroundColor: ColorSchema(z),
+        borderColor: ColorSchema(z),
+        color: ColorSchema(z),
+        hint: z.string().default(""),
+    });
+};
+
+var prepareValuesForSql = function (simpleType, values) {
+    return simpleType === exports.ESimpleDataType.INTEGER ||
+        simpleType === exports.ESimpleDataType.FLOAT ||
+        simpleType === exports.ESimpleDataType.BOOLEAN
+        ? values
+        : values.map(function (value) {
+            return value === null ? null : "'".concat(escapeSingularQuotes$1(escapeReverseSlash(value)), "'");
+        });
+};
+var escapeReverseSlash = function (formula) {
+    return formula.replaceAll(/\\/gm, "\\\\");
+};
+var escapeSingularQuotes$1 = function (formula) {
+    return formula.replaceAll("'", "\\'");
+};
+
+exports.ECalculatorFilterMethods = void 0;
+(function (ECalculatorFilterMethods) {
+    ECalculatorFilterMethods["EQUAL_TO"] = "EQUAL_TO";
+    ECalculatorFilterMethods["NOT_EQUAL_TO"] = "NOT_EQUAL_TO";
+    ECalculatorFilterMethods["GREATER_THAN"] = "GREATER_THAN";
+    ECalculatorFilterMethods["LESS_THAN"] = "LESS_THAN";
+    ECalculatorFilterMethods["GREATER_THAN_OR_EQUAL_TO"] = "GREATER_THAN_OR_EQUAL_TO";
+    ECalculatorFilterMethods["LESS_THAN_OR_EQUAL_TO"] = "LESS_THAN_OR_EQUAL_TO";
+    ECalculatorFilterMethods["STARTS_WITH"] = "STARTS_WITH";
+    ECalculatorFilterMethods["ENDS_WITH"] = "ENDS_WITH";
+    ECalculatorFilterMethods["CONTAINS"] = "CONTAINS";
+    ECalculatorFilterMethods["NOT_CONTAINS"] = "NOT_CONTAINS";
+    ECalculatorFilterMethods["IN_RANGE"] = "IN_RANGE";
+    ECalculatorFilterMethods["NOT_IN_RANGE"] = "NOT_IN_RANGE";
+    ECalculatorFilterMethods["INCLUDE"] = "INCLUDE";
+    ECalculatorFilterMethods["EXCLUDE"] = "EXCLUDE";
+    ECalculatorFilterMethods["NONEMPTY"] = "NONEMPTY";
+    ECalculatorFilterMethods["EMPTY"] = "EMPTY";
+})(exports.ECalculatorFilterMethods || (exports.ECalculatorFilterMethods = {}));
+
+var formulaFilterMethods = __assign(__assign({}, exports.ECalculatorFilterMethods), { LAST_TIME: "LAST_TIME" });
+exports.EProcessFilterNames = void 0;
+(function (EProcessFilterNames) {
+    /** Наличие события */
+    EProcessFilterNames["presenceOfEvent"] = "presenceOfEvent";
+    /** Количество повторов события */
+    EProcessFilterNames["repetitionOfEvent"] = "repetitionOfEvent";
+    /** Наличие перехода */
+    EProcessFilterNames["presenceOfTransition"] = "presenceOfTransition";
+    /** Длительность перехода */
+    EProcessFilterNames["durationOfTransition"] = "durationOfTransition";
+})(exports.EProcessFilterNames || (exports.EProcessFilterNames = {}));
+exports.EFormulaFilterFieldKeys = void 0;
+(function (EFormulaFilterFieldKeys) {
+    EFormulaFilterFieldKeys["date"] = "date";
+    EFormulaFilterFieldKeys["dateRange"] = "dateRange";
+    EFormulaFilterFieldKeys["numberRange"] = "numberRange";
+    EFormulaFilterFieldKeys["string"] = "string";
+    EFormulaFilterFieldKeys["lastTimeValue"] = "lastTimeValue";
+    EFormulaFilterFieldKeys["lastTimeUnit"] = "lastTimeUnit";
+    EFormulaFilterFieldKeys["durationUnit"] = "durationUnit";
+})(exports.EFormulaFilterFieldKeys || (exports.EFormulaFilterFieldKeys = {}));
+exports.EDimensionProcessFilterTimeUnit = void 0;
+(function (EDimensionProcessFilterTimeUnit) {
+    EDimensionProcessFilterTimeUnit["YEARS"] = "YEARS";
+    EDimensionProcessFilterTimeUnit["MONTHS"] = "MONTHS";
+    EDimensionProcessFilterTimeUnit["HOURS"] = "HOURS";
+    EDimensionProcessFilterTimeUnit["DAYS"] = "DAYS";
+    EDimensionProcessFilterTimeUnit["MINUTES"] = "MINUTES";
+})(exports.EDimensionProcessFilterTimeUnit || (exports.EDimensionProcessFilterTimeUnit = {}));
+var isFormulaFilterValue = function (value) {
+    return "filteringMethod" in value;
+};
+var isDimensionProcessFilter = function (filter) { return "value" in filter && "condition" in filter; };
+
+var compact = function (items) { return ((items === null || items === void 0 ? void 0 : items.filter(Boolean)) || []); };
+var compactMap = function (items, f) {
+    return compact(items === null || items === void 0 ? void 0 : items.map(f));
+};
+var isNil = function (value) {
+    return value === null || value === undefined;
+};
+function memoize(fn) {
+    var cache = new Map();
+    return function (arg) {
+        if (cache.has(arg)) {
+            return cache.get(arg);
+        }
+        var result = fn(arg);
+        cache.set(arg, result);
+        return result;
+    };
+}
+
+exports.EClickHouseBaseTypes = void 0;
+(function (EClickHouseBaseTypes) {
+    // DATE
+    EClickHouseBaseTypes["Date"] = "Date";
+    EClickHouseBaseTypes["Date32"] = "Date32";
+    // DATETIME
+    EClickHouseBaseTypes["DateTime"] = "DateTime";
+    EClickHouseBaseTypes["DateTime32"] = "DateTime32";
+    // DATETIME64
+    EClickHouseBaseTypes["DateTime64"] = "DateTime64";
+    // STRING
+    EClickHouseBaseTypes["FixedString"] = "FixedString";
+    EClickHouseBaseTypes["String"] = "String";
+    // FLOAT
+    EClickHouseBaseTypes["Decimal"] = "Decimal";
+    EClickHouseBaseTypes["Decimal32"] = "Decimal32";
+    EClickHouseBaseTypes["Decimal64"] = "Decimal64";
+    EClickHouseBaseTypes["Decimal128"] = "Decimal128";
+    EClickHouseBaseTypes["Decimal256"] = "Decimal256";
+    EClickHouseBaseTypes["Float32"] = "Float32";
+    EClickHouseBaseTypes["Float64"] = "Float64";
+    // INTEGER
+    EClickHouseBaseTypes["Int8"] = "Int8";
+    EClickHouseBaseTypes["Int16"] = "Int16";
+    EClickHouseBaseTypes["Int32"] = "Int32";
+    EClickHouseBaseTypes["Int64"] = "Int64";
+    EClickHouseBaseTypes["Int128"] = "Int128";
+    EClickHouseBaseTypes["Int256"] = "Int256";
+    EClickHouseBaseTypes["UInt8"] = "UInt8";
+    EClickHouseBaseTypes["UInt16"] = "UInt16";
+    EClickHouseBaseTypes["UInt32"] = "UInt32";
+    EClickHouseBaseTypes["UInt64"] = "UInt64";
+    EClickHouseBaseTypes["UInt128"] = "UInt128";
+    EClickHouseBaseTypes["UInt256"] = "UInt256";
+    // BOOLEAN
+    EClickHouseBaseTypes["Bool"] = "Bool";
+})(exports.EClickHouseBaseTypes || (exports.EClickHouseBaseTypes = {}));
+var stringTypes = ["String", "FixedString"];
+var parseClickHouseType = memoize(function (type) {
+    if (isNil(type)) {
+        return {
+            simpleBaseType: exports.ESimpleDataType.OTHER,
+            dbBaseDataType: undefined,
+            containers: [],
+            simpleType: exports.ESimpleDataType.OTHER,
+        };
+    }
+    var _a = extractInnerType(type), containers = _a.containers, dbBaseDataType = _a.dbBaseDataType;
+    if (!dbBaseDataType) {
+        throw new Error("Invalid ClickHouse type: ".concat(type));
+    }
+    return {
+        dbBaseDataType: dbBaseDataType,
+        simpleBaseType: simplifyBaseType(dbBaseDataType),
+        containers: containers,
+        get simpleType() {
+            return containers.includes("Array") ? exports.ESimpleDataType.OTHER : this.simpleBaseType;
+        },
+    };
+});
+/** 'A(B(C))' -> ['A', 'B', 'C'] */
+var splitByBrackets = function (input) { return input.split(/[\(\)]/).filter(Boolean); };
+/**
+ * Отделить внутренний тип от оберток.
+ * Не поддерживаются обертки Tuple и LowCardinality.
+ */
+var extractInnerType = function (type) {
+    var tokens = splitByBrackets(type);
+    // Удаление параметров типа.
+    if (tokens.length > 0 && isTypeParameters(tokens.at(-1))) {
+        tokens.pop();
+    }
+    var dbBaseDataType = tokens.pop();
+    return { containers: tokens, dbBaseDataType: dbBaseDataType };
+};
+var simplifyBaseType = function (dbBaseType) {
+    var isSourceTypeStartsWith = function (prefix) { return dbBaseType.startsWith(prefix); };
+    if (isSourceTypeStartsWith("Int") || isSourceTypeStartsWith("UInt")) {
+        return exports.ESimpleDataType.INTEGER;
+    }
+    if (isSourceTypeStartsWith("Decimal") || isSourceTypeStartsWith("Float")) {
+        return exports.ESimpleDataType.FLOAT;
+    }
+    if (stringTypes.some(isSourceTypeStartsWith)) {
+        return exports.ESimpleDataType.STRING;
+    }
+    if (isSourceTypeStartsWith("DateTime64")) {
+        return exports.ESimpleDataType.DATETIME64;
+    }
+    if (isSourceTypeStartsWith("DateTime")) {
+        return exports.ESimpleDataType.DATETIME;
+    }
+    if (isSourceTypeStartsWith("Date")) {
+        return exports.ESimpleDataType.DATE;
+    }
+    if (isSourceTypeStartsWith("Bool")) {
+        return exports.ESimpleDataType.BOOLEAN;
+    }
+    return exports.ESimpleDataType.OTHER;
+};
+/**
+ * - `3` -> true
+ * - `3, 'Europe/Moscow'` -> true
+ * - `3, Europe/Moscow` -> false
+ *
+ * Пример типа с параметрами: `DateTime64(3, 'Europe/Moscow')`
+ */
+var isTypeParameters = function (stringifiedParameters) {
+    return stringifiedParameters.split(", ").some(function (p) { return !Number.isNaN(Number(p)) || p.startsWith("'"); });
+};
+
 var _a$5;
 exports.EDimensionTemplateNames = void 0;
 (function (EDimensionTemplateNames) {
@@ -679,113 +1520,6 @@ var dimensionTemplateFormulas = (_a$5 = {},
     _a$5[exports.EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
     _a$5);
 
-exports.EWidgetIndicatorType = void 0;
-(function (EWidgetIndicatorType) {
-    EWidgetIndicatorType["MEASURE"] = "MEASURE";
-    EWidgetIndicatorType["EVENT_INDICATOR"] = "EVENT_INDICATOR";
-    EWidgetIndicatorType["TRANSITION_INDICATOR"] = "TRANSITION_INDICATOR";
-    EWidgetIndicatorType["DIMENSION"] = "DIMENSION";
-    EWidgetIndicatorType["SORTING"] = "SORTING";
-})(exports.EWidgetIndicatorType || (exports.EWidgetIndicatorType = {}));
-exports.EOuterAggregation = void 0;
-(function (EOuterAggregation) {
-    EOuterAggregation["avg"] = "avg";
-    EOuterAggregation["median"] = "median";
-    EOuterAggregation["count"] = "count";
-    EOuterAggregation["countDistinct"] = "countDistinct";
-    EOuterAggregation["min"] = "min";
-    EOuterAggregation["max"] = "max";
-    EOuterAggregation["sum"] = "sum";
-    EOuterAggregation["top"] = "top";
-})(exports.EOuterAggregation || (exports.EOuterAggregation = {}));
-/** Режимы значения показателя (на основе чего генерируется формула) */
-exports.EWidgetIndicatorValueModes = void 0;
-(function (EWidgetIndicatorValueModes) {
-    /** Готовая формула (как правило, введенная пользователем через редактор формул) */
-    EWidgetIndicatorValueModes["FORMULA"] = "FORMULA";
-    /** Шаблон формулы, предоставляемый системой */
-    EWidgetIndicatorValueModes["TEMPLATE"] = "TEMPLATE";
-    EWidgetIndicatorValueModes["AGGREGATION"] = "AGGREGATION";
-    EWidgetIndicatorValueModes["DURATION"] = "DURATION";
-    EWidgetIndicatorValueModes["CONVERSION"] = "CONVERSION";
-    EWidgetIndicatorValueModes["START_TIME"] = "START_TIME";
-    EWidgetIndicatorValueModes["END_TIME"] = "END_TIME";
-})(exports.EWidgetIndicatorValueModes || (exports.EWidgetIndicatorValueModes = {}));
-/** Режимы сортировки (на что ссылается сортировка) */
-exports.ESortingValueModes = void 0;
-(function (ESortingValueModes) {
-    /** Сортировка по формуле */
-    ESortingValueModes["FORMULA"] = "FORMULA";
-    /** Сортировка по показателю(разрезу или мере) виджета */
-    ESortingValueModes["IN_WIDGET"] = "IN_WIDGET";
-})(exports.ESortingValueModes || (exports.ESortingValueModes = {}));
-exports.EFormatOrFormattingMode = void 0;
-(function (EFormatOrFormattingMode) {
-    EFormatOrFormattingMode["BASE"] = "BASE";
-    EFormatOrFormattingMode["TEMPLATE"] = "TEMPLATE";
-})(exports.EFormatOrFormattingMode || (exports.EFormatOrFormattingMode = {}));
-/** Тип показателя */
-exports.EIndicatorType = void 0;
-(function (EIndicatorType) {
-    /** Показатели процесса */
-    EIndicatorType["PROCESS_MEASURE"] = "PROCESS_MEASURE";
-    /** Вводимое значение */
-    EIndicatorType["STATIC"] = "STATIC";
-    /** Статический список */
-    EIndicatorType["STATIC_LIST"] = "STATIC_LIST";
-    /** Динамический список */
-    EIndicatorType["DYNAMIC_LIST"] = "DYNAMIC_LIST";
-    /** Список колонок */
-    EIndicatorType["COLUMN_LIST"] = "COLUMN_LIST";
-    /** Разрез */
-    EIndicatorType["DIMENSION"] = "DIMENSION";
-    /** Мера */
-    EIndicatorType["MEASURE"] = "MEASURE";
-    /** Иерархия */
-    EIndicatorType["DYNAMIC_DIMENSION"] = "DYNAMIC_DIMENSION";
-    /** Пользовательская сортировка */
-    EIndicatorType["USER_SORTING"] = "USER_SORTING";
-})(exports.EIndicatorType || (exports.EIndicatorType = {}));
-/** Обобщенные типы значений переменных */
-exports.ESimpleInputType = void 0;
-(function (ESimpleInputType) {
-    /** Число (точность Float64) */
-    ESimpleInputType["NUMBER"] = "FLOAT";
-    /** Целое число (точность Int64) */
-    ESimpleInputType["INTEGER_NUMBER"] = "INTEGER";
-    /** Текст */
-    ESimpleInputType["TEXT"] = "STRING";
-    /** Дата (точность Date) */
-    ESimpleInputType["DATE"] = "DATE";
-    /** Дата и время (точность DateTime64) */
-    ESimpleInputType["DATE_AND_TIME"] = "DATETIME";
-    /** Логический тип */
-    ESimpleInputType["BOOLEAN"] = "BOOLEAN";
-})(exports.ESimpleInputType || (exports.ESimpleInputType = {}));
-function isDimensionsHierarchy(indicator) {
-    return "hierarchyDimensions" in indicator;
-}
-exports.OuterAggregation = void 0;
-(function (OuterAggregation) {
-    OuterAggregation["avg"] = "avgIf";
-    OuterAggregation["median"] = "medianIf";
-    OuterAggregation["count"] = "countIf";
-    OuterAggregation["countDistinct"] = "countIfDistinct";
-    OuterAggregation["min"] = "minIf";
-    OuterAggregation["max"] = "maxIf";
-    OuterAggregation["sum"] = "sumIf";
-})(exports.OuterAggregation || (exports.OuterAggregation = {}));
-exports.EDurationTemplateName = void 0;
-(function (EDurationTemplateName) {
-    EDurationTemplateName["avg"] = "avg";
-    EDurationTemplateName["median"] = "median";
-})(exports.EDurationTemplateName || (exports.EDurationTemplateName = {}));
-exports.EEventAppearances = void 0;
-(function (EEventAppearances) {
-    EEventAppearances["FIRST"] = "FIRST";
-    EEventAppearances["LAST"] = "LAST";
-})(exports.EEventAppearances || (exports.EEventAppearances = {}));
-
 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})");
 }
@@ -820,13 +1554,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;
@@ -851,7 +1578,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` */
@@ -1468,30 +2198,6 @@ function getTransitionMeasureFormula(_a, process) {
     return "";
 }
 
-// Типы, используемые в значениях элементов управления.
-exports.EWidgetFilterMode = void 0;
-(function (EWidgetFilterMode) {
-    EWidgetFilterMode["DEFAULT"] = "DEFAULT";
-    EWidgetFilterMode["SINGLE"] = "SINGLE";
-    EWidgetFilterMode["DISABLED"] = "DISABLED";
-})(exports.EWidgetFilterMode || (exports.EWidgetFilterMode = {}));
-exports.EMarkdownDisplayMode = void 0;
-(function (EMarkdownDisplayMode) {
-    EMarkdownDisplayMode["NONE"] = "NONE";
-    EMarkdownDisplayMode["INDICATOR"] = "INDICATOR";
-})(exports.EMarkdownDisplayMode || (exports.EMarkdownDisplayMode = {}));
-exports.EDisplayConditionMode = void 0;
-(function (EDisplayConditionMode) {
-    EDisplayConditionMode["DISABLED"] = "DISABLED";
-    EDisplayConditionMode["FORMULA"] = "FORMULA";
-    EDisplayConditionMode["VARIABLE"] = "VARIABLE";
-})(exports.EDisplayConditionMode || (exports.EDisplayConditionMode = {}));
-exports.EFontWeight = void 0;
-(function (EFontWeight) {
-    EFontWeight["NORMAL"] = "NORMAL";
-    EFontWeight["BOLD"] = "BOLD";
-})(exports.EFontWeight || (exports.EFontWeight = {}));
-
 function checkDisplayCondition(displayCondition, variables) {
     var _a;
     if ((displayCondition === null || displayCondition === void 0 ? void 0 : displayCondition.mode) === exports.EDisplayConditionMode.VARIABLE) {
@@ -1625,7 +2331,7 @@ var getFormulaFilterValues = function (filterValue) {
             if (filteringMethod === formulaFilterMethods.LAST_TIME) {
                 var showTime = format === exports.EFormatTypes.DATETIME;
                 return compact([
-                    convertDateToClickHouse(subtractDurationFromDate(new Date(), lastTimeValue !== null && lastTimeValue !== void 0 ? lastTimeValue : 0, lastTimeUnit), showTime),
+                    convertDateToClickHouse(subtractDurationFromDate(new Date(), Number(lastTimeValue !== null && lastTimeValue !== void 0 ? lastTimeValue : 0), lastTimeUnit), showTime),
                     convertDateToClickHouse(new Date(), showTime),
                 ]);
             }
@@ -1837,8 +2543,8 @@ exports.ESortDirection = void 0;
  * Если к разрезу иерархии применяется INCLUDE-фильтр с одним значением - выбираем следующий за ним разрез
  * Если к разрезу иерархии применяется INCLUDE-фильтр с несколькими значениями - выбираем данный разрез
  */
-function selectDimensionFromHierarchy(_a, filters) {
-    var hierarchyDimensions = _a.hierarchyDimensions;
+function selectDimensionFromHierarchy(hierarchy, filters) {
+    var hierarchyDimensions = hierarchy.hierarchyDimensions; hierarchy.displayCondition;
     var _loop_1 = function (i) {
         var dimension = hierarchyDimensions[i];
         // todo: widgets - возможно, стоит использовать Map фильтров для быстрого поиска
@@ -1851,14 +2557,18 @@ function selectDimensionFromHierarchy(_a, filters) {
             return "continue";
         }
         var selectionIndex = matchedFilter.values.length > 1 ? i : Math.min(i + 1, hierarchyDimensions.length - 1);
-        return { value: hierarchyDimensions[selectionIndex] };
+        var dimensionFromHierarchy_1 = hierarchyDimensions[selectionIndex];
+        return { value: (dimensionFromHierarchy_1 &&
+                inheritDisplayConditionFromHierarchy(dimensionFromHierarchy_1, hierarchy)) };
     };
     for (var i = hierarchyDimensions.length - 1; i >= 0; i--) {
         var state_1 = _loop_1(i);
         if (typeof state_1 === "object")
             return state_1.value;
     }
-    return hierarchyDimensions[0];
+    var dimensionFromHierarchy = hierarchyDimensions[0];
+    return (dimensionFromHierarchy &&
+        inheritDisplayConditionFromHierarchy(dimensionFromHierarchy, hierarchy));
 }
 
 var getDefaultSortOrders = function (_a) {
@@ -1874,7 +2584,8 @@ var getDefaultSortOrders = function (_a) {
     /** Если есть временной разрез, то авто-сортировка по первому такому разрезу (по возрастанию) */
     var timeDimension = dimensions.find(function (dimension) {
         var _a;
-        return ((_a = dimension.format) === null || _a === void 0 ? void 0 : _a.value) &&
+        return ((_a = dimension.format) === null || _a === void 0 ? void 0 : _a.mode) === exports.EFormatOrFormattingMode.BASE &&
+            dimension.format.value !== undefined &&
             [
                 exports.EFormatTypes.DATE,
                 exports.EFormatTypes.MONTH,
@@ -1933,9 +2644,9 @@ function mapSortingToInputs(_a) {
             return;
         }
         if (getIndicatorType(value.group, indicator) === exports.EWidgetIndicatorType.DIMENSION) {
-            var activeDimensions = isDimensionsHierarchy(indicator)
+            var activeDimensions = (isDimensionsHierarchy(indicator)
                 ? selectDimensionFromHierarchy(indicator, filters)
-                : indicator;
+                : indicator);
             var formula = activeDimensions && getDimensionFormula(activeDimensions);
             if (!formula || !checkDisplayCondition(indicator.displayCondition, variables)) {
                 return;
@@ -1949,10 +2660,11 @@ function mapSortingToInputs(_a) {
                     : undefined,
             };
         }
+        var measure = indicator;
         return {
-            formula: getMeasureFormula(indicator),
+            formula: getMeasureFormula(measure),
             direction: direction,
-            dbDataType: indicator.dbDataType,
+            dbDataType: measure.dbDataType,
         };
     });
     return sortOrder;
@@ -1966,8 +2678,7 @@ function prepareSortOrders(_a) {
 var replaceHierarchiesWithDimensions = function (dimensions, filters) {
     return compactMap(dimensions, function (indicator) {
         if (isDimensionsHierarchy(indicator)) {
-            var selectedDimension = selectDimensionFromHierarchy(indicator, filters);
-            return (selectedDimension && replaceDisplayCondition(selectedDimension, indicator.displayCondition));
+            return selectDimensionFromHierarchy(indicator, filters);
         }
         return indicator;
     });
@@ -2038,6 +2749,12 @@ exports.EUnitMode = void 0;
     EUnitMode["PIXEL"] = "PIXEL";
     EUnitMode["PERCENT"] = "PERCENT";
 })(exports.EUnitMode || (exports.EUnitMode = {}));
+var defaultActionsConfig = {
+    OPEN_URL: { availability: true },
+    UPDATE_VARIABLE: { availability: true },
+    EXECUTE_SCRIPT: { availability: true },
+    OPEN_VIEW: { availability: true },
+};
 
 exports.ESelectOptionTypes = void 0;
 (function (ESelectOptionTypes) {
@@ -2226,6 +2943,120 @@ var getColorByIndex = function (index) {
     return color;
 };
 
+var WidgetPresetSettingsSchema = function (z) {
+    return BaseWidgetSettingsSchema(z)
+        .pick({
+        filterMode: true,
+        ignoreFilters: true,
+        stateName: true,
+        titleColor: true,
+        titleSize: true,
+        titleWeight: true,
+        paddings: true,
+    })
+        .extend({
+        textSize: z.number().default(12),
+    });
+};
+
+/**
+ * Привязывает мета-информацию о теме к Zod-схеме
+ *
+ * @template Value - Тип значения схемы
+ * @template Theme - Тип темы (по умолчанию ITheme)
+ *
+ * @param scheme - Zod схема для привязки
+ * @param selectThemeValue - Функция, возвращающая значение из темы
+ *
+ * @returns Zod схему с мета-информацией о теме
+ *
+ * @example
+ * // Базовое использование
+ * textSize: themed(
+ *   z.number().default(12),
+ *   (theme) => theme.textSize
+ * )
+ */
+var themed = function (scheme, selectThemeValue) {
+    var _a;
+    return scheme.meta((_a = {}, _a[exports.ESettingsSchemaMetaKey.themeValue] = selectThemeValue, _a));
+};
+
+var ColorBaseSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.BASE),
+        value: z.string(),
+    });
+};
+var ColorRuleSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.RULE),
+        formula: FormulaSchema(z),
+    });
+};
+var ColorAutoSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.AUTO),
+    });
+};
+var ColorDisabledSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.DISABLED),
+    });
+};
+var ColorGradientSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.GRADIENT),
+        startValue: z.string(),
+        endValue: z.string(),
+        classCount: z.number().min(3).max(10).nullish(),
+    });
+};
+var ColorFormulaSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.FORMULA),
+        formula: FormulaSchema(z),
+    });
+};
+var ColorValuesSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.VALUES),
+        items: z
+            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
+            .default([]),
+    });
+};
+var ColorByDimensionSchema = function (z) {
+    return z.object({
+        mode: z.literal(exports.EColorMode.BY_DIMENSION),
+        /** Имя разреза из области видимости правила отображения */
+        dimensionName: z.string(),
+        items: z
+            .array(z.object({ value: z.string(), color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]) }))
+            .default([]),
+    });
+};
+var ColoredValueSchema = function (z) {
+    return z.object({
+        value: z.string(),
+        color: z.union([ColorBaseSchema(z), ColorRuleSchema(z)]),
+    });
+};
+var ColorSchema = function (z) {
+    return z
+        .discriminatedUnion("mode", [
+        ColorAutoSchema(z),
+        ColorDisabledSchema(z),
+        ColorBaseSchema(z),
+        ColorRuleSchema(z),
+        ColorGradientSchema(z),
+        ColorFormulaSchema(z),
+        ColorValuesSchema(z),
+        ColorByDimensionSchema(z),
+    ])
+        .default({ mode: exports.EColorMode.AUTO });
+};
+
 Object.defineProperty(exports, "ELanguages", {
     enumerable: true,
     get: function () { return localization$1.ELanguages; }
@@ -2234,6 +3065,81 @@ Object.defineProperty(exports, "EFilteringMethodValues", {
     enumerable: true,
     get: function () { return baseFilter.EFilteringMethodValues; }
 });
+exports.ActionButtonSchema = ActionButtonSchema;
+exports.ActionDrillDownSchema = ActionDrillDownSchema;
+exports.ActionGoToURLSchema = ActionGoToURLSchema;
+exports.ActionOnClickParameterSchema = ActionOnClickParameterSchema;
+exports.ActionOpenInSchema = ActionOpenInSchema;
+exports.ActionOpenViewSchema = ActionOpenViewSchema;
+exports.ActionRunScriptSchema = ActionRunScriptSchema;
+exports.ActionSchema = ActionSchema;
+exports.ActionUpdateVariableSchema = ActionUpdateVariableSchema;
+exports.ActionsOnClickSchema = ActionsOnClickSchema;
+exports.AutoIdentifiedArrayItemSchema = AutoIdentifiedArrayItemSchema;
+exports.BaseWidgetSettingsSchema = BaseWidgetSettingsSchema;
+exports.ColorAutoSchema = ColorAutoSchema;
+exports.ColorBaseSchema = ColorBaseSchema;
+exports.ColorByDimensionSchema = ColorByDimensionSchema;
+exports.ColorDisabledSchema = ColorDisabledSchema;
+exports.ColorFormulaSchema = ColorFormulaSchema;
+exports.ColorGradientSchema = ColorGradientSchema;
+exports.ColorRuleSchema = ColorRuleSchema;
+exports.ColorSchema = ColorSchema;
+exports.ColorValuesSchema = ColorValuesSchema;
+exports.ColoredValueSchema = ColoredValueSchema;
+exports.ColumnIndicatorValueSchema = ColumnIndicatorValueSchema;
+exports.DimensionProcessFilterSchema = DimensionProcessFilterSchema;
+exports.DimensionValueSchema = DimensionValueSchema;
+exports.DisplayConditionSchema = DisplayConditionSchema;
+exports.ExtendedFormulaFilterValueSchema = ExtendedFormulaFilterValueSchema;
+exports.FormatSchema = FormatSchema;
+exports.FormattingSchema = FormattingSchema;
+exports.FormulaFilterValueSchema = FormulaFilterValueSchema;
+exports.FormulaNullableSchema = FormulaNullableSchema;
+exports.FormulaSchema = FormulaSchema;
+exports.KeyNullableSchema = KeyNullableSchema;
+exports.MarkdownMeasureSchema = MarkdownMeasureSchema;
+exports.MeasureValueSchema = MeasureValueSchema;
+exports.NameNullableSchema = NameNullableSchema;
+exports.ParameterFromAggregationSchema = ParameterFromAggregationSchema;
+exports.ParameterFromColumnSchema = ParameterFromColumnSchema;
+exports.ParameterFromDataModelSchema = ParameterFromDataModelSchema;
+exports.ParameterFromDynamicListSchema = ParameterFromDynamicListSchema;
+exports.ParameterFromEndEventSchema = ParameterFromEndEventSchema;
+exports.ParameterFromEventSchema = ParameterFromEventSchema;
+exports.ParameterFromFormulaSchema = ParameterFromFormulaSchema;
+exports.ParameterFromManualInputSchema = ParameterFromManualInputSchema;
+exports.ParameterFromStartEventSchema = ParameterFromStartEventSchema;
+exports.ParameterFromStaticListSchema = ParameterFromStaticListSchema;
+exports.ParameterFromVariableSchema = ParameterFromVariableSchema;
+exports.ProcessIndicatorSchema = ProcessIndicatorSchema;
+exports.ProcessIndicatorValueSchema = ProcessIndicatorValueSchema;
+exports.RangeSchema = RangeSchema;
+exports.SettingsFilterSchema = SettingsFilterSchema;
+exports.SortDirectionSchema = SortDirectionSchema;
+exports.SortOrderSchema = SortOrderSchema;
+exports.ViewActionParameterSchema = ViewActionParameterSchema;
+exports.ViewActionSchema = ViewActionSchema;
+exports.WidgetActionParameterSchema = WidgetActionParameterSchema;
+exports.WidgetActionSchema = WidgetActionSchema;
+exports.WidgetColumnIndicatorSchema = WidgetColumnIndicatorSchema;
+exports.WidgetDimensionHierarchySchema = WidgetDimensionHierarchySchema;
+exports.WidgetDimensionInHierarchySchema = WidgetDimensionInHierarchySchema;
+exports.WidgetDimensionSchema = WidgetDimensionSchema;
+exports.WidgetIndicatorAggregationValueSchema = WidgetIndicatorAggregationValueSchema;
+exports.WidgetIndicatorConversionValueSchema = WidgetIndicatorConversionValueSchema;
+exports.WidgetIndicatorDurationValueSchema = WidgetIndicatorDurationValueSchema;
+exports.WidgetIndicatorFormulaValueSchema = WidgetIndicatorFormulaValueSchema;
+exports.WidgetIndicatorSchema = WidgetIndicatorSchema;
+exports.WidgetIndicatorTemplateValueSchema = WidgetIndicatorTemplateValueSchema;
+exports.WidgetIndicatorTimeValueSchema = WidgetIndicatorTimeValueSchema;
+exports.WidgetMeasureAggregationValueSchema = WidgetMeasureAggregationValueSchema;
+exports.WidgetMeasureSchema = WidgetMeasureSchema;
+exports.WidgetPresetSettingsSchema = WidgetPresetSettingsSchema;
+exports.WidgetSortingIndicatorSchema = WidgetSortingIndicatorSchema;
+exports.WidgetSortingValueSchema = WidgetSortingValueSchema;
+exports.apiVersion = apiVersion;
+exports.apiVersions = apiVersions;
 exports.applyIndexToArrayFormula = applyIndexToArrayFormula;
 exports.bindContentWithIndicator = bindContentWithIndicator;
 exports.bindContentsWithIndicators = bindContentsWithIndicators;
@@ -2249,6 +3155,7 @@ exports.createEscaper = createEscaper;
 exports.createMeasureAggregationTemplate = createAggregationTemplate;
 exports.curlyBracketsContentPattern = curlyBracketsContentPattern;
 exports.dashboardLinkRegExp = dashboardLinkRegExp;
+exports.defaultActionsConfig = defaultActionsConfig;
 exports.dimensionAggregationTemplates = dimensionAggregationTemplates;
 exports.dimensionTemplateFormulas = dimensionTemplateFormulas;
 exports.displayConditionTemplate = displayConditionTemplate;
@@ -2258,7 +3165,6 @@ exports.escapeCurlyBracketLinkName = escapeCurlyBracketLinkName;
 exports.escapeDoubleQuoteLinkName = escapeDoubleQuoteLinkName;
 exports.eventMeasureTemplateFormulas = eventMeasureTemplateFormulas;
 exports.fillTemplateSql = fillTemplateSql;
-exports.fillTemplateString = fillTemplateString;
 exports.formattingConfig = formattingConfig;
 exports.formulaFilterMethods = formulaFilterMethods;
 exports.generateColumnFormula = generateColumnFormula;
@@ -2272,6 +3178,7 @@ exports.getMeasureFormula = getMeasureFormula;
 exports.getProcessDimensionValueFormula = getProcessDimensionValueFormula;
 exports.getRuleColor = getRuleColor;
 exports.getTransitionMeasureFormula = getTransitionMeasureFormula;
+exports.inheritDisplayConditionFromHierarchy = inheritDisplayConditionFromHierarchy;
 exports.isDimensionProcessFilter = isDimensionProcessFilter;
 exports.isDimensionsHierarchy = isDimensionsHierarchy;
 exports.isFormulaFilterValue = isFormulaFilterValue;
@@ -2300,6 +3207,7 @@ exports.replaceDisplayCondition = replaceDisplayCondition;
 exports.replaceFiltersBySelection = replaceFiltersBySelection;
 exports.replaceHierarchiesWithDimensions = replaceHierarchiesWithDimensions;
 exports.selectDimensionFromHierarchy = selectDimensionFromHierarchy;
+exports.themed = themed;
 exports.timeTemplates = timeTemplates;
 exports.transitionMeasureTemplateFormulas = transitionMeasureTemplateFormulas;
 exports.unescapeSpecialCharacters = unescapeSpecialCharacters;