@infomaximum/widget-sdk 7.0.0-3 → 7.0.0-31

package/dist/index.esm.js

@@ -1,6 +1,7 @@
-import { Localization } from '@infomaximum/localization';
 export { ELanguages } from '@infomaximum/localization';
 export { EFilteringMethodValues } from '@infomaximum/base-filter';
+import { EFormatTypes, EFormattingPresets } from '@infomaximum/bi-formatting';
+export { EFormatTypes, EFormattingPresets, availableFormattingByFormat } from '@infomaximum/bi-formatting';
 
 /** Массив версий в строгом порядке, по которому последовательно выполняется миграция */
 var apiVersions = [
@@ -29,6 +30,8 @@ var apiVersions = [
     "16.1", // Для версии системы 250703
     "16.2", // Для версии системы 250709
     "17", // 2508
+    "18", // 2601
+    "19", // 2602
 ];
 /**
  * Актуальная версия settings, с которой работает система.
@@ -36,414 +39,6 @@ var apiVersions = [
  */
 var apiVersion = apiVersions.at(-1);
 
-var EWidgetActionInputMethod;
-(function (EWidgetActionInputMethod) {
-    EWidgetActionInputMethod["COLUMN"] = "COLUMN";
-    EWidgetActionInputMethod["VARIABLE"] = "VARIABLE";
-    EWidgetActionInputMethod["STATIC_LIST"] = "STATIC_LIST";
-    EWidgetActionInputMethod["DYNAMIC_LIST"] = "DYNAMIC_LIST";
-    EWidgetActionInputMethod["FORMULA"] = "FORMULA";
-    EWidgetActionInputMethod["MANUALLY"] = "MANUALLY";
-    EWidgetActionInputMethod["EVENT"] = "EVENT";
-    EWidgetActionInputMethod["START_EVENT"] = "START_EVENT";
-    EWidgetActionInputMethod["FINISH_EVENT"] = "FINISH_EVENT";
-    EWidgetActionInputMethod["AGGREGATION"] = "AGGREGATION";
-    EWidgetActionInputMethod["DATA_MODEL"] = "DATA_MODEL";
-})(EWidgetActionInputMethod || (EWidgetActionInputMethod = {}));
-var EActionTypes;
-(function (EActionTypes) {
-    EActionTypes["OPEN_URL"] = "OPEN_URL";
-    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) {
-    EViewMode["EXISTED_VIEW"] = "EXISTED_VIEW";
-    EViewMode["GENERATED_BY_SCRIPT"] = "GENERATED_BY_SCRIPT";
-    EViewMode["EMPTY"] = "EMPTY";
-})(EViewMode || (EViewMode = {}));
-var EViewOpenIn;
-(function (EViewOpenIn) {
-    EViewOpenIn["WINDOW"] = "WINDOW";
-    EViewOpenIn["PLACEHOLDER"] = "PLACEHOLDER";
-    EViewOpenIn["MODAL_WINDOW"] = "MODAL_WINDOW";
-    EViewOpenIn["DRAWER_WINDOW"] = "DRAWER_WINDOW";
-})(EViewOpenIn || (EViewOpenIn = {}));
-var EDrawerPlacement;
-(function (EDrawerPlacement) {
-    EDrawerPlacement["LEFT"] = "LEFT";
-    EDrawerPlacement["RIGHT"] = "RIGHT";
-})(EDrawerPlacement || (EDrawerPlacement = {}));
-var EAutoUpdateMode;
-(function (EAutoUpdateMode) {
-    EAutoUpdateMode["NONE"] = "NONE";
-    EAutoUpdateMode["THIS_WIDGET"] = "THIS_WIDGET";
-    EAutoUpdateMode["ALL_VIEWS"] = "ALL_VIEWS";
-})(EAutoUpdateMode || (EAutoUpdateMode = {}));
-var EDataModelOption;
-(function (EDataModelOption) {
-    EDataModelOption["TABLE_LIST"] = "TABLE_LIST";
-    EDataModelOption["COLUMN_LIST"] = "COLUMN_LIST";
-})(EDataModelOption || (EDataModelOption = {}));
-var EActivateConditionMode;
-(function (EActivateConditionMode) {
-    EActivateConditionMode["FORMULA"] = "FORMULA";
-    EActivateConditionMode["VARIABLE"] = "VARIABLE";
-})(EActivateConditionMode || (EActivateConditionMode = {}));
-var EActionButtonsTypes;
-(function (EActionButtonsTypes) {
-    EActionButtonsTypes["LINK"] = "link";
-    EActionButtonsTypes["BASE"] = "primary";
-    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";
-    ESimpleDataType["DATE"] = "DATE";
-    ESimpleDataType["FLOAT"] = "FLOAT";
-    ESimpleDataType["DATETIME"] = "DATETIME";
-    ESimpleDataType["STRING"] = "STRING";
-    ESimpleDataType["INTEGER"] = "INTEGER";
-    ESimpleDataType["DATETIME64"] = "DATETIME64";
-    ESimpleDataType["BOOLEAN"] = "BOOLEAN";
-})(ESimpleDataType || (ESimpleDataType = {}));
-
-var EFormatTypes;
-(function (EFormatTypes) {
-    /** Дата */
-    EFormatTypes["DATE"] = "DATE";
-    /** Число */
-    EFormatTypes["NUMBER"] = "NUMBER";
-    /** Месяц */
-    EFormatTypes["MONTH"] = "MONTH";
-    /** Дата и время */
-    EFormatTypes["DATETIME"] = "DATETIME";
-    /** Строка */
-    EFormatTypes["STRING"] = "STRING";
-    /** День недели */
-    EFormatTypes["DAY_OF_WEEK"] = "DAY_OF_WEEK";
-    /** Длительность */
-    EFormatTypes["DURATION"] = "DURATION";
-    /** Час */
-    EFormatTypes["HOUR"] = "HOUR";
-    /** Месяц и год */
-    EFormatTypes["MONTH_YEAR"] = "MONTH_YEAR";
-    /** Год */
-    EFormatTypes["YEAR"] = "YEAR";
-    /** Квартал */
-    EFormatTypes["QUARTER"] = "QUARTER";
-    /** Квартал и год */
-    EFormatTypes["QUARTER_YEAR"] = "QUARTER_YEAR";
-    /** День месяца */
-    EFormatTypes["DAY_OF_MONTH"] = "DAY_OF_MONTH";
-    /** Неделя */
-    EFormatTypes["WEEK"] = "WEEK";
-    /** Логический */
-    EFormatTypes["BOOLEAN"] = "BOOLEAN";
-    EFormatTypes["PERCENT"] = "PERCENT";
-})(EFormatTypes || (EFormatTypes = {}));
-var EFormattingPresets;
-(function (EFormattingPresets) {
-    //Общая группа шаблонов
-    EFormattingPresets["AUTO"] = "AUTO";
-    EFormattingPresets["CUSTOM"] = "CUSTOM";
-    //Группа шаблонов для формата DATE
-    EFormattingPresets["DD/M/YYYY"] = "DD/M/YYYY";
-    EFormattingPresets["DD-MM-YYYY"] = "DD-MM-YYYY";
-    EFormattingPresets["DD-MM-YY"] = "DD-MM-YY";
-    EFormattingPresets["YYYY-MM-DD"] = "YYYY-MM-DD";
-    EFormattingPresets["YY-MM-DD"] = "YY-MM-DD";
-    EFormattingPresets["DD MM YYYY"] = "DD MM YYYY";
-    EFormattingPresets["DD MMM YYYY"] = "DD MMM YYYY";
-    EFormattingPresets["DD MMM YY"] = "DD MMM YY";
-    EFormattingPresets["MM.DD.YYYY"] = "MM.DD.YYYY";
-    EFormattingPresets["MM.DD.YY"] = "MM.DD.YY";
-    EFormattingPresets["DD MMMM YYYY"] = "DD MMMM YYYY";
-    EFormattingPresets["DD MMMM YY"] = "DD MMMM YY";
-    EFormattingPresets["DD/MM/YYYY"] = "DD/MM/YYYY";
-    EFormattingPresets["DD/MM/YY"] = "DD/MM/YY";
-    EFormattingPresets["MM/DD/YYYY"] = "MM/DD/YYYY";
-    EFormattingPresets["MM/DD/YY"] = "MM/DD/YY";
-    EFormattingPresets["MMMM DD, YYYY"] = "MMMM DD, YYYY";
-    EFormattingPresets["MMMM DD, YY"] = "MMMM DD, YY";
-    EFormattingPresets["DD.MM.YYYY"] = "DD.MM.YYYY";
-    EFormattingPresets["DD.MM.YY"] = "DD.MM.YY";
-    EFormattingPresets["MM-DD-YY"] = "MM-DD-YY";
-    EFormattingPresets["MM-DD-YYYY"] = "MM-DD-YYYY";
-    //Группа шаблонов для формата DATETIME
-    EFormattingPresets["DD/M/YYYY HH:mm"] = "DD/M/YYYY HH:mm";
-    EFormattingPresets["DD/MM/YYYY, HH:mm"] = "DD/MM/YYYY, HH:mm";
-    EFormattingPresets["DD/MM/YY, HH:mm"] = "DD/MM/YY, HH:mm";
-    EFormattingPresets["MM/DD/YY, hh:mm a"] = "MM/DD/YY, hh:mm a";
-    EFormattingPresets["MM/DD/YYYY, hh:mm a"] = "MM/DD/YYYY, hh:mm a";
-    EFormattingPresets["YYYY-MM-DD HH:mm"] = "YYYY-MM-DD HH:mm";
-    EFormattingPresets["YY-MM-DD, HH:mm"] = "YY-MM-DD, HH:mm";
-    EFormattingPresets["YYYY-MM-DD, HH:mm"] = "YYYY-MM-DD, HH:mm";
-    EFormattingPresets["YYYY-MM-DD HH:mm:ss"] = "YYYY-MM-DD HH:mm:ss";
-    EFormattingPresets["DD MM YYYY HH:mm"] = "DD MM YYYY HH:mm";
-    EFormattingPresets["DD MMMM YYYY, HH:mm"] = "DD MMMM YYYY, HH:mm";
-    EFormattingPresets["DD.MM.YY, HH:mm"] = "DD.MM.YY, HH:mm";
-    EFormattingPresets["DD.MM.YYYY, HH:mm"] = "DD.MM.YYYY, HH:mm";
-    EFormattingPresets["MM-DD-YY, hh:mm a"] = "MM-DD-YY, hh:mm a";
-    EFormattingPresets["MM-DD-YYYY, hh:mm a"] = "MM-DD-YYYY, hh:mm a";
-    EFormattingPresets["MM.DD.YY, hh:mm a"] = "MM.DD.YY, hh:mm a";
-    EFormattingPresets["MM.DD.YYYY, hh:mm a"] = "MM.DD.YYYY, hh:mm a";
-    EFormattingPresets["MM.DD.YYYY hh:mm a"] = "MM.DD.YYYY hh:mm a";
-    EFormattingPresets["DD MMM YY, HH:mm"] = "DD MMM YY, HH:mm";
-    EFormattingPresets["DD MMM YYYY, HH:mm"] = "DD MMM YYYY, HH:mm";
-    EFormattingPresets["MMMM DD, YY, HH:mm"] = "MMMM DD, YY, HH:mm";
-    EFormattingPresets["MMMM DD, YYYY, HH:mm"] = "MMMM DD, YYYY, HH:mm";
-    EFormattingPresets["DD MMMM YY, HH:mm"] = "DD MMMM YY, HH:mm";
-    EFormattingPresets["DD.MM.YYYY, HH:mm:ss"] = "DD.MM.YYYY, HH:mm:ss";
-    EFormattingPresets["DD.MM.YYYY HH:mm:ss"] = "DD.MM.YYYY HH:mm:ss";
-    EFormattingPresets["DD/MM/YYYY HH:mm:ss"] = "DD/MM/YYYY HH:mm:ss";
-    //Группа шаблонов для формата DAY_OF_WEEK
-    EFormattingPresets["DD"] = "DD";
-    EFormattingPresets["D"] = "D";
-    EFormattingPresets["DDDD"] = "DDDD";
-    //Группа шаблонов для формата MONTH
-    EFormattingPresets["MMM"] = "MMM";
-    EFormattingPresets["MM"] = "MM";
-    EFormattingPresets["MMMM"] = "MMMM";
-    //Группа шаблонов для формата NUMBER
-    EFormattingPresets["k"] = "k";
-    EFormattingPresets["x"] = "x";
-    EFormattingPresets["#,##x"] = "#,##x";
-    EFormattingPresets["#,##x.x"] = "#,##x.x";
-    EFormattingPresets["#,##x.xx"] = "#,##x.xx";
-    EFormattingPresets["x[%]"] = "x[%]";
-    EFormattingPresets["x.x[%]"] = "x.x[%]";
-    EFormattingPresets["[$]x"] = "[$]x";
-    EFormattingPresets["zx.xx[%]"] = "zx.xx[%]";
-    //Группа шаблонов для преобразования DURATION
-    EFormattingPresets["hh:mm:ss"] = "hh:mm:ss";
-    EFormattingPresets["dd:hh:mm:ss"] = "dd:hh:mm:ss";
-    EFormattingPresets["d"] = "d";
-    EFormattingPresets["h"] = "h";
-    EFormattingPresets["dk"] = "dk";
-    EFormattingPresets["hk"] = "hk";
-    EFormattingPresets["dd"] = "dd";
-    //Группа шаблонов для преобразования Час
-    EFormattingPresets["HH"] = "HH";
-    EFormattingPresets["hh a"] = "hh a";
-    //Группа шаблонов для преобразования Month_Year
-    EFormattingPresets["MMM, YYYY"] = "MMM, YYYY";
-    EFormattingPresets["MMM, YY"] = "MMM, YY";
-    EFormattingPresets["MM.YYYY"] = "MM.YYYY";
-    EFormattingPresets["MM.YY"] = "MM.YY";
-    EFormattingPresets["MMMM YYYY"] = "MMMM YYYY";
-    EFormattingPresets["MMMM YY"] = "MMMM YY";
-    //Группа шаблонов для преобразования Quarter
-    EFormattingPresets["[Q]q"] = "[Q]q";
-    EFormattingPresets["R"] = "R";
-    //Группа шаблонов для преобразования Quarter_Year
-    EFormattingPresets["[Q]q[-]YYYY"] = "[Q]q[-]YYYY";
-    EFormattingPresets["[Q]q[-]YY"] = "[Q]q[-]YY";
-    EFormattingPresets["R[-]YYYY"] = "R[-]YYYY";
-    EFormattingPresets["R[-]YY"] = "R[-]YY";
-})(EFormattingPresets || (EFormattingPresets = {}));
-var formattingConfig = {
-    get availableFormatsBySimpleType() {
-        var _a;
-        return _a = {},
-            _a[ESimpleDataType.OTHER] = [EFormatTypes.STRING],
-            _a[ESimpleDataType.STRING] = [EFormatTypes.STRING],
-            _a[ESimpleDataType.FLOAT] = [EFormatTypes.NUMBER, EFormatTypes.DURATION, EFormatTypes.PERCENT],
-            _a[ESimpleDataType.INTEGER] = [
-                EFormatTypes.NUMBER,
-                EFormatTypes.DURATION,
-                EFormatTypes.QUARTER_YEAR,
-                EFormatTypes.MONTH_YEAR,
-                EFormatTypes.MONTH,
-                EFormatTypes.DAY_OF_WEEK,
-                EFormatTypes.PERCENT,
-            ],
-            _a[ESimpleDataType.DATE] = [EFormatTypes.DATE],
-            _a[ESimpleDataType.DATETIME] = [EFormatTypes.DATETIME],
-            _a[ESimpleDataType.DATETIME64] = [EFormatTypes.DATETIME],
-            _a[ESimpleDataType.BOOLEAN] = [EFormatTypes.BOOLEAN],
-            _a;
-    },
-    get availableFormattingByFormat() {
-        var _a;
-        return _a = {},
-            _a[EFormatTypes.DATE] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets["DD.MM.YY"],
-                EFormattingPresets["DD.MM.YYYY"],
-                EFormattingPresets["YY-MM-DD"],
-                EFormattingPresets["YYYY-MM-DD"],
-                EFormattingPresets["MM-DD-YY"],
-                EFormattingPresets["MM-DD-YYYY"],
-                EFormattingPresets["MM.DD.YY"],
-                EFormattingPresets["MM.DD.YYYY"],
-                EFormattingPresets["DD MMM YY"],
-                EFormattingPresets["DD MMM YYYY"],
-                EFormattingPresets["DD MMMM YY"],
-                EFormattingPresets["DD MMMM YYYY"],
-                EFormattingPresets["DD/MM/YY"],
-                EFormattingPresets["DD/MM/YYYY"],
-                EFormattingPresets["MM/DD/YY"],
-                EFormattingPresets["MM/DD/YYYY"],
-                EFormattingPresets["MMMM DD, YY"],
-                EFormattingPresets["MMMM DD, YYYY"],
-                EFormattingPresets.CUSTOM,
-            ],
-            _a[EFormatTypes.DATETIME] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets["DD.MM.YY"],
-                EFormattingPresets["DD.MM.YY, HH:mm"],
-                EFormattingPresets["DD.MM.YYYY"],
-                EFormattingPresets["DD.MM.YYYY, HH:mm"],
-                EFormattingPresets["YY-MM-DD"],
-                EFormattingPresets["YYYY-MM-DD, HH:mm"],
-                EFormattingPresets["YYYY-MM-DD"],
-                EFormattingPresets["YYYY-MM-DD HH:mm"],
-                EFormattingPresets["MM-DD-YY"],
-                EFormattingPresets["MM-DD-YY, hh:mm a"],
-                EFormattingPresets["MM-DD-YYYY"],
-                EFormattingPresets["MM-DD-YYYY, hh:mm a"],
-                EFormattingPresets["MM.DD.YY"],
-                EFormattingPresets["MM.DD.YY, hh:mm a"],
-                EFormattingPresets["MM.DD.YYYY"],
-                EFormattingPresets["MM.DD.YYYY, hh:mm a"],
-                EFormattingPresets["DD MMM YY"],
-                EFormattingPresets["DD MMM YY, HH:mm"],
-                EFormattingPresets["DD MMM YYYY"],
-                EFormattingPresets["DD MMM YYYY, HH:mm"],
-                EFormattingPresets["DD MMMM YY"],
-                EFormattingPresets["DD MMMM YY, HH:mm"],
-                EFormattingPresets["DD MMMM YYYY"],
-                EFormattingPresets["DD MMMM YYYY, HH:mm"],
-                EFormattingPresets["DD/MM/YY"],
-                EFormattingPresets["DD/MM/YY, HH:mm"],
-                EFormattingPresets["DD/MM/YYYY"],
-                EFormattingPresets["DD/MM/YYYY, HH:mm"],
-                EFormattingPresets["MM/DD/YY"],
-                EFormattingPresets["MM/DD/YY, hh:mm a"],
-                EFormattingPresets["MM/DD/YYYY"],
-                EFormattingPresets["MM/DD/YYYY, hh:mm a"],
-                EFormattingPresets["MMMM DD, YY"],
-                EFormattingPresets["MMMM DD, YY, HH:mm"],
-                EFormattingPresets["MMMM DD, YYYY"],
-                EFormattingPresets["MMMM DD, YYYY, HH:mm"],
-                EFormattingPresets.CUSTOM,
-            ],
-            _a[EFormatTypes.DAY_OF_WEEK] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets.DD,
-                EFormattingPresets.D,
-                EFormattingPresets.DDDD,
-            ],
-            _a[EFormatTypes.MONTH] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets.MMM,
-                EFormattingPresets.MM,
-                EFormattingPresets.MMMM,
-            ],
-            _a[EFormatTypes.NUMBER] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets["x"],
-                EFormattingPresets["#,##x"],
-                EFormattingPresets["#,##x.x"],
-                EFormattingPresets["#,##x.xx"],
-                EFormattingPresets["x[%]"],
-                EFormattingPresets["x.x[%]"],
-                EFormattingPresets["zx.xx[%]"],
-                EFormattingPresets["[$]x"],
-                EFormattingPresets.CUSTOM,
-            ],
-            _a[EFormatTypes.DURATION] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets.d,
-                EFormattingPresets.h,
-                EFormattingPresets.CUSTOM,
-            ],
-            _a[EFormatTypes.HOUR] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets.HH,
-                EFormattingPresets["hh a"],
-            ],
-            _a[EFormatTypes.MONTH_YEAR] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets["MMM, YYYY"],
-                EFormattingPresets["MMM, YY"],
-                EFormattingPresets["MM.YYYY"],
-                EFormattingPresets["MM.YY"],
-                EFormattingPresets["MMMM YYYY"],
-                EFormattingPresets["MMMM YY"],
-                EFormattingPresets.CUSTOM,
-            ],
-            _a[EFormatTypes.QUARTER] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets["[Q]q"],
-                EFormattingPresets.R,
-            ],
-            _a[EFormatTypes.QUARTER_YEAR] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets["[Q]q[-]YYYY"],
-                EFormattingPresets["[Q]q[-]YY"],
-                EFormattingPresets["R[-]YYYY"],
-                EFormattingPresets["R[-]YY"],
-                EFormattingPresets.CUSTOM,
-            ],
-            _a[EFormatTypes.STRING] = [],
-            _a[EFormatTypes.DAY_OF_MONTH] = [],
-            _a[EFormatTypes.WEEK] = [],
-            _a[EFormatTypes.YEAR] = [],
-            _a[EFormatTypes.BOOLEAN] = [],
-            _a[EFormatTypes.PERCENT] = [
-                EFormattingPresets.AUTO,
-                EFormattingPresets["x.x[%]"],
-                EFormattingPresets["zx.xx[%]"],
-            ],
-            _a;
-    },
-};
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -460,6 +55,20 @@ PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 /* global Reflect, Promise, SuppressedError, Symbol */
 
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
 
 var __assign = function() {
     __assign = Object.assign || function __assign(t) {
@@ -513,6 +122,16 @@ function __read(o, n) {
     return ar;
 }
 
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
 function __makeTemplateObject(cooked, raw) {
     if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
     return cooked;
@@ -522,842 +141,265 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     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 });
+function compareVersions(a, b) {
+    var _a, _b;
+    var partsA = a.split(".").map(Number);
+    var partsB = b.split(".").map(Number);
+    var length = Math.max(partsA.length, partsB.length);
+    for (var i = 0; i < length; i++) {
+        var pa = (_a = partsA[i]) !== null && _a !== void 0 ? _a : 0;
+        var pb = (_b = partsB[i]) !== null && _b !== void 0 ? _b : 0;
+        var diff = Math.sign(pa - pb);
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
 }
-/** Тип показателя */
-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;
+function findClosestVersion(target, versions) {
+    return versions
+        .toSorted(function (a, b) { return compareVersions(b, a); })
+        .find(function (version) { return compareVersions(version, target) <= 0; });
 }
-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 при расширении лучше положить на более общий уровень.
+ * Версионированный enum.
+ *
+ * Единственный санкционированный способ доступа к историческим срезам — через
+ * `Symbol.for("@infomaximum/widget-sdk:VersionedEnum.forVersion")`.
+ * Никаких других `VersionedEnum`-классов в проекте с тем же ключом.
+ *
+ * @example
+ * ```ts
+ * export const EWidgetFilterMode = VersionedEnum.build({
+ *   latestVersion: "19",
+ *   history: {
+ *     "17": { DEFAULT: "DEFAULT", SINGLE: "SINGLE", MULTI: "MULTI", DISABLED: "DISABLED" } as const,
+ *     "19": { DEFAULT: "DEFAULT", SINGLE: "SINGLE", DISABLED: "DISABLED" } as const,
+ *   },
+ * });
+ *
+ * // Использование latest-среза как обычного объекта:
+ * EWidgetFilterMode.DEFAULT // "DEFAULT"
+ * z.enum(EWidgetFilterMode)  // схема на latest-ключах
+ *
+ * // Получение исторического среза:
+ * const v17 = EWidgetFilterMode[VersionedEnum.forVersion]("17");
+ * v17.MULTI // "MULTI"
+ * z.enum(v17) // схема на v17-ключах
+ * ```
  */
-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); };
+var VersionedEnum = /** @class */ (function () {
+    function VersionedEnum() {
+    }
+    /**
+     * Построить версионированный enum.
+     *
+     * Поведение `[VersionedEnum.forVersion](target)`:
+     * - `target == null` → возвращает latest-срез.
+     * - `target` совпадает с ключом в `history` → точный срез.
+     * - Иначе → `findClosestVersion` (ближайшая версия ≤ target).
+     * - Если подходящей нет → `throw`.
+     */
+    VersionedEnum.build = function (params) {
+        var e_1, _a;
+        var history = params.history;
+        var latestVersion = params.latestVersion;
+        var preparedMap = new Map();
+        try {
+            for (var _b = __values(Object.keys(history)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var version = _c.value;
+                var slice = history[version];
+                if (slice !== undefined) {
+                    preparedMap.set(version, Object.freeze(__assign({}, slice)));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var latestSlice = preparedMap.get(latestVersion);
+        if (latestSlice === undefined) {
+            throw new Error("VersionedEnum: latestVersion=\"".concat(latestVersion, "\" \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u0432 history"));
+        }
+        var availableVersions = Array.from(preparedMap.keys());
+        var forVersionFn = function (target) {
+            if (target == null) {
+                return latestSlice;
+            }
+            var exact = preparedMap.get(target);
+            if (exact !== undefined) {
+                return exact;
+            }
+            var closest = findClosestVersion(target, availableVersions);
+            if (closest === undefined) {
+                throw new Error("VersionedEnum: no slice for version=".concat(target, ", available: ").concat(availableVersions.join(", "), ", and no earlier version available"));
+            }
+            return preparedMap.get(closest);
+        };
+        var result = Object.defineProperty(__assign({}, latestSlice), VersionedEnum.forVersion, {
+            value: forVersionFn,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+        return Object.freeze(result);
+    };
+    /**
+     * Symbol-ключ для доступа к историческим срезам.
+     *
+     * Зафиксирован как `Symbol.for("@infomaximum/widget-sdk:VersionedEnum.forVersion")` —
+     * глобальный реестр гарантирует стабильность при дублировании пакета.
+     * Никаких других `VersionedEnum`-классов в проекте с тем же ключом — запрет в ADR-0001.
+     */
+    VersionedEnum.forVersion = Symbol.for("@infomaximum/widget-sdk:VersionedEnum.forVersion");
+    return VersionedEnum;
+}());
 /**
- * Схема формулы, которая не может быть пустой строкой, но может быть в
- * неинициализированном состоянии null (вместо пустой строки)
+ * Готовит аргумент для `z.enum(...)` из `VersionedEnum`, его исторического среза
+ * или плоского `Record<string, string>`.
  *
- * @note для обратной совместимости без необходимости писать миграции
+ * Решает структурную несовместимость `TVersionedEnum` (имеет non-enumerable
+ * Symbol-ключ `forVersion`) с `EnumLike`-типом zod: на уровне типов отбрасывает
+ * не-строковые ключи, на уровне runtime спред также не копирует non-enumerable
+ * Symbol. Литералы значений сохраняются.
+ *
+ * @example
+ * z.enum(zodEnumLike(EFontWeight))
+ * z.enum(zodEnumLike(EFilterMode[VersionedEnum.forVersion]("17")))
  */
-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("'", "\\'");
-};
+function zodEnumLike(source) {
+    return __assign({}, source);
+}
+/**
+ * Возвращает массив значений `VersionedEnum` или его исторического среза,
+ * сохраняя literal union как тип элемента. Безопаснее, чем
+ * `Object.values(E) as TValue[]` — спред отсекает Symbol-ключ `forVersion`
+ * на runtime, а тип возвращает union литералов вместо `string`.
+ *
+ * @example
+ * const modes = versionedEnumValues(EFontWeight); // TFontWeight[]
+ * for (const mode of versionedEnumValues(EDataModelOption)) { ... }
+ */
+function versionedEnumValues(source) {
+    return Object.values(__assign({}, source));
+}
 
-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 EWidgetActionInputMethod = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            COLUMN: "COLUMN",
+            VARIABLE: "VARIABLE",
+            STATIC_LIST: "STATIC_LIST",
+            DYNAMIC_LIST: "DYNAMIC_LIST",
+            FORMULA: "FORMULA",
+            MANUALLY: "MANUALLY",
+            EVENT: "EVENT",
+            START_EVENT: "START_EVENT",
+            FINISH_EVENT: "FINISH_EVENT",
+            AGGREGATION: "AGGREGATION",
+            DATA_MODEL: "DATA_MODEL",
+            /** Значение берётся из редактируемого текста виджета в момент сохранения */
+            EDITABLE_TEXT_VALUE: "EDITABLE_TEXT_VALUE",
+        },
+    },
+});
+var EActionTypes = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            OPEN_URL: "OPEN_URL",
+            UPDATE_VARIABLE: "UPDATE_VARIABLE",
+            EXECUTE_SCRIPT: "EXECUTE_SCRIPT",
+            OPEN_VIEW: "OPEN_VIEW",
+            DRILL_DOWN: "DRILL_DOWN",
+        },
+    },
+});
+var EViewMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            EXISTED_VIEW: "EXISTED_VIEW",
+            GENERATED_BY_SCRIPT: "GENERATED_BY_SCRIPT",
+            EMPTY: "EMPTY",
+        },
+    },
+});
+var EViewOpenIn = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            WINDOW: "WINDOW",
+            PLACEHOLDER: "PLACEHOLDER",
+            MODAL_WINDOW: "MODAL_WINDOW",
+            DRAWER_WINDOW: "DRAWER_WINDOW",
+        },
+    },
+});
+var EDrawerPlacement = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            LEFT: "LEFT",
+            RIGHT: "RIGHT",
+        },
+    },
+});
+var EAutoUpdateMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            NONE: "NONE",
+            THIS_WIDGET: "THIS_WIDGET",
+            ALL_VIEWS: "ALL_VIEWS",
+        },
+    },
+});
+var EDataModelOption = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            TABLE_LIST: "TABLE_LIST",
+            COLUMN_LIST: "COLUMN_LIST",
+        },
+    },
+});
+var EActivateConditionMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            FORMULA: "FORMULA",
+            VARIABLE: "VARIABLE",
+        },
+    },
+});
+var EActionButtonsTypes = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            LINK: "link",
+            BASE: "primary",
+            SECONDARY: "primary-outlined",
+        },
+    },
+});
+var EExpectedFieldTypes;
+(function (EExpectedFieldTypes) {
+    EExpectedFieldTypes["TEXT"] = "text";
+    EExpectedFieldTypes["DOUBLE"] = "number";
+    EExpectedFieldTypes["BOOLEAN"] = "boolean";
+    EExpectedFieldTypes["INTEGER"] = "integer";
+    EExpectedFieldTypes["DATE"] = "date";
+    EExpectedFieldTypes["DATE_TIME"] = "date_time";
+    EExpectedFieldTypes["BIGINTEGER"] = "big_integer";
+    EExpectedFieldTypes["BIGDECIMAL"] = "big_decimal";
+    EExpectedFieldTypes["FILE"] = "file";
+})(EExpectedFieldTypes || (EExpectedFieldTypes = {}));
 
 var compact = function (items) { return ((items === null || items === void 0 ? void 0 : items.filter(Boolean)) || []); };
 var compactMap = function (items, f) {
@@ -1366,6 +408,24 @@ var compactMap = function (items, f) {
 var isNil = function (value) {
     return value === null || value === undefined;
 };
+function omit(obj, keys) {
+    var e_1, _a;
+    var newObj = __assign({}, obj);
+    try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            delete newObj[key];
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return newObj;
+}
 function memoize(fn) {
     var cache = new Map();
     return function (arg) {
@@ -1377,48 +437,1827 @@ function memoize(fn) {
         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 {
+var clamp = function (value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+};
+function mapValues(obj, fn) {
+    return Object.fromEntries(Object.entries(obj).map(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        return [key, fn(value, key)];
+    }));
+}
+/** Добавляет свойства к функции */
+function assignPropsToFn(fn, props) {
+    return Object.assign(fn, props);
+}
+
+/** Фабрика версионированных схем. Не содержит состояния */
+var VersionedSchemaFactory = /** @class */ (function () {
+    function VersionedSchemaFactory() {
+    }
+    VersionedSchemaFactory.compareVersions = function (a, b) {
+        var _a, _b;
+        var partsA = a.split(".").map(Number);
+        var partsB = b.split(".").map(Number);
+        var length = Math.max(partsA.length, partsB.length);
+        for (var i = 0; i < length; i++) {
+            var pa = (_a = partsA[i]) !== null && _a !== void 0 ? _a : 0;
+            var pb = (_b = partsB[i]) !== null && _b !== void 0 ? _b : 0;
+            var diff = Math.sign(pa - pb);
+            if (diff !== 0) {
+                return diff;
+            }
+        }
+        return 0;
+    };
+    VersionedSchemaFactory.findClosestVersion = function (versions, targetVersion, compare) {
+        return versions
+            .toSorted(function (a, b) { return compare(b, a); })
+            .find(function (version) { return compare(version, targetVersion) <= 0; });
+    };
+    /** Добавляет метаданные к схеме (curried) */
+    VersionedSchemaFactory.annotateSchema = function (meta) {
+        if (meta === undefined) {
+            return function (schemaFactory) { return schemaFactory; };
+        }
+        return function (schemaFactory) {
+            return (function (z) {
+                var restArgs = [];
+                for (var _i = 1; _i < arguments.length; _i++) {
+                    restArgs[_i - 1] = arguments[_i];
+                }
+                return schemaFactory.apply(void 0, __spreadArray([z], __read(restArgs), false)).meta(meta);
+            });
+        };
+    };
+    /**
+     * Оборачивает фабрику схемы, добавляя кеширование результата.
+     *
+     * Предполагается, что `z` — синглтон (один экземпляр на всё приложение),
+     * поэтому достаточно закешировать единственный результат.
+     *
+     * Вызовы с дополнительными аргументами (restArgs) не кешируются,
+     * так как результат может зависеть от их значений.
+     */
+    VersionedSchemaFactory.withCache = function (schemaFactory) {
+        var cached;
+        return (function (z) {
+            var restArgs = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                restArgs[_i - 1] = arguments[_i];
+            }
+            if (restArgs.length > 0) {
+                return schemaFactory.apply(void 0, __spreadArray([z], __read(restArgs), false));
+            }
+            if (cached === undefined) {
+                cached = schemaFactory(z);
+            }
+            return cached;
+        });
+    };
+    /** Построить версионированную схему */
+    VersionedSchemaFactory.build = function (_a) {
+        var _this = this;
+        var history = _a.history, latestVersion = _a.latestVersion, meta = _a.meta;
+        var latestFactory = history[latestVersion];
+        if (!latestFactory) {
+            throw new Error("Не найдено записи в 'history' по 'latestVersion'");
+        }
+        var annotate = this.annotateSchema(meta);
+        var preparedHistory = mapValues(history, function (factory) {
+            return _this.withCache(annotate(factory));
+        });
+        var schema = assignPropsToFn(preparedHistory[latestVersion], {
+            forVersion: function (targetVersion) {
+                if (targetVersion === null || targetVersion === undefined) {
+                    return preparedHistory[latestVersion];
+                }
+                if (targetVersion in preparedHistory) {
+                    return preparedHistory[targetVersion];
+                }
+                var closestVersion = _this.findClosestVersion(Object.keys(preparedHistory), targetVersion, VersionedSchemaFactory.compareVersions);
+                if (closestVersion === undefined || !(closestVersion in preparedHistory)) {
+                    throw new Error("\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043F\u043E\u0434\u0445\u043E\u0434\u044F\u0449\u0435\u0439 \u0441\u0445\u0435\u043C\u044B \u0434\u043B\u044F \u0432\u0435\u0440\u0441\u0438\u0438 '".concat(targetVersion, "'"));
+                }
+                return preparedHistory[closestVersion];
+            },
+        });
+        return schema;
+    };
+    return VersionedSchemaFactory;
+}());
+
+/**
+ * Глобальный реестр версионированных схем (публичный слой, только чтение).
+ *
+ * Отвечает за:
+ *
+ * 1. Хранение зарегистрированных схем
+ * 2. Поиск схем по ключу
+ *
+ * Не предоставляет API для модификации registry.
+ */
+var SchemaRegistryReader = /** @class */ (function () {
+    function SchemaRegistryReader() {
+    }
+    /** Получить версионированную схему из `registry` по ключу схемы */
+    SchemaRegistryReader.get = function (schemaKey) {
+        return this.registry.get(schemaKey);
+    };
+    /**
+     * Имя поля в метаданных схемы, в котором хранится идентификатор типа схемы.
+     *
+     * Это поле добавляется ко всем схемам, зарегистрированным через `SchemaRegistry`.
+     */
+    SchemaRegistryReader.typeKey = "type";
+    SchemaRegistryReader.registry = new Map();
+    return SchemaRegistryReader;
+}());
+/**
+ * Глобальный реестр версионированных схем (внутренний слой).
+ *
+ * Расширяет SchemaRegistryReader возможностью создать запись в registry.
+ *
+ * Отвечает за:
+ * 1. Декларацию схем (build + аннотация)
+ * 2. Регистрацию схем по ключу
+ */
+var SchemaRegistry = /** @class */ (function (_super) {
+    __extends(SchemaRegistry, _super);
+    function SchemaRegistry() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /** Объявляет версионированную схему и регистрирует её во внутреннем `registry` */
+    SchemaRegistry.define = function (_a) {
+        var _b;
+        var key = _a.key, history = _a.history, latestVersion = _a.latestVersion;
+        var schema = VersionedSchemaFactory.build({
+            history: history,
+            latestVersion: latestVersion,
+            meta: (_b = {}, _b[this.typeKey] = key, _b),
+        });
+        this.registry.set(key, schema);
+        return schema;
+    };
+    return SchemaRegistry;
+}(SchemaRegistryReader));
+
+/**
+ * Глобальный счетчик для генерации ID.
+ *
+ * @todo
+ * В будущем можно заменить единый счетчик на изолированные счетчики в разных контекстах.
+ */
+var id = 1;
+var AutoIdentifiedArrayItemSchema = SchemaRegistry.define({
+    key: "AutoIdentifiedArrayItem",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                /**
+                 * Идентификатор, добавляемый системой "на лету" для удобства разработки, не сохраняется на сервер.
+                 * Гарантируется уникальность id в пределах settings виджета.
+                 */
+                id: z
+                    .number()
+                    .default(-1)
+                    .transform(function (currentId) { return (currentId === -1 ? id++ : currentId); }),
+            });
+        },
+    },
+});
+var BaseWidgetSettingsSchema = SchemaRegistry.define({
+    key: "BaseWidgetSettings",
+    latestVersion: "19",
+    get history() {
+        var v17 = function (z) {
+            var v17FilterMode = EWidgetFilterMode[VersionedEnum.forVersion]("17");
+            var v17FontWeight = EFontWeight[VersionedEnum.forVersion]("17");
+            return z.object({
+                title: z.string().default(""),
+                titleSize: themed(z.number().default(14), function (theme) { return theme.widgets.titleSize; }),
+                titleColor: themed(ColorSchema.forVersion("17")(z), function (theme) { return theme.widgets.titleColor; }),
+                titleWeight: themed(z.enum(zodEnumLike(v17FontWeight)).default(v17FontWeight.NORMAL), function (theme) { return theme.widgets.titleWeight; }),
+                stateName: z.string().nullable().default(null),
+                showMarkdown: z.boolean().default(false),
+                markdownMeasures: z.array(MarkdownMeasureSchema.forVersion("17")(z)).default([]),
+                markdownText: z.string().default(""),
+                markdownTextSize: z.number().default(14),
+                customNoDataHint: z.string().default(""),
+                filters: z.array(SettingsFilterSchema.forVersion("17")(z)).default([]),
+                filterMode: z.enum(zodEnumLike(v17FilterMode)).default(v17FilterMode.DEFAULT),
+                ignoreFilters: z.boolean().default(false),
+                sorting: z.array(WidgetSortingIndicatorSchema.forVersion("17")(z)).default([]),
+                actionButtons: z.array(ActionButtonSchema.forVersion("17")(z)).default([]),
+                paddings: z.union([z.number(), z.string()]).default(8),
+                viewTheme: z.boolean().default(false),
+            });
+        };
+        return {
+            "17": v17,
+            "19": function (z) {
+                return v17(z)
+                    .omit({ paddings: true, filterMode: true })
+                    .extend({ ignoreFilters: WidgetIgnoreFilterModeSchema.forVersion("19")(z) });
+            },
+        };
+    },
+});
+
+var EWidgetIndicatorType = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            MEASURE: "MEASURE",
+            EVENT_INDICATOR: "EVENT_INDICATOR",
+            TRANSITION_INDICATOR: "TRANSITION_INDICATOR",
+            DIMENSION: "DIMENSION",
+            SORTING: "SORTING",
+        },
+    },
+});
+var EOuterAggregation = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            avg: "avg",
+            median: "median",
+            count: "count",
+            countDistinct: "countDistinct",
+            min: "min",
+            max: "max",
+            sum: "sum",
+            top: "top",
+        },
+    },
+});
+/** Режимы значения показателя (на основе чего генерируется формула) */
+var EWidgetIndicatorValueModes = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Готовая формула (как правило, введенная пользователем через редактор формул) */
+            FORMULA: "FORMULA",
+            /** Шаблон формулы, предоставляемый системой */
+            TEMPLATE: "TEMPLATE",
+            AGGREGATION: "AGGREGATION",
+            DURATION: "DURATION",
+            CONVERSION: "CONVERSION",
+            START_TIME: "START_TIME",
+            END_TIME: "END_TIME",
+        },
+    },
+});
+/** Режимы сортировки (на что ссылается сортировка) */
+var ESortingValueModes = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Сортировка по формуле */
+            FORMULA: "FORMULA",
+            /** Сортировка по показателю(разрезу или мере) виджета */
+            IN_WIDGET: "IN_WIDGET",
+        },
+    },
+});
+var EFormatOrFormattingMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            BASE: "BASE",
+            TEMPLATE: "TEMPLATE",
+        },
+    },
+});
+function inheritDisplayConditionFromHierarchy(dimension, hierarchy) {
+    return __assign(__assign({}, dimension), { displayCondition: hierarchy.displayCondition });
+}
+/** Тип показателя */
+var EIndicatorType = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Показатели процесса */
+            PROCESS_MEASURE: "PROCESS_MEASURE",
+            /** Вводимое значение */
+            STATIC: "STATIC",
+            /** Статический список */
+            STATIC_LIST: "STATIC_LIST",
+            /** Динамический список */
+            DYNAMIC_LIST: "DYNAMIC_LIST",
+            /** Список колонок */
+            COLUMN_LIST: "COLUMN_LIST",
+            /** Разрез */
+            DIMENSION: "DIMENSION",
+            /** Мера */
+            MEASURE: "MEASURE",
+            /** Иерархия */
+            DYNAMIC_DIMENSION: "DYNAMIC_DIMENSION",
+            /** Пользовательская сортировка */
+            USER_SORTING: "USER_SORTING",
+        },
+    },
+});
+/** Обобщенные типы значений переменных */
+var ESimpleInputType = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Число (точность Float64) */
+            NUMBER: "FLOAT",
+            /** Целое число (точность Int64) */
+            INTEGER_NUMBER: "INTEGER",
+            /** Текст */
+            TEXT: "STRING",
+            /** Дата (точность Date) */
+            DATE: "DATE",
+            /** Дата и время (точность DateTime64) */
+            DATE_AND_TIME: "DATETIME",
+            /** Логический тип */
+            BOOLEAN: "BOOLEAN",
+        },
+    },
+});
+function isDimensionsHierarchy(indicator) {
+    return "hierarchyDimensions" in indicator;
+}
+var OuterAggregation = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            avg: "avgIf",
+            median: "medianIf",
+            count: "countIf",
+            countDistinct: "countIfDistinct",
+            min: "minIf",
+            max: "maxIf",
+            sum: "sumIf",
+        },
+    },
+});
+var EDurationTemplateName = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            avg: "avg",
+            median: "median",
+        },
+    },
+});
+var EEventAppearances = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            FIRST: "FIRST",
+            LAST: "LAST",
+        },
+    },
+});
+
+// Типы, используемые в значениях элементов управления.
+/** Режим фильтрации (с возможностью наследования, начиная с v19) */
+var EWidgetFilterMode = VersionedEnum.build({
+    latestVersion: "19",
+    get history() {
+        var v17 = {
+            DEFAULT: "DEFAULT",
+            SINGLE: "SINGLE",
+            MULTI: "MULTI",
+            DISABLED: "DISABLED",
+        };
+        return {
+            "17": v17,
+            "19": {
+                INHERITED: "INHERITED",
+                DEFAULT: "DEFAULT",
+                SINGLE: "SINGLE",
+                DISABLED: "DISABLED",
+            },
+        };
+    },
+});
+/** Режим игнорирования фильтрации (разрешённое значение образа: вкл/выкл) */
+var EIgnoreFilterMode = VersionedEnum.build({
+    latestVersion: "19",
+    history: {
+        "19": {
+            ENABLED: "ENABLED",
+            DISABLED: "DISABLED",
+        },
+    },
+});
+/** Режим игнорирования фильтрации (с возможностью наследования) */
+var EWidgetIgnoreFilterMode = VersionedEnum.build({
+    latestVersion: "19",
+    history: {
+        "19": {
+            INHERITED: "INHERITED",
+            ENABLED: "ENABLED",
+            DISABLED: "DISABLED",
+        },
+    },
+});
+var EMarkdownDisplayMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            NONE: "NONE",
+            INDICATOR: "INDICATOR",
+        },
+    },
+});
+var EDisplayConditionMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            DISABLED: "DISABLED",
+            FORMULA: "FORMULA",
+            VARIABLE: "VARIABLE",
+        },
+    },
+});
+var EFontWeight = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            NORMAL: "NORMAL",
+            BOLD: "BOLD",
+        },
+    },
+});
+var EHeightMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            FIXED: "FIXED",
+            PERCENT: "PERCENT",
+        },
+    },
+});
+
+var SortDirectionSchema = SchemaRegistry.define({
+    key: "SortDirection",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([z.literal(ESortDirection.ascend), z.literal(ESortDirection.descend)]);
+        },
+    },
+});
+var SortOrderSchema = SchemaRegistry.define({
+    key: "SortOrder",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                /** Формула сортировки */
+                formula: FormulaSchema.forVersion("17")(z),
+                /** Тип данных формулы */
+                dbDataType: z.string().optional(),
+                /** Направление сортировки */
+                direction: SortDirectionSchema.forVersion("17")(z),
+                /** Условие применения сортировки */
+                displayCondition: FormulaSchema.forVersion("17")(z).optional(),
+            });
+        },
+    },
+});
+var WidgetSortingValueSchema = SchemaRegistry.define({
+    key: "WidgetSortingValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(ESortingValueModes.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                    dbDataType: z.string().optional(),
+                }),
+                z.object({
+                    mode: z.literal(ESortingValueModes.IN_WIDGET),
+                    group: z.string(),
+                    index: z.number(),
+                }),
+            ]);
+        },
+    },
+});
+var SortingValueSchema = SchemaRegistry.define({
+    key: "SortingValueSchema",
+    latestVersion: "19",
+    history: {
+        "19": function (z) {
+            return z.discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(ESortingMode.BY_VALUES),
+                    direction: SortDirectionSchema(z).default(ESortDirection.ascend),
+                }),
+                z.object({
+                    mode: z.literal(ESortingMode.FORMULA),
+                    direction: SortDirectionSchema(z).default(ESortDirection.ascend),
+                    formula: FormulaSchema.forVersion("17")(z),
+                    dbDataType: z.string().optional(),
+                }),
+            ]);
+        },
+    },
+});
+
+/** Ключи мета-данных внутри схем настроек */
+var ESettingsSchemaMetaKey = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Привязка значения из темы к настройке */
+            themeValue: "themeValue",
+            /** Тип сущности */
+            entity: "entity",
+        },
+    },
+});
+
+var RangeSchema = SchemaRegistry.define({
+    key: "Range",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                unit: z.string().optional(),
+                min: z.number().optional(),
+                max: z.number().optional(),
+            });
+        },
+    },
+});
+var DisplayConditionSchema = SchemaRegistry.define({
+    key: "DisplayCondition",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EDisplayConditionMode.DISABLED),
+                }),
+                z.object({
+                    mode: z.literal(EDisplayConditionMode.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(EDisplayConditionMode.VARIABLE),
+                    variableName: NameNullableSchema.forVersion("17")(z),
+                    variableValue: z.string().nullable().default(null),
+                }),
+            ])
+                .default({ mode: EDisplayConditionMode.DISABLED });
+        },
+    },
+});
+/** Схема ключа сущности (с возможностью находиться в неинициализированном состоянии) */
+var KeyNullableSchema = SchemaRegistry.define({
+    key: "KeyNullable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return z.string().nullable().default(null); },
+    },
+});
+/** Схема имени сущности (с возможностью находиться в неинициализированном состоянии) */
+var NameNullableSchema = SchemaRegistry.define({
+    key: "NameNullable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return z.string().nullable().default(null); },
+    },
+});
+/** Схема формулы */
+var FormulaSchema = SchemaRegistry.define({
+    key: "Formula",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return z.string().default(""); },
+    },
+});
+/**
+ * Схема формулы, которая не может быть пустой строкой, но может быть в
+ * неинициализированном состоянии null (вместо пустой строки)
+ *
+ * @note для обратной совместимости без необходимости писать миграции
+ */
+var FormulaNullableSchema = SchemaRegistry.define({
+    key: "FormulaNullable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) { return FormulaSchema.forVersion("17")(z).nullable().default(null); },
+    },
+});
+
+// NOTE: В будущем можно сделать fluent-обёртку для цепочных вызовов:
+//   withMetaDecorator(schema).omit({ field: true }).extend({ newField: z.string() })
+// Это позволит избежать вложенных вызовов omitWithMeta/extendWithMeta.
+var PARENT_META_KEY = "parent";
+/**
+ * Возвращает родительскую мету схемы, установленную через extendWithMeta / omitWithMeta.
+ * Используй для обхода цепочки наследования схем.
+ */
+function getParentMeta(meta) {
+    return meta[PARENT_META_KEY];
+}
+function inheritMeta(target, source) {
+    var _a;
+    var sourceMeta = source.meta();
+    return sourceMeta !== undefined ? target.meta((_a = {}, _a[PARENT_META_KEY] = sourceMeta, _a)) : target;
+}
+/**
+ * Расширяет Zod-схему дополнительными полями, сохраняя цепочку наследования мет.
+ *
+ * Мета базовой схемы сохраняется как `parent` в мете расширенной схемы — формируя
+ * иммутабельный связанный список.
+ *
+ * Используй вместо `.extend()` при расширении схем, задекларированных через
+ * `SchemaRegistry.define`, — это обязательное условие корректной работы миграций.
+ *
+ * @example
+ * // Вместо:
+ * DimensionSchema(z).extend({ color: ColorSchema(z) })
+ *
+ * // Используй:
+ * extendWithMeta(DimensionSchema(z), { color: ColorSchema(z) })
+ */
+function extendWithMeta(schema, extension) {
+    return inheritMeta(schema.extend(extension), schema);
+}
+/**
+ * Создаёт Zod-схему с удалёнными полями, сохраняя цепочку наследования мет.
+ *
+ * Мета базовой схемы сохраняется как `parent` в мете результирующей схемы.
+ *
+ * Используй вместо `.omit()` при работе со схемами, задекларированными через
+ * `SchemaRegistry.define`, — это обязательное условие корректной работы миграций.
+ *
+ * @example
+ * // Вместо:
+ * BaseWidgetSettingsSchema(z).omit({ paddings: true })
+ *
+ * // Используй:
+ * omitWithMeta(BaseWidgetSettingsSchema(z), { paddings: true })
+ */
+function omitWithMeta(schema, keys) {
+    return inheritMeta(schema.omit(keys), schema);
+}
+/**
+ * Проверяет, есть ли в цепочке наследования мет узел, удовлетворяющий предикату.
+ *
+ * Обходит цепочку от текущей меты к корню через ссылки parent, установленные
+ * функциями extendWithMeta / omitWithMeta.
+ *
+ * @example
+ * hasInMetaChain(schema.meta(), (meta) => meta.type === "WidgetDimension")
+ */
+function hasInMetaChain(meta, predicate) {
+    var current = meta;
+    while (current !== undefined) {
+        if (predicate(current))
+            return true;
+        current = getParentMeta(current);
+    }
+    return false;
+}
+
+var WidgetIndicatorSchema = SchemaRegistry.define({
+    key: "WidgetIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), {
+                name: z.string(),
+            });
+        },
+    },
+});
+var FormatSchema = SchemaRegistry.define({
+    key: "Format",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EFormatOrFormattingMode.BASE),
+                    value: z.enum(EFormatTypes).default(EFormatTypes.STRING).optional(),
+                }),
+                z.object({
+                    mode: z.literal(EFormatOrFormattingMode.TEMPLATE),
+                    value: z.string().default("").optional(),
+                }),
+            ])
+                .default({ mode: EFormatOrFormattingMode.BASE, value: EFormatTypes.STRING });
+        },
+    },
+});
+var FormattingSchema = SchemaRegistry.define({
+    key: "Formatting",
+    latestVersion: "17",
+    history: {
+        "17": 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 = SchemaRegistry.define({
+    key: "WidgetColumnIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(WidgetIndicatorSchema.forVersion("17")(z), {
+                dbDataType: z.string().optional(),
+                format: FormatSchema.forVersion("17")(z).optional(),
+                formatting: FormattingSchema.forVersion("17")(z).optional(),
+                displayCondition: DisplayConditionSchema.forVersion("17")(z),
+                onClick: z.array(ActionsOnClickSchema.forVersion("17")(z)).default([]).optional(),
+            });
+        },
+    },
+});
+var WidgetIndicatorFormulaValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorFormulaValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
+                formula: FormulaSchema.forVersion("17")(z).optional(),
+            });
+        },
+    },
+});
+var WidgetIndicatorTemplateValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorTemplateValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.TEMPLATE),
+                /** Имя шаблонной формулы, использующей колонку таблицы */
+                templateName: z.string().optional(),
+                /** Имя таблицы */
+                tableName: z.string().optional(),
+                /** Имя колонки */
+                columnName: z.string().optional(),
+            });
+        },
+    },
+});
+var ColumnIndicatorValueSchema = SchemaRegistry.define({
+    key: "ColumnIndicatorValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([MeasureValueSchema.forVersion("17")(z), DimensionValueSchema.forVersion("17")(z)]);
+        },
+    },
+});
+var MeasureValueSchema = SchemaRegistry.define({
+    key: "MeasureValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                WidgetIndicatorFormulaValueSchema.forVersion("17")(z),
+                extendWithMeta(WidgetIndicatorTemplateValueSchema.forVersion("17")(z), {
+                    innerTemplateName: z.enum(zodEnumLike(EMeasureInnerTemplateNames)).optional(),
+                }),
+            ]);
+        },
+    },
+});
+var DimensionValueSchema = SchemaRegistry.define({
+    key: "DimensionValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                WidgetIndicatorFormulaValueSchema.forVersion("17")(z),
+                extendWithMeta(WidgetIndicatorTemplateValueSchema.forVersion("17")(z), {
+                    innerTemplateName: z.never().optional(),
+                }),
+            ]);
+        },
+    },
+});
+var WidgetIndicatorAggregationValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorAggregationValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.AGGREGATION),
+                templateName: z.string(),
+                processKey: KeyNullableSchema.forVersion("17")(z),
+                eventName: NameNullableSchema.forVersion("17")(z),
+                eventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                anyEvent: z.literal(true).optional(),
+                caseCaseIdFormula: FormulaNullableSchema.forVersion("17")(z),
+                filters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+                tableName: z.string().optional(),
+                columnName: z.string().optional(),
+                eventTimeFormula: FormulaNullableSchema.forVersion("17")(z).optional(),
+                innerTemplateName: z.string().optional(),
+            });
+        },
+    },
+});
+var WidgetMeasureAggregationValueSchema = SchemaRegistry.define({
+    key: "WidgetMeasureAggregationValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(WidgetIndicatorAggregationValueSchema.forVersion("17")(z), {
+                outerAggregation: z.enum(EOuterAggregation[VersionedEnum.forVersion]("17")),
+            });
+        },
+    },
+});
+var WidgetIndicatorTimeValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorTimeValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                templateName: z.string(),
+                mode: z.union([
+                    z.literal(EWidgetIndicatorValueModes.START_TIME),
+                    z.literal(EWidgetIndicatorValueModes.END_TIME),
+                ]),
+                processKey: KeyNullableSchema.forVersion("17")(z),
+                eventName: NameNullableSchema.forVersion("17")(z),
+                eventTimeFormula: FormulaNullableSchema.forVersion("17")(z),
+                caseCaseIdFormula: FormulaNullableSchema.forVersion("17")(z),
+                eventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                filters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var WidgetDimensionSchema = SchemaRegistry.define({
+    key: "WidgetDimension",
+    latestVersion: "19",
+    get history() {
+        var v17 = function (z) {
+            return extendWithMeta(WidgetColumnIndicatorSchema.forVersion("17")(z), {
+                value: z
+                    .discriminatedUnion("mode", [
+                    DimensionValueSchema.forVersion("17")(z),
+                    extendWithMeta(WidgetIndicatorAggregationValueSchema.forVersion("17")(z), {
+                        innerTemplateName: z.string().optional(),
+                    }),
+                    WidgetIndicatorTimeValueSchema.forVersion("17")(z),
+                ])
+                    .optional(),
+                hideEmptyValues: z.boolean().default(false),
+            });
+        };
+        return {
+            "17": v17,
+            "19": function (z) {
+                return extendWithMeta(v17(z), {
+                    filterMode: WidgetFilterModeSchema.forVersion("19")(z).default(EWidgetFilterMode.INHERITED),
+                });
+            },
+        };
+    },
+});
+var WidgetDimensionInHierarchySchema = SchemaRegistry.define({
+    key: "WidgetDimensionInHierarchy",
+    latestVersion: "19",
+    history: {
+        "17": function (z) {
+            return omitWithMeta(WidgetDimensionSchema.forVersion("17")(z), { displayCondition: true });
+        },
+        "19": function (z) {
+            return omitWithMeta(WidgetDimensionSchema.forVersion("19")(z), { displayCondition: true });
+        },
+    },
+});
+var WidgetDimensionHierarchySchema = SchemaRegistry.define({
+    key: "WidgetDimensionHierarchy",
+    latestVersion: "19",
+    get history() {
+        // Тело buildHierarchy одинаково для v17/v19 — версии нужны только для ограничения типа D,
+        // чтобы вызывающий код мог передавать dimension-схему нужной версии без ручного приведения.
+        var buildHierarchy = function (z, dimensionSchema) {
+            return extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), {
+                name: z.string(),
+                // Для иерархии является дискриминатором, для него нельзя задавать дефолтное значение.
+                hierarchyDimensions: z.array(dimensionSchema),
+                displayCondition: DisplayConditionSchema.forVersion("17")(z),
+            });
+        };
+        var forVersionedBuilder = function (_version) {
+            return function (z, dimensionSchema) {
+                return buildHierarchy(z, dimensionSchema);
+            };
+        };
+        return {
+            "17": forVersionedBuilder(),
+            "19": forVersionedBuilder(),
+        };
+    },
+});
+var WidgetIndicatorConversionValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorConversionValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EWidgetIndicatorValueModes.CONVERSION),
+                startEventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                startEventProcessKey: KeyNullableSchema.forVersion("17")(z),
+                startEventName: NameNullableSchema.forVersion("17")(z),
+                startEventFilters: z
+                    .array(ExtendedFormulaFilterValueSchema.forVersion("17")(z))
+                    .default([]),
+                startEventTimeFormula: FormulaNullableSchema.forVersion("17")(z),
+                endEventNameFormula: FormulaNullableSchema.forVersion("17")(z),
+                endEventProcessKey: KeyNullableSchema.forVersion("17")(z),
+                endEventName: NameNullableSchema.forVersion("17")(z),
+                endEventFilters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+                endCaseCaseIdFormula: FormulaNullableSchema.forVersion("17")(z),
+                endEventTimeFormula: FormulaNullableSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var WidgetIndicatorDurationValueSchema = SchemaRegistry.define({
+    key: "WidgetIndicatorDurationValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(WidgetIndicatorConversionValueSchema.forVersion("17")(z), {
+                mode: z.literal(EWidgetIndicatorValueModes.DURATION),
+                templateName: z.string(),
+                startEventAppearances: z.enum(EEventAppearances[VersionedEnum.forVersion]("17")),
+                endEventAppearances: z.enum(EEventAppearances[VersionedEnum.forVersion]("17")),
+            });
+        },
+    },
+});
+var WidgetMeasureSchema = SchemaRegistry.define({
+    key: "WidgetMeasure",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(WidgetColumnIndicatorSchema.forVersion("17")(z), {
+                value: z
+                    .discriminatedUnion("mode", [
+                    MeasureValueSchema.forVersion("17")(z),
+                    WidgetMeasureAggregationValueSchema.forVersion("17")(z),
+                    WidgetIndicatorConversionValueSchema.forVersion("17")(z),
+                    WidgetIndicatorDurationValueSchema.forVersion("17")(z),
+                ])
+                    .optional(),
+            });
+        },
+    },
+});
+var MarkdownMeasureSchema = SchemaRegistry.define({
+    key: "MarkdownMeasure",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            var v17MarkdownDisplayMode = EMarkdownDisplayMode[VersionedEnum.forVersion]("17");
+            return extendWithMeta(WidgetMeasureSchema.forVersion("17")(z), {
+                displaySign: z
+                    .enum(zodEnumLike(v17MarkdownDisplayMode))
+                    .default(v17MarkdownDisplayMode.NONE),
+            });
+        },
+    },
+});
+var WidgetSortingIndicatorSchema = SchemaRegistry.define({
+    key: "WidgetSortingIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(WidgetIndicatorSchema.forVersion("17")(z), {
+                direction: SortDirectionSchema.forVersion("17")(z),
+                value: WidgetSortingValueSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var ProcessIndicatorValueSchema = SchemaRegistry.define({
+    key: "ProcessIndicatorValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(z),
+                }),
+                z.object({
+                    mode: z.literal(EWidgetIndicatorValueModes.TEMPLATE),
+                    /** Имя шаблонной формулы, использующей колонку таблицы */
+                    templateName: z.string(),
+                }),
+            ]);
+        },
+    },
+});
+var ProcessIndicatorSchema = SchemaRegistry.define({
+    key: "ProcessIndicator",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(WidgetIndicatorSchema.forVersion("17")(z), {
+                value: ProcessIndicatorValueSchema.forVersion("17")(z).optional(),
+                dbDataType: z.string().optional(),
+                format: FormatSchema.forVersion("17")(z).optional(),
+                formatting: FormattingSchema.forVersion("17")(z).optional(),
+                displayCondition: DisplayConditionSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+
+var FormulaFilterValueSchema = SchemaRegistry.define({
+    key: "FormulaFilterValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            var _a;
+            return z.object({
+                name: z.string().nullish(),
+                formula: FormulaSchema.forVersion("17")(z),
+                sliceIndex: z.number().optional(),
+                dbDataType: z.string(),
+                format: z.union([z.enum(EFormatTypes), z.string()]).optional(),
+                filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+                checkedValues: z.array(z.string().nullable()).default([]).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().nullable(),
+                        z.number().nullable(),
+                    ]),
+                    _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(zodEnumLike(ELastTimeUnit)),
+                    _a[EFormulaFilterFieldKeys.durationUnit] = z.enum(zodEnumLike(EDurationUnit)),
+                    _a))
+                    .partial()
+                    .optional(),
+            });
+        },
+    },
+});
+var ExtendedFormulaFilterValueSchema = SchemaRegistry.define({
+    key: "ExtendedFormulaFilterValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                FormulaFilterValueSchema.forVersion("17")(z),
+                z.object({ formula: FormulaSchema.forVersion("17")(z) }),
+            ]);
+        },
+    },
+});
+var DimensionProcessFilterSchema = SchemaRegistry.define({
+    key: "DimensionProcessFilter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                value: z.union([
+                    extendWithMeta(WidgetIndicatorAggregationValueSchema.forVersion("17")(z), {
+                        outerAggregation: z.enum(EOuterAggregation[VersionedEnum.forVersion]("17")),
+                    }),
+                    extendWithMeta(WidgetIndicatorAggregationValueSchema.forVersion("17")(z), {
+                        innerTemplateName: z.string().optional(),
+                    }),
+                    WidgetIndicatorTimeValueSchema.forVersion("17")(z),
+                    z.object({
+                        mode: z.literal(EWidgetIndicatorValueModes.FORMULA),
+                        formula: FormulaSchema.forVersion("17")(z).optional(),
+                    }),
+                ]),
+                dbDataType: z.string(),
+                condition: z.object({
+                    filteringMethod: z.enum(Object.values(formulaFilterMethods)),
+                    timeUnit: z.enum(zodEnumLike(EDimensionProcessFilterTimeUnit)).optional(),
+                    values: z.array(z.string().nullable()),
+                }),
+            });
+        },
+    },
+});
+var SettingsFilterSchema = SchemaRegistry.define({
+    key: "SettingsFilter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                DimensionProcessFilterSchema.forVersion("17")(z),
+                ExtendedFormulaFilterValueSchema.forVersion("17")(z),
+            ]);
+        },
+    },
+});
+var WidgetIgnoreFilterModeSchema = SchemaRegistry.define({
+    key: "WidgetIgnoreFilterMode",
+    latestVersion: "19",
+    history: {
+        "19": function (z) {
+            var v19IgnoreFilterMode = EWidgetIgnoreFilterMode[VersionedEnum.forVersion]("19");
+            return z.enum(zodEnumLike(v19IgnoreFilterMode)).default(v19IgnoreFilterMode.INHERITED);
+        },
+    },
+});
+var WidgetFilterModeSchema = SchemaRegistry.define({
+    key: "WidgetFilterMode",
+    latestVersion: "19",
+    history: {
+        "19": function (z) {
+            var v19FilterMode = EWidgetFilterMode[VersionedEnum.forVersion]("19");
+            return z.enum(zodEnumLike(v19FilterMode)).default(v19FilterMode.INHERITED);
+        },
+    },
+});
+
+var ActionOnClickParameterCommonSchema = SchemaRegistry.define({
+    key: "ActionOnClickParameterCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), {
+                name: z.string(),
+            });
+        },
+    },
+});
+var ParameterFromColumnSchema = SchemaRegistry.define({
+    key: "ParameterFromColumn",
+    latestVersion: "17",
+    history: {
+        "17": 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(),
+                value: z.string().nullable().optional(),
+            });
+        },
+    },
+});
+var ParameterFromVariableSchema = SchemaRegistry.define({
+    key: "ParameterFromVariable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.VARIABLE),
+                sourceVariable: z.string().nullable().default(null),
+            });
+        },
+    },
+});
+var ParameterFromFormulaSchema = SchemaRegistry.define({
+    key: "ParameterFromFormula",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.FORMULA),
+                formula: FormulaSchema.forVersion("17")(z),
+                considerFilters: z.boolean().default(false),
+                dbDataType: z.string().optional(),
+            });
+        },
+    },
+});
+var ParameterFromEventSchema = SchemaRegistry.define({
+    key: "ParameterFromEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.EVENT),
+            });
+        },
+    },
+});
+var ParameterFromStartEventSchema = SchemaRegistry.define({
+    key: "ParameterFromStartEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.START_EVENT),
+            });
+        },
+    },
+});
+var ParameterFromEndEventSchema = SchemaRegistry.define({
+    key: "ParameterFromEndEvent",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.FINISH_EVENT),
+            });
+        },
+    },
+});
+var ParameterFromAggregationSchema = SchemaRegistry.define({
+    key: "ParameterFromAggregation",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.AGGREGATION),
+                formula: FormulaSchema.forVersion("17")(z),
+                considerFilters: z.boolean().default(false),
+                dbDataType: z.string().optional(),
+            });
+        },
+    },
+});
+var ParameterFromManualInputSchema = SchemaRegistry.define({
+    key: "ParameterFromManualInput",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.MANUALLY),
+                description: z.string().default(""),
+                defaultValue: FormulaSchema.forVersion("17")(z),
+                dbDataType: z.string().optional(),
+                filterByRows: z.boolean().default(false),
+                validation: FormulaSchema.forVersion("17")(z),
+                acceptEmptyValue: z.boolean().default(false),
+            });
+        },
+    },
+});
+var ParameterFromStaticListSchema = SchemaRegistry.define({
+    key: "ParameterFromStaticList",
+    latestVersion: "17",
+    history: {
+        "17": 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 = SchemaRegistry.define({
+    key: "ParameterFromDynamicList",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.DYNAMIC_LIST),
+                options: FormulaSchema.forVersion("17")(z),
+                defaultValue: FormulaSchema.forVersion("17")(z),
+                dbDataType: z.string().optional(),
+                displayOptions: FormulaSchema.forVersion("17")(z),
+                filters: z.array(ExtendedFormulaFilterValueSchema.forVersion("17")(z)).default([]),
+                filterByRows: z.boolean().default(false),
+                considerFilters: z.boolean().default(false),
+                insertAnyValues: z.boolean().default(false),
+                validation: FormulaSchema.forVersion("17")(z),
+                acceptEmptyValue: z.boolean().default(false),
+                sorting: SortingValueSchema.forVersion("19")(z)
+                    .default({
+                    direction: ESortDirection.ascend,
+                    mode: ESortingMode.BY_VALUES,
+                })
+                    .optional(),
+            });
+        },
+    },
+});
+var ParameterFromDataModelSchema = SchemaRegistry.define({
+    key: "ParameterFromDataModel",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.DATA_MODEL),
+                option: z.enum(zodEnumLike(EDataModelOption)).default(EDataModelOption.TABLE_LIST),
+                /**
+                 * Используется только при COLUMN_LIST. Не делаем union по option, чтобы сохранить
+                 * одновременно default для option и работоспособность внешнего discriminated union.
+                 */
+                parent: NameNullableSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+/**
+ * Значение берётся из редактируемого текста виджета в момент сохранения.
+ * Используется только в `onSave` виджета `editable-text-widget`.
+ */
+var ParameterFromEditableTextValueSchema = SchemaRegistry.define({
+    key: "ParameterFromEditableTextValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                inputMethod: z.literal(EWidgetActionInputMethod.EDITABLE_TEXT_VALUE),
+                value: z.string().optional(),
+            });
+        },
+    },
+});
+var ActionOnClickParameterSchema = SchemaRegistry.define({
+    key: "ActionOnClickParameter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(ActionOnClickParameterCommonSchema.forVersion("17")(z), z.discriminatedUnion("inputMethod", [
+                ParameterFromColumnSchema.forVersion("17")(z),
+                ParameterFromVariableSchema.forVersion("17")(z),
+                ParameterFromFormulaSchema.forVersion("17")(z),
+                ParameterFromEventSchema.forVersion("17")(z),
+                ParameterFromStartEventSchema.forVersion("17")(z),
+                ParameterFromEndEventSchema.forVersion("17")(z),
+                ParameterFromAggregationSchema.forVersion("17")(z),
+                ParameterFromManualInputSchema.forVersion("17")(z),
+                ParameterFromStaticListSchema.forVersion("17")(z),
+                ParameterFromDynamicListSchema.forVersion("17")(z),
+                ParameterFromDataModelSchema.forVersion("17")(z),
+                ParameterFromEditableTextValueSchema.forVersion("17")(z),
+            ]));
+        },
+    },
+});
+var ActionCommonSchema = SchemaRegistry.define({
+    key: "ActionCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), {
+                name: z.string(),
+            });
+        },
+    },
+});
+var ActionDrillDownSchema = SchemaRegistry.define({
+    key: "ActionDrillDown",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(ActionCommonSchema.forVersion("17")(z), {
+                type: z.literal(EActionTypes.DRILL_DOWN),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActionGoToURLSchema = SchemaRegistry.define({
+    key: "ActionGoToURL",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(ActionCommonSchema.forVersion("17")(z), {
+                type: z.literal(EActionTypes.OPEN_URL),
+                url: FormulaSchema.forVersion("17")(z),
+                newWindow: z.boolean().default(true),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActivateConditionSchema = SchemaRegistry.define({
+    key: "ActivateCondition",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                z.object({
+                    mode: z.literal(EActivateConditionMode.FORMULA),
+                    formula: FormulaSchema.forVersion("17")(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 = SchemaRegistry.define({
+    key: "ActionRunScript",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(ActionCommonSchema.forVersion("17")(z), {
+                type: z.literal(EActionTypes.EXECUTE_SCRIPT),
+                parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                scriptKey: z.string(),
+                autoUpdate: z.enum(zodEnumLike(EAutoUpdateMode)).default(EAutoUpdateMode.THIS_WIDGET),
+                hideInactiveButton: z.boolean().default(false),
+                activateCondition: ActivateConditionSchema.forVersion("17")(z),
+                hint: z.string().default(""),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                runButtonText: z.string().default(""),
+            });
+        },
+    },
+});
+var ActionUpdateVariableSchema = SchemaRegistry.define({
+    key: "ActionUpdateVariable",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(ActionCommonSchema.forVersion("17")(z), {
+                type: z.literal(EActionTypes.UPDATE_VARIABLE),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActionOpenInSchema = SchemaRegistry.define({
+    key: "ActionOpenIn",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.discriminatedUnion("openIn", [
+                z.object({
+                    openIn: z.literal(EViewOpenIn.DRAWER_WINDOW),
+                    alignment: z.enum(zodEnumLike(EDrawerPlacement)).default(EDrawerPlacement.RIGHT),
+                    inheritFilter: z.boolean().default(true),
+                }),
+                z.object({
+                    openIn: z.literal(EViewOpenIn.PLACEHOLDER),
+                    placeholderName: z.string().optional(),
+                }),
+                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 = SchemaRegistry.define({
+    key: "ActionOpenViewCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(ActionCommonSchema.forVersion("17")(z), {
+                type: z.literal(EActionTypes.OPEN_VIEW),
+                variables: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+            });
+        },
+    },
+});
+var ActionOpenViewSchema = SchemaRegistry.define({
+    key: "ActionOpenView",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(z.discriminatedUnion("mode", [
+                extendWithMeta(ActionOpenViewCommonSchema.forVersion("17")(z), {
+                    mode: z.literal(EViewMode.GENERATED_BY_SCRIPT),
+                    scriptKey: z.string().optional(),
+                    parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                    displayName: z.string().default(""),
+                }),
+                extendWithMeta(ActionOpenViewCommonSchema.forVersion("17")(z), {
+                    mode: z.literal(EViewMode.EXISTED_VIEW),
+                    viewKey: z.string().optional(),
+                    parameters: z.array(ActionOnClickParameterSchema.forVersion("17")(z)).default([]),
+                }),
+                extendWithMeta(ActionOpenViewCommonSchema.forVersion("17")(z), {
+                    mode: z.literal(EViewMode.EMPTY),
+                    placeholderName: z.string().optional(),
+                    openIn: z.literal(EViewOpenIn.PLACEHOLDER),
+                }),
+            ]), ActionOpenInSchema.forVersion("17")(z));
+        },
+    },
+});
+var ActionsOnClickSchema = SchemaRegistry.define({
+    key: "ActionsOnClick",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                ActionGoToURLSchema.forVersion("17")(z),
+                ActionRunScriptSchema.forVersion("17")(z),
+                ActionUpdateVariableSchema.forVersion("17")(z),
+                ActionOpenViewSchema.forVersion("17")(z),
+                ActionDrillDownSchema.forVersion("17")(z),
+            ]);
+        },
+    },
+});
+var WidgetActionParameterCommonSchema = SchemaRegistry.define({
+    key: "WidgetActionParameterCommon",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), {
+                name: z.string(),
+                displayName: z.string().default(""),
+                isHidden: z.boolean().default(false),
+            });
+        },
+    },
+});
+var WidgetActionParameterSchema = SchemaRegistry.define({
+    key: "WidgetActionParameter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(WidgetActionParameterCommonSchema.forVersion("17")(z), z.discriminatedUnion("inputMethod", [
+                ParameterFromColumnSchema.forVersion("17")(z),
+                ParameterFromVariableSchema.forVersion("17")(z),
+                ParameterFromFormulaSchema.forVersion("17")(z),
+                ParameterFromManualInputSchema.forVersion("17")(z),
+                ParameterFromStaticListSchema.forVersion("17")(z),
+                ParameterFromDynamicListSchema.forVersion("17")(z),
+                ParameterFromAggregationSchema.forVersion("17")(z),
+                ParameterFromDataModelSchema.forVersion("17")(z),
+            ]));
+        },
+    },
+});
+var WidgetActionSchema = SchemaRegistry.define({
+    key: "WidgetAction",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(ActionCommonSchema.forVersion("17")(z), {
+                parameters: z.array(WidgetActionParameterSchema.forVersion("17")(z)).default([]),
+                type: z.literal(EActionTypes.EXECUTE_SCRIPT),
+                scriptKey: z.string(),
+                autoUpdate: z.enum(zodEnumLike(EAutoUpdateMode)).default(EAutoUpdateMode.THIS_WIDGET),
+                description: z.string().default(""),
+                hideInactiveButton: z.boolean().default(false),
+                hint: z.string().default(""),
+                activateCondition: ActivateConditionSchema.forVersion("17")(z),
+                variables: z.array(WidgetActionParameterSchema.forVersion("17")(z)).default([]),
+                runButtonText: z.string().default(""),
+            });
+        },
+    },
+});
+var ViewActionParameterSchema = SchemaRegistry.define({
+    key: "ViewActionParameter",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.intersection(extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), { name: z.string() }), z.discriminatedUnion("inputMethod", [
+                ParameterFromAggregationSchema.forVersion("17")(z),
+                ParameterFromVariableSchema.forVersion("17")(z),
+            ]));
+        },
+    },
+});
+var ViewActionSchema = SchemaRegistry.define({
+    key: "ViewAction",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), {
+                name: z.string(),
+                buttonType: z.enum(zodEnumLike(EActionButtonsTypes)).default(EActionButtonsTypes.BASE),
+                type: z.literal(EActionTypes.EXECUTE_SCRIPT).default(EActionTypes.EXECUTE_SCRIPT),
+                parameters: z.array(ViewActionParameterSchema.forVersion("17")(z)).default([]),
+                scriptKey: KeyNullableSchema.forVersion("17")(z),
+                autoUpdate: z
+                    .union([z.literal(EAutoUpdateMode.NONE), z.literal(EAutoUpdateMode.ALL_VIEWS)])
+                    .default(EAutoUpdateMode.NONE),
+            });
+        },
+    },
+});
+var ActionSchema = SchemaRegistry.define({
+    key: "Action",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.union([
+                /* Изменение порядка схем связано с отсутствием strict
+                  Strict будет добавлен в BI-16355
+                */
+                WidgetActionSchema.forVersion("17")(z),
+                ActionsOnClickSchema.forVersion("17")(z),
+                ViewActionSchema.forVersion("17")(z),
+            ]);
+        },
+    },
+});
+var ActionButtonSchema = SchemaRegistry.define({
+    key: "ActionButton",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return extendWithMeta(AutoIdentifiedArrayItemSchema.forVersion("17")(z), {
+                name: z.string(),
+                onClick: z.array(WidgetActionSchema.forVersion("17")(z)).default([]),
+                buttonType: z.enum(zodEnumLike(EActionButtonsTypes)).default(EActionButtonsTypes.BASE),
+                backgroundColor: ColorSchema.forVersion("17")(z),
+                borderColor: ColorSchema.forVersion("17")(z),
+                color: ColorSchema.forVersion("17")(z),
+                hint: z.string().default(""),
+            });
+        },
+    },
+});
+
+var ESimpleDataType = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            OTHER: "OTHER",
+            DATE: "DATE",
+            FLOAT: "FLOAT",
+            DATETIME: "DATETIME",
+            STRING: "STRING",
+            INTEGER: "INTEGER",
+            DATETIME64: "DATETIME64",
+            BOOLEAN: "BOOLEAN",
+        },
+    },
+});
+
+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 = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            EQUAL_TO: "EQUAL_TO",
+            NOT_EQUAL_TO: "NOT_EQUAL_TO",
+            GREATER_THAN: "GREATER_THAN",
+            LESS_THAN: "LESS_THAN",
+            GREATER_THAN_OR_EQUAL_TO: "GREATER_THAN_OR_EQUAL_TO",
+            LESS_THAN_OR_EQUAL_TO: "LESS_THAN_OR_EQUAL_TO",
+            STARTS_WITH: "STARTS_WITH",
+            ENDS_WITH: "ENDS_WITH",
+            CONTAINS: "CONTAINS",
+            NOT_CONTAINS: "NOT_CONTAINS",
+            IN_RANGE: "IN_RANGE",
+            NOT_IN_RANGE: "NOT_IN_RANGE",
+            INCLUDE: "INCLUDE",
+            EXCLUDE: "EXCLUDE",
+            NONEMPTY: "NONEMPTY",
+            EMPTY: "EMPTY",
+        },
+    },
+});
+
+var formulaFilterMethods = __assign(__assign({}, Object.fromEntries(Object.entries(ECalculatorFilterMethods).map(function (_a) {
+    var _b = __read(_a, 2), k = _b[0], v = _b[1];
+    return [k, v];
+}))), { LAST_TIME: "LAST_TIME" });
+var EProcessFilterNames = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Наличие события */
+            presenceOfEvent: "presenceOfEvent",
+            /** Количество повторов события */
+            repetitionOfEvent: "repetitionOfEvent",
+            /** Наличие перехода */
+            presenceOfTransition: "presenceOfTransition",
+            /** Длительность перехода */
+            durationOfTransition: "durationOfTransition",
+        },
+    },
+});
+var EFormulaFilterFieldKeys = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            date: "date",
+            dateRange: "dateRange",
+            numberRange: "numberRange",
+            string: "string",
+            lastTimeValue: "lastTimeValue",
+            lastTimeUnit: "lastTimeUnit",
+            durationUnit: "durationUnit",
+        },
+    },
+});
+var EDimensionProcessFilterTimeUnit = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            YEARS: "YEARS",
+            MONTHS: "MONTHS",
+            HOURS: "HOURS",
+            DAYS: "DAYS",
+            MINUTES: "MINUTES",
+        },
+    },
+});
+var isFormulaFilterValue = function (value) {
+    return "filteringMethod" in value;
+};
+var isDimensionProcessFilter = function (filter) { return "value" in filter && "condition" in filter; };
+
+var EClickHouseBaseTypes = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            // DATE
+            Date: "Date",
+            Date32: "Date32",
+            // DATETIME
+            DateTime: "DateTime",
+            DateTime32: "DateTime32",
+            // DATETIME64
+            DateTime64: "DateTime64",
+            // STRING
+            FixedString: "FixedString",
+            String: "String",
+            // FLOAT
+            Decimal: "Decimal",
+            Decimal32: "Decimal32",
+            Decimal64: "Decimal64",
+            Decimal128: "Decimal128",
+            Decimal256: "Decimal256",
+            Float32: "Float32",
+            Float64: "Float64",
+            // INTEGER
+            Int8: "Int8",
+            Int16: "Int16",
+            Int32: "Int32",
+            Int64: "Int64",
+            Int128: "Int128",
+            Int256: "Int256",
+            UInt8: "UInt8",
+            UInt16: "UInt16",
+            UInt32: "UInt32",
+            UInt64: "UInt64",
+            UInt128: "UInt128",
+            UInt256: "UInt256",
+            // BOOLEAN
+            Bool: "Bool",
+        },
+    },
+});
+var stringTypes = ["String", "FixedString"];
+var parseClickHouseType = memoize(function (type) {
+    if (isNil(type)) {
+        return {
             simpleBaseType: ESimpleDataType.OTHER,
             dbBaseDataType: undefined,
             containers: [],
@@ -1489,35 +2328,39 @@ var isTypeParameters = function (stringifiedParameters) {
     return stringifiedParameters.split(", ").some(function (p) { return !Number.isNaN(Number(p)) || p.startsWith("'"); });
 };
 
-var _a$5;
-var EDimensionTemplateNames;
-(function (EDimensionTemplateNames) {
-    EDimensionTemplateNames["dateTime"] = "dateTime";
-    EDimensionTemplateNames["date"] = "date";
-    EDimensionTemplateNames["year"] = "year";
-    EDimensionTemplateNames["yearAndQuarter"] = "yearAndQuarter";
-    EDimensionTemplateNames["quarter"] = "quarter";
-    EDimensionTemplateNames["yearAndMonth"] = "yearAndMonth";
-    EDimensionTemplateNames["dayOfMonth"] = "dayOfMonth";
-    EDimensionTemplateNames["month"] = "month";
-    EDimensionTemplateNames["week"] = "week";
-    EDimensionTemplateNames["dayOfWeek"] = "dayOfWeek";
-    EDimensionTemplateNames["hour"] = "hour";
-})(EDimensionTemplateNames || (EDimensionTemplateNames = {}));
+var _a$6;
+var EDimensionTemplateNames = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            dateTime: "dateTime",
+            date: "date",
+            year: "year",
+            yearAndQuarter: "yearAndQuarter",
+            quarter: "quarter",
+            yearAndMonth: "yearAndMonth",
+            dayOfMonth: "dayOfMonth",
+            month: "month",
+            week: "week",
+            dayOfWeek: "dayOfWeek",
+            hour: "hour",
+        },
+    },
+});
 /** Стандартные шаблоны разреза */
-var dimensionTemplateFormulas = (_a$5 = {},
-    _a$5[EDimensionTemplateNames.dateTime] = "toDateTime({columnFormula})",
-    _a$5[EDimensionTemplateNames.date] = "toDate({columnFormula})",
-    _a$5[EDimensionTemplateNames.year] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}))",
-    _a$5[EDimensionTemplateNames.yearAndQuarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}) * 10 + toQuarter({columnFormula}))",
-    _a$5[EDimensionTemplateNames.quarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toQuarter({columnFormula}))",
-    _a$5[EDimensionTemplateNames.yearAndMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYYYYMM({columnFormula}))",
-    _a$5[EDimensionTemplateNames.month] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toMonth({columnFormula}))",
-    _a$5[EDimensionTemplateNames.dayOfMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfMonth({columnFormula}))",
-    _a$5[EDimensionTemplateNames.week] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toWeek({columnFormula}))",
-    _a$5[EDimensionTemplateNames.dayOfWeek] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfWeek({columnFormula}))",
-    _a$5[EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
-    _a$5);
+var dimensionTemplateFormulas = (_a$6 = {},
+    _a$6[EDimensionTemplateNames.dateTime] = "toDateTime({columnFormula})",
+    _a$6[EDimensionTemplateNames.date] = "toDate({columnFormula})",
+    _a$6[EDimensionTemplateNames.year] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}))",
+    _a$6[EDimensionTemplateNames.yearAndQuarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYear({columnFormula}) * 10 + toQuarter({columnFormula}))",
+    _a$6[EDimensionTemplateNames.quarter] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toQuarter({columnFormula}))",
+    _a$6[EDimensionTemplateNames.yearAndMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toYYYYMM({columnFormula}))",
+    _a$6[EDimensionTemplateNames.month] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toMonth({columnFormula}))",
+    _a$6[EDimensionTemplateNames.dayOfMonth] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfMonth({columnFormula}))",
+    _a$6[EDimensionTemplateNames.week] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toWeek({columnFormula}))",
+    _a$6[EDimensionTemplateNames.dayOfWeek] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toDayOfWeek({columnFormula}))",
+    _a$6[EDimensionTemplateNames.hour] = "if(defaultValueOfArgumentType({columnFormula}) = {columnFormula}, 0, toHour({columnFormula}))",
+    _a$6);
 
 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})");
@@ -1629,7 +2472,7 @@ var escapeCurlyBracketLinkName = createEscaper(Array.from("\\}.[]"));
 var parseIndicatorLink = function (formula) {
     var dashboardMatch = formula.match(dashboardLinkRegExp.source);
     if (dashboardMatch) {
-        return { scopeName: null, indicatorName: dashboardMatch[1] };
+        return { scopeName: null, indicatorName: unescapeSpecialCharacters(dashboardMatch[1]) };
     }
     var workspaceMatch = formula.match(workspaceLinkRegExp.source);
     if (workspaceMatch) {
@@ -1664,8 +2507,13 @@ var clearMultiLineComments = function (formula) {
     return formula.replace(/\/\*[\s\S]*?\*\//g, "");
 };
 
+var dateSimpleTypes = [
+    ESimpleDataType.DATE,
+    ESimpleDataType.DATETIME,
+    ESimpleDataType.DATETIME64,
+];
 function isDateSimpleType(simpleType) {
-    return [ESimpleDataType.DATE, ESimpleDataType.DATETIME, ESimpleDataType.DATETIME64].includes(simpleType);
+    return dateSimpleTypes.includes(simpleType);
 }
 var castToDateValue = function (simpleType) { return function (value) {
     return simpleType === ESimpleDataType.DATE ? "toDate('".concat(value, "')") : "toDateTime('".concat(value, "')");
@@ -1736,37 +2584,41 @@ var convertFiltersToFormula = function (filters) {
     return filters.length > 0 ? " AND ".concat(convertToFormulasChain(filters)) : "";
 };
 
-var _a$4;
-var EDimensionAggregationTemplateName;
-(function (EDimensionAggregationTemplateName) {
-    EDimensionAggregationTemplateName["avg"] = "avg";
-    EDimensionAggregationTemplateName["median"] = "median";
-    EDimensionAggregationTemplateName["count"] = "count";
-    EDimensionAggregationTemplateName["countDistinct"] = "countDistinct";
-    EDimensionAggregationTemplateName["min"] = "min";
-    EDimensionAggregationTemplateName["max"] = "max";
-    EDimensionAggregationTemplateName["sum"] = "sum";
-    EDimensionAggregationTemplateName["top"] = "top";
-    EDimensionAggregationTemplateName["firstValue"] = "firstValue";
-    EDimensionAggregationTemplateName["lastValue"] = "lastValue";
-    EDimensionAggregationTemplateName["countExecutions"] = "countExecutions";
-    EDimensionAggregationTemplateName["countReworks"] = "countReworks";
-})(EDimensionAggregationTemplateName || (EDimensionAggregationTemplateName = {}));
+var _a$5;
+var EDimensionAggregationTemplateName = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            avg: "avg",
+            median: "median",
+            count: "count",
+            countDistinct: "countDistinct",
+            min: "min",
+            max: "max",
+            sum: "sum",
+            top: "top",
+            firstValue: "firstValue",
+            lastValue: "lastValue",
+            countExecutions: "countExecutions",
+            countReworks: "countReworks",
+        },
+    },
+});
 /** Шаблоны процессных метрик разреза с режимом AGGREGATION */
-var dimensionAggregationTemplates = (_a$4 = {},
-    _a$4[EDimensionAggregationTemplateName.avg] = avgTemplate,
-    _a$4[EDimensionAggregationTemplateName.median] = medianTemplate,
-    _a$4[EDimensionAggregationTemplateName.count] = countTemplate,
-    _a$4[EDimensionAggregationTemplateName.countDistinct] = countDistinctTemplate,
-    _a$4[EDimensionAggregationTemplateName.min] = minTemplate,
-    _a$4[EDimensionAggregationTemplateName.max] = maxTemplate,
-    _a$4[EDimensionAggregationTemplateName.sum] = sumTemplate,
-    _a$4[EDimensionAggregationTemplateName.top] = topTemplate,
-    _a$4[EDimensionAggregationTemplateName.firstValue] = firstValueTemplate,
-    _a$4[EDimensionAggregationTemplateName.lastValue] = lastValueTemplate,
-    _a$4[EDimensionAggregationTemplateName.countExecutions] = countExecutionsTemplate,
-    _a$4[EDimensionAggregationTemplateName.countReworks] = countReworksTemplate,
-    _a$4);
+var dimensionAggregationTemplates = (_a$5 = {},
+    _a$5[EDimensionAggregationTemplateName.avg] = avgTemplate,
+    _a$5[EDimensionAggregationTemplateName.median] = medianTemplate,
+    _a$5[EDimensionAggregationTemplateName.count] = countTemplate,
+    _a$5[EDimensionAggregationTemplateName.countDistinct] = countDistinctTemplate,
+    _a$5[EDimensionAggregationTemplateName.min] = minTemplate,
+    _a$5[EDimensionAggregationTemplateName.max] = maxTemplate,
+    _a$5[EDimensionAggregationTemplateName.sum] = sumTemplate,
+    _a$5[EDimensionAggregationTemplateName.top] = topTemplate,
+    _a$5[EDimensionAggregationTemplateName.firstValue] = firstValueTemplate,
+    _a$5[EDimensionAggregationTemplateName.lastValue] = lastValueTemplate,
+    _a$5[EDimensionAggregationTemplateName.countExecutions] = countExecutionsTemplate,
+    _a$5[EDimensionAggregationTemplateName.countReworks] = countReworksTemplate,
+    _a$5);
 /** На основе значения режима AGGREGATION подготовить параметры для подстановки в шаблонную формулу */
 var prepareDimensionAggregationParams = function (value) {
     if (!value.eventName ||
@@ -1883,21 +2735,26 @@ function getProcessDimensionValueFormula(value) {
     }
 }
 
-var EMeasureAggregationTemplateName;
-(function (EMeasureAggregationTemplateName) {
-    EMeasureAggregationTemplateName["agvIf"] = "agvIf";
-    EMeasureAggregationTemplateName["medianIf"] = "medianIf";
-    EMeasureAggregationTemplateName["countIf"] = "countIf";
-    EMeasureAggregationTemplateName["countIfDistinct"] = "countIfDistinct";
-    EMeasureAggregationTemplateName["minIf"] = "minIf";
-    EMeasureAggregationTemplateName["maxIf"] = "maxIf";
-    EMeasureAggregationTemplateName["sumIf"] = "sumIf";
-    EMeasureAggregationTemplateName["top"] = "top";
-    EMeasureAggregationTemplateName["firstValue"] = "firstValue";
-    EMeasureAggregationTemplateName["lastValue"] = "lastValue";
-    EMeasureAggregationTemplateName["countExecutions"] = "countExecutions";
-    EMeasureAggregationTemplateName["countReworks"] = "countReworks";
-})(EMeasureAggregationTemplateName || (EMeasureAggregationTemplateName = {}));
+var EMeasureAggregationTemplateName = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            agvIf: "agvIf",
+            medianIf: "medianIf",
+            countIf: "countIf",
+            countIfDistinct: "countIfDistinct",
+            minIf: "minIf",
+            maxIf: "maxIf",
+            sumIf: "sumIf",
+            anyIf: "anyIf",
+            top: "top",
+            firstValue: "firstValue",
+            lastValue: "lastValue",
+            countExecutions: "countExecutions",
+            countReworks: "countReworks",
+        },
+    },
+});
 /** На основе значения режима AGGREGATION подготовить параметры для подстановки в шаблонную формулу */
 var prepareMeasureAggregationParams = function (value) {
     if ((!value.anyEvent && !value.eventName) ||
@@ -1933,32 +2790,42 @@ var prepareMeasureAggregationParams = function (value) {
     return columnParams;
 };
 
-var _a$3, _b;
-var EMeasureTemplateNames;
-(function (EMeasureTemplateNames) {
-    EMeasureTemplateNames["avg"] = "avg";
-    EMeasureTemplateNames["median"] = "median";
-    EMeasureTemplateNames["count"] = "count";
-    EMeasureTemplateNames["countDistinct"] = "countDistinct";
-    EMeasureTemplateNames["min"] = "min";
-    EMeasureTemplateNames["max"] = "max";
-    EMeasureTemplateNames["sum"] = "sum";
-})(EMeasureTemplateNames || (EMeasureTemplateNames = {}));
-var EMeasureInnerTemplateNames;
-(function (EMeasureInnerTemplateNames) {
-    EMeasureInnerTemplateNames["begin"] = "begin";
-    EMeasureInnerTemplateNames["end"] = "end";
-})(EMeasureInnerTemplateNames || (EMeasureInnerTemplateNames = {}));
+var _a$4, _b;
+var EMeasureTemplateNames = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            avg: "avg",
+            median: "median",
+            count: "count",
+            countDistinct: "countDistinct",
+            min: "min",
+            max: "max",
+            sum: "sum",
+            any: "any",
+        },
+    },
+});
+var EMeasureInnerTemplateNames = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            begin: "begin",
+            end: "end",
+        },
+    },
+});
 /** Стандартные шаблоны меры */
-var measureTemplateFormulas = (_a$3 = {},
-    _a$3[EMeasureTemplateNames.avg] = "avg({columnFormula})",
-    _a$3[EMeasureTemplateNames.count] = "count({columnFormula})",
-    _a$3[EMeasureTemplateNames.countDistinct] = "count(distinct {columnFormula})",
-    _a$3[EMeasureTemplateNames.median] = "medianExact({columnFormula})",
-    _a$3[EMeasureTemplateNames.min] = "min({columnFormula})",
-    _a$3[EMeasureTemplateNames.max] = "max({columnFormula})",
-    _a$3[EMeasureTemplateNames.sum] = "sum({columnFormula})",
-    _a$3);
+var measureTemplateFormulas = (_a$4 = {},
+    _a$4[EMeasureTemplateNames.avg] = "avg({columnFormula})",
+    _a$4[EMeasureTemplateNames.count] = "count({columnFormula})",
+    _a$4[EMeasureTemplateNames.countDistinct] = "count(distinct {columnFormula})",
+    _a$4[EMeasureTemplateNames.median] = "medianExact({columnFormula})",
+    _a$4[EMeasureTemplateNames.min] = "min({columnFormula})",
+    _a$4[EMeasureTemplateNames.max] = "max({columnFormula})",
+    _a$4[EMeasureTemplateNames.sum] = "sum({columnFormula})",
+    _a$4[EMeasureTemplateNames.any] = "any({columnFormula})",
+    _a$4);
 var measureInnerTemplateFormulas = (_b = {},
     _b[EMeasureInnerTemplateNames.begin] = "begin({columnFormula})",
     _b[EMeasureInnerTemplateNames.end] = "end({columnFormula})",
@@ -2076,6 +2943,10 @@ function createAggregationTemplate(templateName, _a) {
             return anyEvent
                 ? createAnyEventTemplate("sum({columnFormula})")
                 : createSpecificEventTemplate("sumIf");
+        case EMeasureAggregationTemplateName.anyIf:
+            return anyEvent
+                ? createAnyEventTemplate("any({columnFormula})")
+                : createSpecificEventTemplate("anyIf");
         case EMeasureAggregationTemplateName.top:
             return anyEvent
                 ? createAnyEventTemplate("topK(1)({columnFormula})[1]")
@@ -2145,16 +3016,20 @@ function getMeasureFormula(_a) {
     return "";
 }
 
-var _a$2;
-var EEventMeasureTemplateNames;
-(function (EEventMeasureTemplateNames) {
-    EEventMeasureTemplateNames["eventsCount"] = "eventsCount";
-    EEventMeasureTemplateNames["reworksCount"] = "reworksCount";
-})(EEventMeasureTemplateNames || (EEventMeasureTemplateNames = {}));
-var eventMeasureTemplateFormulas = (_a$2 = {},
-    _a$2[EEventMeasureTemplateNames.eventsCount] = "count()",
-    _a$2[EEventMeasureTemplateNames.reworksCount] = "count() - uniqExact({caseCaseIdFormula})",
-    _a$2);
+var _a$3;
+var EEventMeasureTemplateNames = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            eventsCount: "eventsCount",
+            reworksCount: "reworksCount",
+        },
+    },
+});
+var eventMeasureTemplateFormulas = (_a$3 = {},
+    _a$3[EEventMeasureTemplateNames.eventsCount] = "count()",
+    _a$3[EEventMeasureTemplateNames.reworksCount] = "count() - uniqExact({caseCaseIdFormula})",
+    _a$3);
 
 function getEventMeasureFormula(_a, process) {
     var value = _a.value;
@@ -2171,16 +3046,20 @@ function getEventMeasureFormula(_a, process) {
     return "";
 }
 
-var _a$1;
-var ETransitionMeasureTemplateNames;
-(function (ETransitionMeasureTemplateNames) {
-    ETransitionMeasureTemplateNames["transitionsCount"] = "transitionsCount";
-    ETransitionMeasureTemplateNames["medianTime"] = "medianTime";
-})(ETransitionMeasureTemplateNames || (ETransitionMeasureTemplateNames = {}));
-var transitionMeasureTemplateFormulas = (_a$1 = {},
-    _a$1[ETransitionMeasureTemplateNames.transitionsCount] = "count()",
-    _a$1[ETransitionMeasureTemplateNames.medianTime] = "medianExact(date_diff(second, begin({eventTimeFormula}), end({eventTimeFormula})))",
-    _a$1);
+var _a$2;
+var ETransitionMeasureTemplateNames = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            transitionsCount: "transitionsCount",
+            medianTime: "medianTime",
+        },
+    },
+});
+var transitionMeasureTemplateFormulas = (_a$2 = {},
+    _a$2[ETransitionMeasureTemplateNames.transitionsCount] = "count()",
+    _a$2[ETransitionMeasureTemplateNames.medianTime] = "medianExact(date_diff(second, begin({eventTimeFormula}), end({eventTimeFormula})))",
+    _a$2);
 
 function getTransitionMeasureFormula(_a, process) {
     var value = _a.value;
@@ -2220,34 +3099,47 @@ var replaceDisplayCondition = function (dimension, displayCondition) {
     return isNil(displayCondition) ? dimension : __assign(__assign({}, dimension), { displayCondition: displayCondition });
 };
 /**
- * Шаблон формулы для проверки условия отображения.
+ * Шаблон формулы для приведения произвольного выражения к Boolean.
+ * Используется и для display-condition виджетов/вкладок/инпутов,
+ * и для фильтров по формуле.
+ *
+ * NULL отсекается явной проверкой isNotNull (трактуется как false).
+ * Остальные непреобразуемые к Boolean значения подпадают под дефолт true.
  *
+ * - null -> false (явная проверка isNotNull)
  * - 0 -> false
  * - 1 -> true
  * - 15 -> true
- * - '0' ->	false
+ * - '0' -> false
  * - '1' -> true
- * - '15' ->	true (значение по умолчанию, т.к. не преобразуется к Boolean)
+ * - '15' -> true (значение по умолчанию, т.к. не преобразуется к Boolean)
  * - 'false' -> false
  * - 'true' -> true
  * - 'abc' -> true (значение по умолчанию, т.к. не преобразуется к Boolean)
- * - null -> true (значение по умолчанию, т.к. не преобразуется к Boolean)
  */
-var displayConditionTemplate = "accurateCastOrDefault({formula}, 'Boolean', true)";
-
-var ELastTimeUnit;
-(function (ELastTimeUnit) {
-    ELastTimeUnit["DAYS"] = "DAYS";
-    ELastTimeUnit["MONTHS"] = "MONTHS";
-    ELastTimeUnit["YEARS"] = "YEARS";
-})(ELastTimeUnit || (ELastTimeUnit = {}));
-var EDurationUnit;
-(function (EDurationUnit) {
-    EDurationUnit["DAYS"] = "DAYS";
-    EDurationUnit["HOURS"] = "HOURS";
-    EDurationUnit["MINUTES"] = "MINUTES";
-    EDurationUnit["SECONDS"] = "SECONDS";
-})(EDurationUnit || (EDurationUnit = {}));
+var displayConditionTemplate = "isNotNull({formula}) AND accurateCastOrDefault({formula}, 'Boolean', true)";
+
+var ELastTimeUnit = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            DAYS: "DAYS",
+            MONTHS: "MONTHS",
+            YEARS: "YEARS",
+        },
+    },
+});
+var EDurationUnit = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            DAYS: "DAYS",
+            HOURS: "HOURS",
+            MINUTES: "MINUTES",
+            SECONDS: "SECONDS",
+        },
+    },
+});
 var isRangeFilteringMethod = function (filteringMethod) {
     return filteringMethod === formulaFilterMethods.IN_RANGE ||
         filteringMethod === formulaFilterMethods.NOT_IN_RANGE;
@@ -2312,7 +3204,7 @@ var getFormulaFilterValues = function (filterValue) {
         });
     }
     function convertDurationRangeToSecond(range, rangeUnit) {
-        if (range === void 0) { range = [undefined, undefined]; }
+        if (range === void 0) { range = [null, null]; }
         return range.map(function (value, index) {
             if (isNil(value)) {
                 return String(index === 0 ? -Infinity : Infinity);
@@ -2397,14 +3289,14 @@ var mapFormulaFiltersToInputs = function (filters) {
     return compactMap(filters, mapFormulaFilterToCalculatorInput);
 };
 
-var _a;
-var intervalByUnit = (_a = {},
-    _a[EDimensionProcessFilterTimeUnit.YEARS] = "year",
-    _a[EDimensionProcessFilterTimeUnit.MONTHS] = "month",
-    _a[EDimensionProcessFilterTimeUnit.DAYS] = "day",
-    _a[EDimensionProcessFilterTimeUnit.HOURS] = "hour",
-    _a[EDimensionProcessFilterTimeUnit.MINUTES] = "minute",
-    _a);
+var _a$1;
+var intervalByUnit = (_a$1 = {},
+    _a$1[EDimensionProcessFilterTimeUnit.YEARS] = "year",
+    _a$1[EDimensionProcessFilterTimeUnit.MONTHS] = "month",
+    _a$1[EDimensionProcessFilterTimeUnit.DAYS] = "day",
+    _a$1[EDimensionProcessFilterTimeUnit.HOURS] = "hour",
+    _a$1[EDimensionProcessFilterTimeUnit.MINUTES] = "minute",
+    _a$1);
 function mapDimensionProcessFilterToCalculatorInput(filter) {
     var formula = filter.value.mode === EWidgetIndicatorValueModes.FORMULA
         ? filter.value.formula
@@ -2459,8 +3351,158 @@ function mapMeasuresToInputs(measures, variables, addFormulas) {
     return compactMap(measures, function (measure) { return mapMeasureToInput(measure, variables, addFormulas); });
 }
 
+var isFormulaWithSliceGuard = function (value) {
+    return "filteringMethod" in value && "formula" in value;
+};
+function isNestingDimension(indicator) {
+    return (!isDimensionsHierarchy(indicator) &&
+        parseClickHouseType(indicator.dbDataType).containers.includes("Array"));
+}
+function findMatchedFilter(filterValues, dimension) {
+    var dimensionFormula = getDimensionFormula(dimension);
+    return filterValues.findLast(function (filterValue) {
+        if (!isFormulaWithSliceGuard(filterValue)) {
+            return false;
+        }
+        var isFormulaMatched = filterValue.formula === dimensionFormula;
+        if (dimension.arrayNesting) {
+            return isFormulaMatched && filterValue.sliceIndex;
+        }
+        return isFormulaMatched;
+    });
+}
+function calculateSelectionIndex(dimension, hierarchyDimensions, index, dimensionMaxNestingMap, filterSliceIndex) {
+    var correctIndex = index + 1;
+    if (filterSliceIndex) {
+        var maxNestingDepth = Number(dimensionMaxNestingMap === null || dimensionMaxNestingMap === void 0 ? void 0 : dimensionMaxNestingMap.get(String(dimension.id))) || 0;
+        var isBelowMaxDepth = filterSliceIndex < maxNestingDepth;
+        var isNestingPending = dimension.arrayNesting && !dimensionMaxNestingMap;
+        correctIndex = isBelowMaxDepth || isNestingPending ? index : index + 1;
+    }
+    return Math.min(correctIndex, hierarchyDimensions.length - 1);
+}
+var minNestingIndex = 1;
+function getDimensionSliceIndex(dimensionMaxNestingMap, filterSliceIndex, checkedValuesLength, dimensionId) {
+    if (!filterSliceIndex) {
+        return minNestingIndex;
+    }
+    var maxNestingDepth = typeof dimensionId === "number" && Number(dimensionMaxNestingMap === null || dimensionMaxNestingMap === void 0 ? void 0 : dimensionMaxNestingMap.get(String(dimensionId)));
+    var isFilterSliceIndexMaxNesting = filterSliceIndex && maxNestingDepth && filterSliceIndex >= maxNestingDepth;
+    if (!dimensionMaxNestingMap || checkedValuesLength > 1 || isFilterSliceIndexMaxNesting) {
+        return filterSliceIndex;
+    }
+    if (checkedValuesLength === 1) {
+        return filterSliceIndex + 1;
+    }
+    return minNestingIndex;
+}
+function getSlicedDimension(dimension, sliceIndex) {
+    return __assign(__assign({}, dimension), { sliceIndex: sliceIndex });
+}
+function selectSlicedDimensionFromHierarchy(hierarchy, widgetFilterValues, dimensionMaxNestingMap) {
+    var _a;
+    var hierarchyDimensions = hierarchy.hierarchyDimensions;
+    for (var i = hierarchyDimensions.length - 1; i >= 0; i--) {
+        var dimension = hierarchyDimensions[i];
+        if (!dimension) {
+            continue;
+        }
+        var displayedDimension = inheritDisplayConditionFromHierarchy(dimension, hierarchy);
+        var matchedFilter = findMatchedFilter(widgetFilterValues, displayedDimension);
+        if (!matchedFilter || !isFormulaWithSliceGuard(matchedFilter)) {
+            continue;
+        }
+        var checkedValuesLength = (_a = matchedFilter.checkedValues) === null || _a === void 0 ? void 0 : _a.length;
+        if (checkedValuesLength === undefined) {
+            continue;
+        }
+        var filterSliceIndex = matchedFilter.sliceIndex;
+        var selectionIndex = checkedValuesLength > 1
+            ? i
+            : calculateSelectionIndex(displayedDimension, hierarchyDimensions, i, dimensionMaxNestingMap, filterSliceIndex);
+        var currentDimension = hierarchyDimensions[selectionIndex];
+        if (!currentDimension) {
+            continue;
+        }
+        var displayedCurrentDimension = inheritDisplayConditionFromHierarchy(currentDimension, hierarchy);
+        var dimensionSliceIndex = (displayedCurrentDimension === null || displayedCurrentDimension === void 0 ? void 0 : displayedCurrentDimension.arrayNesting)
+            ? getDimensionSliceIndex(dimensionMaxNestingMap, displayedDimension.id === (displayedCurrentDimension === null || displayedCurrentDimension === void 0 ? void 0 : displayedCurrentDimension.id) ? filterSliceIndex : undefined, checkedValuesLength, displayedCurrentDimension === null || displayedCurrentDimension === void 0 ? void 0 : displayedCurrentDimension.id)
+            : undefined;
+        return getSlicedDimension(displayedCurrentDimension, dimensionSliceIndex);
+    }
+    var activeDimension = hierarchyDimensions.at(0);
+    if (!activeDimension) {
+        return;
+    }
+    var displayedActiveDimension = inheritDisplayConditionFromHierarchy(activeDimension, hierarchy);
+    var sliceIndex = (displayedActiveDimension === null || displayedActiveDimension === void 0 ? void 0 : displayedActiveDimension.arrayNesting) ? minNestingIndex : undefined;
+    return getSlicedDimension(displayedActiveDimension, sliceIndex);
+}
+function getSlicedDimensionByFilters(dimension, widgetFilters, dimensionMaxNestingMap) {
+    var _a, _b;
+    if (!dimension.arrayNesting) {
+        return dimension;
+    }
+    var matchedFilter = findMatchedFilter(widgetFilters, dimension);
+    if (!matchedFilter || !isFormulaWithSliceGuard(matchedFilter)) {
+        return getSlicedDimension(dimension, 1);
+    }
+    var dimensionSliceIndex = getDimensionSliceIndex(dimensionMaxNestingMap, matchedFilter.sliceIndex, (_b = (_a = matchedFilter.checkedValues) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0, dimension.id);
+    return getSlicedDimension(dimension, dimensionSliceIndex);
+}
+var getSlicedDimensionFormula = function (dimension) {
+    var dimensionFormula = getDimensionFormula(dimension);
+    var slicedDimensionFormula = dimension.sliceIndex
+        ? applyIndexToArrayFormula(dimensionFormula, dimension.sliceIndex)
+        : dimensionFormula;
+    return { slicedDimensionFormula: slicedDimensionFormula, dimensionFormula: dimensionFormula };
+};
+var replaceHierarchiesWithSlicedDimension = function (dimension, widgetFilters, dimensionMaxNestingMap) {
+    if (isDimensionsHierarchy(dimension)) {
+        var slicedDimension = selectSlicedDimensionFromHierarchy(dimension, widgetFilters, dimensionMaxNestingMap);
+        if (!slicedDimension) {
+            return;
+        }
+        var displayedIndicator = __assign(__assign({}, slicedDimension), { displayCondition: dimension.displayCondition });
+        return getSlicedDimension(displayedIndicator, slicedDimension === null || slicedDimension === void 0 ? void 0 : slicedDimension.sliceIndex);
+    }
+    return getSlicedDimensionByFilters(dimension, widgetFilters, dimensionMaxNestingMap);
+};
+var replaceHierarchiesWithSlicedDimensions = function (dimensions, widgetFilters, dimensionMaxNestingMap) {
+    return compactMap(dimensions, function (dimension) {
+        return replaceHierarchiesWithSlicedDimension(dimension, widgetFilters, dimensionMaxNestingMap);
+    });
+};
+var findDimensionsForNestingQuery = function (dimensions, widgetFilters) {
+    var slicedDimensions = replaceHierarchiesWithSlicedDimensions(dimensions, widgetFilters);
+    return slicedDimensions.filter(function (dimension) {
+        var _a, _b;
+        if (!(dimension === null || dimension === void 0 ? void 0 : dimension.arrayNesting)) {
+            return false;
+        }
+        var dimensionFormula = getDimensionFormula(dimension);
+        var lastFilterByDimension = widgetFilters.findLast(function (filterValue) {
+            if (!isFormulaWithSliceGuard(filterValue) || !filterValue.sliceIndex) {
+                return false;
+            }
+            return (filterValue.formula === dimensionFormula && dimension.sliceIndex === filterValue.sliceIndex);
+        });
+        if (!lastFilterByDimension || !isFormulaWithSliceGuard(lastFilterByDimension)) {
+            return false;
+        }
+        var filterSliceIndex = lastFilterByDimension.sliceIndex;
+        var selectedFilterValues = (_b = (_a = lastFilterByDimension.checkedValues) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        if (!filterSliceIndex || selectedFilterValues !== 1) {
+            return false;
+        }
+        return true;
+    });
+};
+
 function mapDimensionToInput(dimension, variables) {
-    var formula = getDimensionFormula(dimension);
+    var formula = dimension.sliceIndex !== undefined
+        ? getSlicedDimensionFormula(dimension).slicedDimensionFormula
+        : getDimensionFormula(dimension);
     if (!formula) {
         return null;
     }
@@ -2528,13 +3570,26 @@ function mapEventMeasuresToInputs(indicators, process, variables, addFormulas) {
     });
 }
 
-var ESortDirection;
-(function (ESortDirection) {
-    ESortDirection["descend"] = "DESC";
-    ESortDirection["ascend"] = "ASC";
-    ESortDirection["ASC"] = "ascend";
-    ESortDirection["DESC"] = "descend";
-})(ESortDirection || (ESortDirection = {}));
+var ESortDirection = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            descend: "DESC",
+            ascend: "ASC",
+            ASC: "ascend",
+            DESC: "descend",
+        },
+    },
+});
+var ESortingMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            BY_VALUES: "BY_VALUES",
+            FORMULA: "FORMULA",
+        },
+    },
+});
 
 /**
  * Выбрать активный разрез иерархии на основе активных фильтров.
@@ -2543,7 +3598,7 @@ var ESortDirection;
  * Если к разрезу иерархии применяется INCLUDE-фильтр с несколькими значениями - выбираем данный разрез
  */
 function selectDimensionFromHierarchy(hierarchy, filters) {
-    var hierarchyDimensions = hierarchy.hierarchyDimensions; hierarchy.displayCondition;
+    var hierarchyDimensions = hierarchy.hierarchyDimensions;
     var _loop_1 = function (i) {
         var dimension = hierarchyDimensions[i];
         // todo: widgets - возможно, стоит использовать Map фильтров для быстрого поиска
@@ -2628,9 +3683,9 @@ var getDefaultSortOrders = function (_a) {
 };
 function mapSortingToInputs(_a) {
     var _b;
-    var settings = _a.settings, variables = _a.variables, filters = _a.filters, getIndicatorType = _a.getIndicatorType;
+    var settings = _a.settings, variables = _a.variables, filters = _a.filters, widgetFilters = _a.widgetFilters, getIndicatorType = _a.getIndicatorType, dimensionMaxNestingMap = _a.dimensionMaxNestingMap;
     var sortOrder = compactMap((_b = settings["sorting"]) !== null && _b !== void 0 ? _b : [], function (_a) {
-        var _b;
+        var _b, _c;
         var direction = _a.direction, value = _a.value;
         if (value.mode === ESortingValueModes.FORMULA) {
             return value.formula
@@ -2643,6 +3698,21 @@ function mapSortingToInputs(_a) {
             return;
         }
         if (getIndicatorType(value.group, indicator) === EWidgetIndicatorType.DIMENSION) {
+            if (dimensionMaxNestingMap !== undefined) {
+                var slicedDimension = replaceHierarchiesWithSlicedDimension(indicator, widgetFilters !== null && widgetFilters !== void 0 ? widgetFilters : [], dimensionMaxNestingMap);
+                if (!slicedDimension ||
+                    !checkDisplayCondition(slicedDimension.displayCondition, variables)) {
+                    return;
+                }
+                return {
+                    formula: getSlicedDimensionFormula(slicedDimension).slicedDimensionFormula,
+                    direction: direction,
+                    dbDataType: slicedDimension.dbDataType,
+                    displayCondition: ((_b = slicedDimension.displayCondition) === null || _b === void 0 ? void 0 : _b.mode) === EDisplayConditionMode.FORMULA
+                        ? slicedDimension.displayCondition.formula
+                        : undefined,
+                };
+            }
             var activeDimensions = (isDimensionsHierarchy(indicator)
                 ? selectDimensionFromHierarchy(indicator, filters)
                 : indicator);
@@ -2654,7 +3724,7 @@ function mapSortingToInputs(_a) {
                 formula: formula,
                 direction: direction,
                 dbDataType: activeDimensions.dbDataType,
-                displayCondition: ((_b = indicator.displayCondition) === null || _b === void 0 ? void 0 : _b.mode) === EDisplayConditionMode.FORMULA
+                displayCondition: ((_c = indicator.displayCondition) === null || _c === void 0 ? void 0 : _c.mode) === EDisplayConditionMode.FORMULA
                     ? indicator.displayCondition.formula
                     : undefined,
             };
@@ -2697,57 +3767,67 @@ function bindContentsWithIndicators(outputs, indicators) {
     return compactMap(indicators, function (indicator) { return bindContentWithIndicator(outputs, indicator); });
 }
 
-var EControlType;
-(function (EControlType) {
-    /** Ввод текста */
-    EControlType["input"] = "input";
-    /** Ввод текста с поддержкой шаблонной вставки сущностей */
-    EControlType["inputTemplate"] = "inputTemplate";
-    /** Ввод текста в формате markdown */
-    EControlType["inputMarkdown"] = "inputMarkdown";
-    /** Ввод числа */
-    EControlType["inputNumber"] = "inputNumber";
-    /** Выбор диапазона чисел */
-    EControlType["inputRange"] = "inputRange";
-    /** Ввод размера (число + единица измерения) */
-    EControlType["size"] = "size";
-    /** Выбор boolean значения через переключатель */
-    EControlType["switch"] = "switch";
-    /** Выбор варианта из выпадающего списка */
-    EControlType["select"] = "select";
-    /** Выбор одного из вариантов, представленных через иконки */
-    EControlType["radioIconGroup"] = "radioIconGroup";
-    /** Ввод значения показателя */
-    EControlType["formula"] = "formula";
-    /** Ввод формулы и ее типа */
-    EControlType["typedFormula"] = "typedFormula";
-    /** Выбор настроек форматирования */
-    EControlType["formatting"] = "formatting";
-    /** Ввод шаблона форматирования */
-    EControlType["formattingTemplate"] = "formattingTemplate";
-    /** Выбор действий по клику */
-    EControlType["actionOnClick"] = "actionOnClick";
-    /** Ввод фильтров */
-    EControlType["filter"] = "filter";
-    /** Ввод условия отображения */
-    EControlType["displayCondition"] = "displayCondition";
-    /** Ввод цвета */
-    EControlType["colorPicker"] = "colorPicker";
-    /** Отображение тегов с возможностью "провалиться" внутрь */
-    EControlType["tagSet"] = "tagSet";
-    /** Множественный выбор событий процесса */
-    EControlType["eventsPicker"] = "eventsPicker";
-    /**
-     * @deprecated используется только для виджета "Маршруты", будет перенесено на уровень виджета.
-     * Ввод цветов для событий процесса.
-     */
-    EControlType["eventsColor"] = "eventsColor";
-})(EControlType || (EControlType = {}));
-var EUnitMode;
-(function (EUnitMode) {
-    EUnitMode["PIXEL"] = "PIXEL";
-    EUnitMode["PERCENT"] = "PERCENT";
-})(EUnitMode || (EUnitMode = {}));
+var EControlType = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Ввод текста */
+            input: "input",
+            /** Ввод текста с поддержкой шаблонной вставки сущностей */
+            inputTemplate: "inputTemplate",
+            /** Ввод текста в формате markdown */
+            inputMarkdown: "inputMarkdown",
+            /** Ввод числа */
+            inputNumber: "inputNumber",
+            /** Выбор диапазона чисел */
+            inputRange: "inputRange",
+            /** Ввод размера (число + единица измерения) */
+            size: "size",
+            /** Выбор boolean значения через переключатель */
+            switch: "switch",
+            /** Выбор варианта из выпадающего списка */
+            select: "select",
+            /** Выбор одного из вариантов, представленных через иконки */
+            radioIconGroup: "radioIconGroup",
+            /** Ввод значения показателя */
+            formula: "formula",
+            /** Ввод формулы и ее типа */
+            typedFormula: "typedFormula",
+            /** Выбор настроек форматирования */
+            formatting: "formatting",
+            /** Ввод шаблона форматирования */
+            formattingTemplate: "formattingTemplate",
+            /** Выбор действий по клику */
+            actionOnClick: "actionOnClick",
+            /** Ввод фильтров */
+            filter: "filter",
+            /** Ввод условия отображения */
+            displayCondition: "displayCondition",
+            /** Ввод цвета */
+            colorPicker: "colorPicker",
+            /** Отображение тегов с возможностью "провалиться" внутрь */
+            tagSet: "tagSet",
+            /** Множественный выбор событий процесса */
+            eventsPicker: "eventsPicker",
+            /**
+             * @deprecated используется только для виджета "Маршруты", будет перенесено на уровень виджета.
+             * Ввод цветов для событий процесса.
+             */
+            eventsColor: "eventsColor",
+            /** Сортировка */
+            sorting: "sorting",
+        },
+    },
+});
+var EUnitMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            PIXEL: "PIXEL",
+            PERCENT: "PERCENT",
+        },
+    },
+});
 var defaultActionsConfig = {
     OPEN_URL: { availability: true },
     UPDATE_VARIABLE: { availability: true },
@@ -2755,24 +3835,56 @@ var defaultActionsConfig = {
     OPEN_VIEW: { availability: true },
 };
 
-var ESelectOptionTypes;
-(function (ESelectOptionTypes) {
-    ESelectOptionTypes["DIVIDER"] = "DIVIDER";
-    ESelectOptionTypes["SYSTEM"] = "SYSTEM";
-    ESelectOptionTypes["GROUP"] = "GROUP";
-    ESelectOptionTypes["BRANCH"] = "BRANCH";
-    ESelectOptionTypes["LEAF"] = "LEAF";
-})(ESelectOptionTypes || (ESelectOptionTypes = {}));
-var ECustomSelectTemplates;
-(function (ECustomSelectTemplates) {
-    ECustomSelectTemplates["FORMULA"] = "FORMULA";
-    ECustomSelectTemplates["DIMENSION_GROUPS"] = "DIMENSION_GROUPS";
-})(ECustomSelectTemplates || (ECustomSelectTemplates = {}));
+var _a;
+var availableFormatsBySimpleType = (_a = {},
+    _a[ESimpleDataType.OTHER] = [EFormatTypes.STRING],
+    _a[ESimpleDataType.STRING] = [EFormatTypes.STRING],
+    _a[ESimpleDataType.FLOAT] = [EFormatTypes.NUMBER, EFormatTypes.DURATION, EFormatTypes.PERCENT],
+    _a[ESimpleDataType.INTEGER] = [
+        EFormatTypes.NUMBER,
+        EFormatTypes.DURATION,
+        EFormatTypes.QUARTER_YEAR,
+        EFormatTypes.MONTH_YEAR,
+        EFormatTypes.MONTH,
+        EFormatTypes.DAY_OF_WEEK,
+        EFormatTypes.PERCENT,
+    ],
+    _a[ESimpleDataType.DATE] = [EFormatTypes.DATE],
+    _a[ESimpleDataType.DATETIME] = [EFormatTypes.DATETIME],
+    _a[ESimpleDataType.DATETIME64] = [EFormatTypes.DATETIME],
+    _a[ESimpleDataType.BOOLEAN] = [EFormatTypes.BOOLEAN],
+    _a);
+
+var ESelectOptionTypes = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            DIVIDER: "DIVIDER",
+            SYSTEM: "SYSTEM",
+            GROUP: "GROUP",
+            BRANCH: "BRANCH",
+            LEAF: "LEAF",
+        },
+    },
+});
+var ECustomSelectTemplates = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            FORMULA: "FORMULA",
+            DIMENSION_GROUPS: "DIMENSION_GROUPS",
+        },
+    },
+});
 //todo: заполнить в рамках BI-13985
-var ESystemRecordKey;
-(function (ESystemRecordKey) {
-    ESystemRecordKey["formatting"] = "formatting";
-})(ESystemRecordKey || (ESystemRecordKey = {}));
+var ESystemRecordKey = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            formatting: "formatting",
+        },
+    },
+});
 
 var findFilterByFormula = function (filters, formula) {
     var _a;
@@ -2822,80 +3934,47 @@ var updateSingleModeSelection = function (selection, formula, value) {
         replacedFilter: null,
     });
 };
-var replaceFiltersBySelection = function (filters, selection) {
+var isWidgetFilter = function (filter) {
+    return "filterValue" in filter;
+};
+var isCalculatorFilter = function (filter) { return "formula" in filter; };
+var getWidgetFilterFormula = function (_a) {
+    var filterValue = _a.filterValue, preparedFilterValue = _a.preparedFilterValue;
+    if (!("filteringMethod" in filterValue && "formula" in filterValue)) {
+        return preparedFilterValue.formula;
+    }
+    var formulaFilterValue = filterValue;
+    if (!formulaFilterValue.sliceIndex) {
+        return formulaFilterValue.formula;
+    }
+    return applyIndexToArrayFormula(formulaFilterValue.formula, formulaFilterValue.sliceIndex);
+};
+var mergeWidgetFilter = function (filter, replacedFilter) {
+    return __assign(__assign({}, filter), { preparedFilterValue: replacedFilter, filterValue: __assign(__assign(__assign({}, filter.filterValue), omit(replacedFilter, ["values"])), { checkedValues: replacedFilter.values }) });
+};
+function replaceFiltersBySelection(filters, selection) {
     return filters.reduce(function (acc, filter) {
         var _a;
-        var calculatorFilter = selection.has(filter.formula)
-            ? (_a = selection.get(filter.formula)) === null || _a === void 0 ? void 0 : _a.replacedFilter
+        var isFilterFromWidget = isWidgetFilter(filter);
+        var filterFormula = isFilterFromWidget ? getWidgetFilterFormula(filter) : filter.formula;
+        if (!filterFormula) {
+            return acc;
+        }
+        var currentFilter = selection.has(filterFormula)
+            ? (_a = selection.get(filterFormula)) === null || _a === void 0 ? void 0 : _a.replacedFilter
             : filter;
-        if (!calculatorFilter) {
+        if (!currentFilter) {
             return acc;
         }
-        acc.push(calculatorFilter);
+        var hasReplacedCalculatorForWidget = selection.has(filterFormula) && isFilterFromWidget && isCalculatorFilter(currentFilter);
+        var resolvedFilter = hasReplacedCalculatorForWidget
+            ? mergeWidgetFilter(filter, currentFilter)
+            : currentFilter;
+        acc.push(resolvedFilter);
         return acc;
     }, []);
-};
-
-var localization = null;
-var supportedLanguages = [Localization.Language.ru, Localization.Language.en];
-/**
- * Получает локализованный текст на основе переданного языка и объекта локализации.
- * @param {ELanguages} language - Текущий язык, на котором должен быть возвращен локализованный текст.
- * @param {L} locObj - Объект локализации, содержащий тексты на разных языках.
- * @param {P} [props] - Дополнительные параметры локализации.
- * @returns {string} - Локализованный текст для указанного языка.
- */
-var getLocalizedText = function (language, locObj, props) {
-    if (!localization || localization.getLanguage() !== language) {
-        var isSupportLanguage = supportedLanguages.includes(language);
-        !isSupportLanguage &&
-            console.error("An unsupported \"".concat(language, "\" language has been passed. The default language is English"));
-        var lang = isSupportLanguage ? language : Localization.Language.en;
-        localization = new Localization({ language: lang });
-    }
-    return localization.getLocalized(locObj, props);
-};
+}
 
-var EColorMode;
-(function (EColorMode) {
-    /** Окрашивание отключено */
-    EColorMode["DISABLED"] = "DISABLED";
-    /** Цвет каждого значения вычисляется по формуле */
-    EColorMode["FORMULA"] = "FORMULA";
-    /** Один цвет для всех значений */
-    EColorMode["BASE"] = "BASE";
-    /** Окрашивание каждого значения по градиенту относительно минимального и максимального значений */
-    EColorMode["GRADIENT"] = "GRADIENT";
-    /** Использовать автоматический цвет: по умолчанию определяется порядковым номером показателя */
-    EColorMode["AUTO"] = "AUTO";
-    /** Использовать цвет из правила отображения (в правиле отображения рекурсивно определен цвет) */
-    EColorMode["RULE"] = "RULE";
-    /** Задать цвет конкретным значениям разреза */
-    EColorMode["VALUES"] = "VALUES";
-    /** Задать цвет конкретным значениям общего разреза. Режим используется только для настроек правила отображения */
-    EColorMode["BY_DIMENSION"] = "BY_DIMENSION";
-})(EColorMode || (EColorMode = {}));
-var getRuleColor = function (ruleFormula, globalContext) {
-    var _a, _b;
-    var link = parseIndicatorLink(ruleFormula);
-    if (!link) {
-        return;
-    }
-    var _c = link.scopeName, scopeName = _c === void 0 ? null : _c, ruleName = link.indicatorName;
-    var rulesByScope = isNil(scopeName)
-        ? globalContext.reportDisplayRules
-        : (_a = globalContext.workspaceDisplayRules) === null || _a === void 0 ? void 0 : _a.get(scopeName);
-    return (_b = rulesByScope === null || rulesByScope === void 0 ? void 0 : rulesByScope.get(ruleName)) === null || _b === void 0 ? void 0 : _b.color;
-};
-var isValidColor = function (color, globalContext) {
-    if (color.mode === EColorMode.RULE) {
-        return !color.formula || Boolean(getRuleColor(color.formula, globalContext));
-    }
-    if (color.mode === EColorMode.VALUES) {
-        return color.items.every(function (item) { return isValidColor(item.color, globalContext); });
-    }
-    return true;
-};
 var colors = [
     "#222F3E",
     "#00D2D3",
@@ -2928,6 +4007,54 @@ var colors = [
     "#BCC8D4",
     "#BA46AA",
 ];
+
+var EColorMode = VersionedEnum.build({
+    latestVersion: "17",
+    history: {
+        "17": {
+            /** Окрашивание отключено */
+            DISABLED: "DISABLED",
+            /** Цвет каждого значения вычисляется по формуле */
+            FORMULA: "FORMULA",
+            /** Один цвет для всех значений */
+            BASE: "BASE",
+            /** Окрашивание каждого значения по градиенту относительно минимального и максимального значений */
+            GRADIENT: "GRADIENT",
+            /** Использовать автоматический цвет: по умолчанию определяется порядковым номером показателя */
+            AUTO: "AUTO",
+            /** Использовать цвет из правила отображения (в правиле отображения рекурсивно определен цвет) */
+            RULE: "RULE",
+            /** Задать цвет конкретным значениям разреза */
+            VALUES: "VALUES",
+            /** Задать цвет конкретным значениям общего разреза. Режим используется только для настроек правила отображения */
+            BY_DIMENSION: "BY_DIMENSION",
+            /** Окрашивание по числовым диапазонам меры: colors[n] + limits[n-1] */
+            RANGES: "RANGES",
+        },
+    },
+});
+
+var getRuleColor = function (ruleFormula, globalContext) {
+    var _a, _b;
+    var link = parseIndicatorLink(ruleFormula);
+    if (!link) {
+        return;
+    }
+    var _c = link.scopeName, scopeName = _c === void 0 ? null : _c, ruleName = link.indicatorName;
+    var rulesByScope = isNil(scopeName)
+        ? globalContext.reportDisplayRules
+        : (_a = globalContext.workspaceDisplayRules) === null || _a === void 0 ? void 0 : _a.get(scopeName);
+    return (_b = rulesByScope === null || rulesByScope === void 0 ? void 0 : rulesByScope.get(ruleName)) === null || _b === void 0 ? void 0 : _b.color;
+};
+var isValidColor = function (color, globalContext) {
+    if (color.mode === EColorMode.RULE) {
+        return !color.formula || Boolean(getRuleColor(color.formula, globalContext));
+    }
+    if (color.mode === EColorMode.VALUES) {
+        return color.items.every(function (item) { return isValidColor(item.color, globalContext); });
+    }
+    return true;
+};
 /**
  * Получить цвет по индексу элемента
  * @param index - индекс элемента, которому требуется цвет
@@ -2942,22 +4069,245 @@ 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),
+var ColorBaseSchema = SchemaRegistry.define({
+    key: "ColorBase",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.BASE),
+                value: z.string(),
+            });
+        },
+    },
+});
+var ColorRuleSchema = SchemaRegistry.define({
+    key: "ColorRule",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.RULE),
+                // Здесь не нужна FormulaSchema, т.к. не требуется подстановка формулы
+                formula: z.string().default(""),
+            });
+        },
+    },
+});
+var ColorAutoSchema = SchemaRegistry.define({
+    key: "ColorAuto",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.AUTO),
+            });
+        },
+    },
+});
+var ColorDisabledSchema = SchemaRegistry.define({
+    key: "ColorDisabled",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.DISABLED),
+            });
+        },
+    },
+});
+var ColorGradientSchema = SchemaRegistry.define({
+    key: "ColorGradient",
+    latestVersion: "17",
+    history: {
+        "17": 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 = SchemaRegistry.define({
+    key: "ColorFormula",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.FORMULA),
+                formula: FormulaSchema.forVersion("17")(z),
+            });
+        },
+    },
+});
+var ColorValuesSchema = SchemaRegistry.define({
+    key: "ColorValues",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                mode: z.literal(EColorMode.VALUES),
+                items: z
+                    .array(z.object({
+                    value: z.string(),
+                    color: z.union([
+                        ColorBaseSchema.forVersion("17")(z),
+                        ColorRuleSchema.forVersion("17")(z),
+                    ]),
+                }))
+                    .default([]),
+            });
+        },
+    },
+});
+var ColorByDimensionSchema = SchemaRegistry.define({
+    key: "ColorByDimension",
+    latestVersion: "17",
+    history: {
+        "17": 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.forVersion("17")(z),
+                        ColorRuleSchema.forVersion("17")(z),
+                    ]),
+                }))
+                    .default([]),
+            });
+        },
+    },
+});
+var ColorRangesSchema = SchemaRegistry.define({
+    key: "ColorRanges",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .object({
+                mode: z.literal(EColorMode.RANGES),
+                colors: z.array(z.string()).default([]),
+                limits: z.array(z.number()).default([]),
+            })
+                .refine(function (_a) {
+                var colors = _a.colors, limits = _a.limits;
+                return limits.length === colors.length - 1;
+            }, {
+                path: ["limits"],
+                message: "limits.length должно быть равно colors.length - 1",
+            });
+        },
+    },
+});
+var ColoredValueSchema = SchemaRegistry.define({
+    key: "ColoredValue",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z.object({
+                value: z.string(),
+                color: z.union([ColorBaseSchema.forVersion("17")(z), ColorRuleSchema.forVersion("17")(z)]),
+            });
+        },
+    },
+});
+var ColorSchema = SchemaRegistry.define({
+    key: "Color",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return z
+                .discriminatedUnion("mode", [
+                ColorAutoSchema.forVersion("17")(z),
+                ColorDisabledSchema.forVersion("17")(z),
+                ColorBaseSchema.forVersion("17")(z),
+                ColorRuleSchema.forVersion("17")(z),
+                ColorGradientSchema.forVersion("17")(z),
+                ColorFormulaSchema.forVersion("17")(z),
+                ColorValuesSchema.forVersion("17")(z),
+                ColorByDimensionSchema.forVersion("17")(z),
+                ColorRangesSchema.forVersion("17")(z),
+            ])
+                .default({ mode: EColorMode.AUTO });
+        },
+    },
+});
+
+var hexToRgb = function (hex) {
+    if (hex.length === 0) {
+        return;
+    }
+    var rgbTuple = [0, 0, 0];
+    var matchArray = hex
+        .replace(/^#?([a-f\d])([a-f\d])([a-f\d])$/i, function (m, r, g, b) { return "#".concat(r).concat(r).concat(g).concat(g).concat(b).concat(b); })
+        .substring(1)
+        .match(/.{2}/g);
+    matchArray === null || matchArray === void 0 ? void 0 : matchArray.forEach(function (value, index) {
+        if (index > 2) {
+            return undefined;
+        }
+        rgbTuple[index] = parseInt(value, 16);
     });
+    return rgbTuple;
+};
+
+var rgbToHex = function (rgb) {
+    return "#".concat(rgb.map(function (x) { return x.toString(16).padStart(2, "0"); }).join(""));
+};
+
+var lerp = function (a, b, t) { return a + (b - a) * t; };
+/**
+ * Вычисляет промежуточный hex цвет между двумя цветами путем линейной интерполяции
+ * в RGB пространстве
+ *
+ * @param startHex цвет начала
+ * @param endHex цвет конца
+ * @param position позиция на градиенте от 0 до 1
+ */
+var interpolateHexColor = function (startHex, endHex, position) {
+    var clampedPosition = clamp(position, 0, 1);
+    var startRgb = hexToRgb(startHex);
+    var endRgb = hexToRgb(endHex);
+    if (!startRgb || !endRgb) {
+        throw new Error("\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0435 \u0446\u0432\u0435\u0442\u0430: start: ".concat(startHex, ", end: ").concat(endHex));
+    }
+    var interpolated = [
+        Math.round(lerp(startRgb[0], endRgb[0], clampedPosition)),
+        Math.round(lerp(startRgb[1], endRgb[1], clampedPosition)),
+        Math.round(lerp(startRgb[2], endRgb[2], clampedPosition)),
+    ];
+    return rgbToHex(interpolated);
 };
 
+/** @deprecated временно используется для миграции */
+var WidgetPresetSettingsSchema = SchemaRegistry.define({
+    key: "WidgetPresetSettings",
+    latestVersion: "17",
+    history: {
+        "17": function (z) {
+            return BaseWidgetSettingsSchema.forVersion("17")(z)
+                .pick({
+                filterMode: true,
+                ignoreFilters: true,
+                stateName: true,
+                titleColor: true,
+                titleSize: true,
+                titleWeight: true,
+                paddings: true,
+            })
+                .extend({
+                textSize: z.number().default(12),
+            });
+        },
+    },
+});
+
 /**
  * Привязывает мета-информацию о теме к Zod-схеме
  *
@@ -2981,79 +4331,4 @@ var themed = function (scheme, selectThemeValue) {
     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 };
+export { ActionButtonSchema, ActionDrillDownSchema, ActionGoToURLSchema, ActionOnClickParameterSchema, ActionOpenInSchema, ActionOpenViewSchema, ActionRunScriptSchema, ActionSchema, ActionUpdateVariableSchema, ActionsOnClickSchema, AutoIdentifiedArrayItemSchema, BaseWidgetSettingsSchema, ColorAutoSchema, ColorBaseSchema, ColorByDimensionSchema, ColorDisabledSchema, ColorFormulaSchema, ColorGradientSchema, ColorRangesSchema, 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, EExpectedFieldTypes, EFontWeight, EFormatOrFormattingMode, EFormulaFilterFieldKeys, EHeightMode, EIgnoreFilterMode, EIndicatorType, ELastTimeUnit, EMarkdownDisplayMode, EMeasureAggregationTemplateName, EMeasureInnerTemplateNames, EMeasureTemplateNames, EOuterAggregation, EProcessFilterNames, ESelectOptionTypes, ESettingsSchemaMetaKey, ESimpleDataType, ESimpleInputType, ESortDirection, ESortingMode, ESortingValueModes, ESystemRecordKey, ETransitionMeasureTemplateNames, EUnitMode, EViewMode, EViewOpenIn, EWidgetActionInputMethod, EWidgetFilterMode, EWidgetIgnoreFilterMode, EWidgetIndicatorType, EWidgetIndicatorValueModes, ExtendedFormulaFilterValueSchema, FormatSchema, FormattingSchema, FormulaFilterValueSchema, FormulaNullableSchema, FormulaSchema, KeyNullableSchema, MarkdownMeasureSchema, MeasureValueSchema, NameNullableSchema, OuterAggregation, ParameterFromAggregationSchema, ParameterFromColumnSchema, ParameterFromDataModelSchema, ParameterFromDynamicListSchema, ParameterFromEditableTextValueSchema, ParameterFromEndEventSchema, ParameterFromEventSchema, ParameterFromFormulaSchema, ParameterFromManualInputSchema, ParameterFromStartEventSchema, ParameterFromStaticListSchema, ParameterFromVariableSchema, ProcessIndicatorSchema, ProcessIndicatorValueSchema, RangeSchema, SchemaRegistryReader, SettingsFilterSchema, SortDirectionSchema, SortOrderSchema, SortingValueSchema, VersionedEnum, VersionedSchemaFactory, ViewActionParameterSchema, ViewActionSchema, WidgetActionParameterSchema, WidgetActionSchema, WidgetColumnIndicatorSchema, WidgetDimensionHierarchySchema, WidgetDimensionInHierarchySchema, WidgetDimensionSchema, WidgetFilterModeSchema, WidgetIgnoreFilterModeSchema, WidgetIndicatorAggregationValueSchema, WidgetIndicatorConversionValueSchema, WidgetIndicatorDurationValueSchema, WidgetIndicatorFormulaValueSchema, WidgetIndicatorSchema, WidgetIndicatorTemplateValueSchema, WidgetIndicatorTimeValueSchema, WidgetMeasureAggregationValueSchema, WidgetMeasureSchema, WidgetPresetSettingsSchema, WidgetSortingIndicatorSchema, WidgetSortingValueSchema, apiVersion, apiVersions, applyIndexToArrayFormula, availableFormatsBySimpleType, 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, extendWithMeta, fillTemplateSql, findDimensionsForNestingQuery, findMatchedFilter, formulaFilterMethods, generateColumnFormula, getColorByIndex, getDefaultSortOrders, getDimensionFormula, getDimensionSliceIndex, getDisplayConditionFormula, getEventMeasureFormula, getMeasureFormula, getParentMeta, getProcessDimensionValueFormula, getRuleColor, getSlicedDimension, getSlicedDimensionByFilters, getSlicedDimensionFormula, getTransitionMeasureFormula, hasInMetaChain, hexToRgb, inheritDisplayConditionFromHierarchy, interpolateHexColor, isDimensionProcessFilter, isDimensionsHierarchy, isFormulaFilterValue, isNestingDimension, isValidColor, mapDimensionToInput, mapDimensionsToInputs, mapEventMeasuresToInputs, mapFormulaFilterToCalculatorInput, mapFormulaFiltersToInputs, mapMeasuresToInputs, mapSettingsFiltersToInputs, mapSortingToInputs, mapTransitionMeasuresToInputs, measureInnerTemplateFormulas, measureTemplateFormulas, omitWithMeta, parseClickHouseType, parseIndicatorLink, prepareConversionParams, prepareDimensionAggregationParams, prepareDurationParams, prepareFormulaForSql, prepareMeasureAggregationParams, prepareSortOrders, prepareTimeParams, prepareValuesForSql, replaceDisplayCondition, replaceFiltersBySelection, replaceHierarchiesWithDimensions, replaceHierarchiesWithSlicedDimension, replaceHierarchiesWithSlicedDimensions, selectDimensionFromHierarchy, selectSlicedDimensionFromHierarchy, themed, timeTemplates, transitionMeasureTemplateFormulas, unescapeSpecialCharacters, updateDefaultModeSelection, updateSingleModeSelection, versionedEnumValues, workspaceLinkRegExp, zodEnumLike };