ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/containers/Tenant/utils/schemaActions.js

@@ -0,0 +1,104 @@
+import copy from 'copy-to-clipboard';
+import { changeUserInput } from '../../../store/reducers/executeQuery';
+import { setQueryTab, setTenantPage } from '../../../store/reducers/tenant/tenant';
+import { TENANT_QUERY_TABS_ID, TENANT_PAGES_IDS } from '../../../store/reducers/tenant/constants';
+import createToast from '../../../utils/createToast';
+import i18n from '../i18n';
+import { alterTableTemplate, alterTopicTemplate, createExternalTableTemplate, createTableTemplate, createTopicTemplate, dropExternalTableTemplate, dropTopicTemplate, selectQueryTemplate, upsertQueryTemplate, } from './queryTemplates';
+const bindActions = (path, dispatch, additionalEffects) => {
+    const { setActivePath, setQueryMode } = additionalEffects;
+    const inputQuery = (tmpl, mode) => () => {
+        if (mode) {
+            setQueryMode(mode);
+        }
+        dispatch(changeUserInput({ input: tmpl(path) }));
+        dispatch(setTenantPage(TENANT_PAGES_IDS.query));
+        dispatch(setQueryTab(TENANT_QUERY_TABS_ID.newQuery));
+        setActivePath(path);
+    };
+    return {
+        createTable: inputQuery(createTableTemplate, 'script'),
+        alterTable: inputQuery(alterTableTemplate, 'script'),
+        selectQuery: inputQuery(selectQueryTemplate),
+        upsertQuery: inputQuery(upsertQueryTemplate),
+        createExternalTable: inputQuery(createExternalTableTemplate, 'script'),
+        dropExternalTable: inputQuery(dropExternalTableTemplate, 'script'),
+        selectQueryFromExternalTable: inputQuery(selectQueryTemplate, 'query'),
+        createTopic: inputQuery(createTopicTemplate, 'script'),
+        alterTopic: inputQuery(alterTopicTemplate, 'script'),
+        dropTopic: inputQuery(dropTopicTemplate, 'script'),
+        copyPath: () => {
+            try {
+                copy(path);
+                createToast({
+                    name: 'Copied',
+                    title: i18n('actions.copied'),
+                    type: 'success',
+                });
+            }
+            catch (_a) {
+                createToast({
+                    name: 'Not copied',
+                    title: i18n('actions.notCopied'),
+                    type: 'error',
+                });
+            }
+        },
+    };
+};
+export const getActions = (dispatch, additionalEffects) => (path, type) => {
+    const actions = bindActions(path, dispatch, additionalEffects);
+    const copyItem = { text: i18n('actions.copyPath'), action: actions.copyPath };
+    const DIR_SET = [
+        [copyItem],
+        [
+            { text: i18n('actions.createTable'), action: actions.createTable },
+            { text: i18n('actions.createTopic'), action: actions.createTopic },
+        ],
+    ];
+    const TABLE_SET = [
+        [copyItem],
+        [
+            { text: i18n('actions.alterTable'), action: actions.alterTable },
+            { text: i18n('actions.selectQuery'), action: actions.selectQuery },
+            { text: i18n('actions.upsertQuery'), action: actions.upsertQuery },
+        ],
+    ];
+    const TOPIC_SET = [
+        [copyItem],
+        [
+            { text: i18n('actions.alterTopic'), action: actions.alterTopic },
+            { text: i18n('actions.dropTopic'), action: actions.dropTopic },
+        ],
+    ];
+    const EXTERNAL_TABLE_SET = [
+        [copyItem],
+        [
+            {
+                text: i18n('actions.selectQuery'),
+                action: actions.selectQueryFromExternalTable,
+            },
+        ],
+        [{ text: i18n('actions.dropTable'), action: actions.dropExternalTable }],
+    ];
+    const EXTERNAL_DATA_SOURCE_SET = [
+        [copyItem],
+        [{ text: i18n('actions.createExternalTable'), action: actions.createExternalTable }],
+    ];
+    const JUST_COPY = [copyItem];
+    // verbose mapping to guarantee a correct actions set for new node types
+    // TS will error when a new type is added in the lib but is not mapped here
+    const nodeTypeToActions = {
+        database: DIR_SET,
+        directory: DIR_SET,
+        table: TABLE_SET,
+        column_table: TABLE_SET,
+        index_table: JUST_COPY,
+        topic: TOPIC_SET,
+        stream: JUST_COPY,
+        index: JUST_COPY,
+        external_table: EXTERNAL_TABLE_SET,
+        external_data_source: EXTERNAL_DATA_SOURCE_SET,
+    };
+    return nodeTypeToActions[type];
+};

package/dist/containers/Tenant/utils/schemaControls.d.ts

@@ -0,0 +1,7 @@
+import { Dispatch } from 'react';
+import { NavigationTreeNodeType } from 'ydb-ui-components';
+interface ControlsAdditionalEffects {
+    setActivePath: (path: string) => void;
+}
+export declare const getControls: (dispatch: Dispatch<any>, additionalEffects: ControlsAdditionalEffects) => (path: string, type: NavigationTreeNodeType) => JSX.Element | undefined;
+export {};

package/dist/containers/Tenant/utils/schemaControls.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Button } from '@gravity-ui/uikit';
+import { setShowPreview } from '../../../store/reducers/schema/schema';
+import { setQueryTab, setTenantPage } from '../../../store/reducers/tenant/tenant';
+import { TENANT_PAGES_IDS, TENANT_QUERY_TABS_ID } from '../../../store/reducers/tenant/constants';
+import { Icon } from '../../../components/Icon';
+import i18n from '../i18n';
+const bindActions = (path, dispatch, additionalEffects) => {
+    const { setActivePath } = additionalEffects;
+    return {
+        openPreview: () => {
+            dispatch(setShowPreview(true));
+            dispatch(setTenantPage(TENANT_PAGES_IDS.query));
+            dispatch(setQueryTab(TENANT_QUERY_TABS_ID.newQuery));
+            setActivePath(path);
+        },
+    };
+};
+export const getControls = (dispatch, additionalEffects) => (path, type) => {
+    const options = bindActions(path, dispatch, additionalEffects);
+    const openPreview = (_jsx(Button, Object.assign({ view: "flat-secondary", onClick: options.openPreview, title: i18n('actions.openPreview'), size: "s" }, { children: _jsx(Icon, { name: "tablePreview" }) })));
+    const nodeTypeToControls = {
+        database: undefined,
+        directory: undefined,
+        table: openPreview,
+        column_table: openPreview,
+        index_table: undefined,
+        topic: undefined,
+        stream: undefined,
+        index: undefined,
+        external_table: openPreview,
+        external_data_source: undefined,
+    };
+    return nodeTypeToControls[type];
+};

package/dist/containers/Tenants/Tenants.d.ts

@@ -0,0 +1,7 @@
+import type { AdditionalTenantsProps } from '../../types/additionalProps';
+import './Tenants.scss';
+interface TenantsProps {
+    additionalTenantsProps?: AdditionalTenantsProps;
+}
+export declare const Tenants: ({ additionalTenantsProps }: TenantsProps) => JSX.Element;
+export {};

package/dist/containers/Tenants/Tenants.js

@@ -0,0 +1,166 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import cn from 'bem-cn-lite';
+import { useDispatch } from 'react-redux';
+import DataTable from '@gravity-ui/react-data-table';
+import { Button } from '@gravity-ui/uikit';
+import EntityStatus from '../../components/EntityStatus/EntityStatus';
+import { PoolsGraph } from '../../components/PoolsGraph/PoolsGraph';
+import { TabletsStatistic } from '../../components/TabletsStatistic';
+import { ProblemFilter } from '../../components/ProblemFilter';
+import { Illustration } from '../../components/Illustration';
+import { Search } from '../../components/Search';
+import { TableWithControlsLayout } from '../../components/TableWithControlsLayout/TableWithControlsLayout';
+import { ResponseError } from '../../components/Errors/ResponseError';
+import { getTenantsInfo, setSearchValue } from '../../store/reducers/tenants/tenants';
+import { selectFilteredTenants, selectTenantsSearchValue, } from '../../store/reducers/tenants/selectors';
+import { changeFilter, ProblemFilterValues, selectProblemFilter, } from '../../store/reducers/settings/settings';
+import { formatBytesToGigabyte, formatCPU, formatNumber, } from '../../utils/dataFormatters/dataFormatters';
+import { DEFAULT_TABLE_SETTINGS } from '../../utils/constants';
+import { useAutofetcher, useTypedSelector } from '../../utils/hooks';
+import { clusterName } from '../../store';
+import { getTenantPath } from '../Tenant/TenantPages';
+import './Tenants.scss';
+const b = cn('tenants');
+export const Tenants = ({ additionalTenantsProps }) => {
+    const dispatch = useDispatch();
+    const { error, loading, wasLoaded } = useTypedSelector((state) => state.tenants);
+    const searchValue = useTypedSelector(selectTenantsSearchValue);
+    const filteredTenants = useTypedSelector(selectFilteredTenants);
+    const problemFilter = useTypedSelector(selectProblemFilter);
+    useAutofetcher(() => {
+        dispatch(getTenantsInfo(clusterName));
+    }, [dispatch], true);
+    const handleProblemFilterChange = (value) => {
+        dispatch(changeFilter(value));
+    };
+    const handleSearchChange = (value) => {
+        dispatch(setSearchValue(value));
+    };
+    const renderControls = () => {
+        return (_jsxs(_Fragment, { children: [_jsx(Search, { value: searchValue, onChange: handleSearchChange, placeholder: "Database name", className: b('search') }), _jsx(ProblemFilter, { value: problemFilter, onChange: handleProblemFilterChange })] }));
+    };
+    const renderTable = () => {
+        const getTenantBackend = (tenant) => {
+            var _a, _b;
+            const backend = (_a = tenant.MonitoringEndpoint) !== null && _a !== void 0 ? _a : tenant.backend;
+            return (_b = additionalTenantsProps === null || additionalTenantsProps === void 0 ? void 0 : additionalTenantsProps.prepareTenantBackend) === null || _b === void 0 ? void 0 : _b.call(additionalTenantsProps, backend);
+        };
+        const columns = [
+            {
+                name: 'Name',
+                header: 'Database',
+                render: ({ row }) => {
+                    var _a;
+                    const backend = getTenantBackend(row);
+                    const isExternalLink = Boolean(backend);
+                    return (_jsxs("div", Object.assign({ className: b('name-wrapper') }, { children: [_jsx(EntityStatus, { externalLink: isExternalLink, className: b('name'), name: row.Name || 'unknown database', withLeftTrim: true, status: row.Overall, hasClipboardButton: true, path: getTenantPath({
+                                    name: row.Name,
+                                    backend,
+                                }) }), (_a = additionalTenantsProps === null || additionalTenantsProps === void 0 ? void 0 : additionalTenantsProps.getMonitoringLink) === null || _a === void 0 ? void 0 : _a.call(additionalTenantsProps, row.Name, row.Type)] })));
+                },
+                width: 440,
+                sortable: true,
+                defaultOrder: DataTable.DESCENDING,
+            },
+            {
+                name: 'controlPlaneName',
+                header: 'Name',
+                render: ({ row }) => {
+                    return row.controlPlaneName;
+                },
+                width: 200,
+                sortable: true,
+                defaultOrder: DataTable.DESCENDING,
+            },
+            {
+                name: 'Type',
+                width: 200,
+                render: ({ row }) => {
+                    if (row.Type !== 'Serverless') {
+                        return row.Type;
+                    }
+                    return (_jsxs("div", Object.assign({ className: b('type') }, { children: [_jsx("span", Object.assign({ className: b('type-value') }, { children: row.Type })), _jsx(Button, Object.assign({ className: b('type-button'), onClick: () => handleSearchChange(row.sharedTenantName || '') }, { children: "Show shared" }))] })));
+                },
+            },
+            {
+                name: 'State',
+                width: 90,
+                render: ({ row }) => (row.State ? row.State.toLowerCase() : '—'),
+                customStyle: () => ({ textTransform: 'capitalize' }),
+            },
+            {
+                name: 'cpu',
+                header: 'CPU',
+                width: 80,
+                render: ({ row }) => {
+                    // Don't show values below 0.01 when formatted
+                    if (row.cpu > 10000) {
+                        return formatCPU(row.cpu);
+                    }
+                    return '—';
+                },
+                align: DataTable.RIGHT,
+                defaultOrder: DataTable.DESCENDING,
+            },
+            {
+                name: 'memory',
+                header: 'Memory',
+                width: 120,
+                render: ({ row }) => (row.memory ? formatBytesToGigabyte(row.memory) : '—'),
+                align: DataTable.RIGHT,
+                defaultOrder: DataTable.DESCENDING,
+            },
+            {
+                name: 'storage',
+                header: 'Storage',
+                width: 120,
+                render: ({ row }) => (row.storage ? formatBytesToGigabyte(row.storage) : '—'),
+                align: DataTable.RIGHT,
+                defaultOrder: DataTable.DESCENDING,
+            },
+            {
+                name: 'nodesCount',
+                header: 'Nodes',
+                width: 100,
+                render: ({ row }) => (row.nodesCount ? formatNumber(row.nodesCount) : '—'),
+                align: DataTable.RIGHT,
+                defaultOrder: DataTable.DESCENDING,
+            },
+            {
+                name: 'groupsCount',
+                header: 'Groups',
+                width: 100,
+                render: ({ row }) => (row.groupsCount ? formatNumber(row.groupsCount) : '—'),
+                align: DataTable.RIGHT,
+                defaultOrder: DataTable.DESCENDING,
+            },
+            {
+                name: 'PoolStats',
+                header: 'Pools',
+                width: 100,
+                sortAccessor: ({ PoolStats = [] }) => PoolStats.reduce((acc, item) => acc + (item.Usage || 0), 0),
+                defaultOrder: DataTable.DESCENDING,
+                align: DataTable.LEFT,
+                render: ({ row }) => _jsx(PoolsGraph, { pools: row.PoolStats }),
+            },
+            {
+                name: 'Tablets',
+                header: 'Tablets States',
+                sortable: false,
+                width: 430,
+                render: ({ row }) => {
+                    const backend = getTenantBackend(row);
+                    return row.Tablets ? (_jsx(TabletsStatistic, { path: row.Name, tablets: row.Tablets, nodeIds: row.NodeIds || [], backend: backend })) : ('—');
+                },
+            },
+        ];
+        if (filteredTenants.length === 0 && problemFilter !== ProblemFilterValues.ALL) {
+            return _jsx(Illustration, { name: "thumbsUp", width: "200" });
+        }
+        return (_jsx(DataTable, { theme: "yandex-cloud", data: filteredTenants, columns: columns, settings: DEFAULT_TABLE_SETTINGS, emptyDataMessage: "No such tenants" }));
+    };
+    if (error) {
+        return _jsx(ResponseError, { error: error });
+    }
+    return (_jsxs(TableWithControlsLayout, { children: [_jsx(TableWithControlsLayout.Controls, { children: renderControls() }), _jsx(TableWithControlsLayout.Table, Object.assign({ loading: loading && !wasLoaded, className: b('table') }, { children: renderTable() }))] }));
+};

package/dist/containers/Tenants/Tenants.scss

@@ -44,6 +44,7 @@
     &__name-wrapper {
         display: flex;
         align-items: center;
+        gap: 4px;
     }
 
     &__name {

package/dist/containers/UserSettings/Setting.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+export declare type SettingsElementType = 'switch' | 'radio';
+export interface SettingProps {
+    type?: SettingsElementType;
+    title: string;
+    settingKey: string;
+    helpPopoverContent?: ReactNode;
+    options?: {
+        value: string;
+        content: string;
+    }[];
+    defaultValue?: unknown;
+    onValueUpdate?: VoidFunction;
+}
+export declare const Setting: ({ type, settingKey, title, helpPopoverContent, options, defaultValue, onValueUpdate, }: SettingProps) => JSX.Element;

package/dist/containers/UserSettings/Setting.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RadioButton, Switch } from '@gravity-ui/uikit';
+import { Settings } from '@gravity-ui/navigation';
+import { LabelWithPopover } from '../../components/LabelWithPopover/LabelWithPopover';
+import { useSetting } from '../../utils/hooks';
+import { b } from './UserSettings';
+export const Setting = ({ type = 'switch', settingKey, title, helpPopoverContent, options, defaultValue, onValueUpdate, }) => {
+    const [settingValue, setValue] = useSetting(settingKey, defaultValue);
+    const onUpdate = (value) => {
+        setValue(value);
+        onValueUpdate === null || onValueUpdate === void 0 ? void 0 : onValueUpdate();
+    };
+    const renderTitleComponent = (value) => {
+        if (helpPopoverContent) {
+            return (_jsx(LabelWithPopover, { className: b('item-with-popup'), contentClassName: b('popup'), text: value, popoverContent: helpPopoverContent }));
+        }
+        return value;
+    };
+    const getSettingsElement = (elementType) => {
+        switch (elementType) {
+            case 'switch': {
+                return _jsx(Switch, { checked: Boolean(settingValue), onUpdate: onUpdate });
+            }
+            case 'radio': {
+                if (!options) {
+                    return null;
+                }
+                return (_jsx(RadioButton, Object.assign({ value: String(settingValue), onUpdate: onUpdate }, { children: options.map(({ value, content }) => {
+                        return (_jsx(RadioButton.Option, Object.assign({ value: value }, { children: content }), value));
+                    }) })));
+            }
+            default:
+                return null;
+        }
+    };
+    return (_jsx(Settings.Item, Object.assign({ title: title, highlightedTitle: title, renderTitleComponent: renderTitleComponent }, { children: getSettingsElement(type) })));
+};

package/dist/containers/UserSettings/UserSettings.d.ts

@@ -0,0 +1,17 @@
+import { YDBEmbeddedUISettings } from './settings';
+import './UserSettings.scss';
+export declare const b: {
+    (elementName: string, modifiers: import("bem-cn-lite").Modifications | null, mixin?: string | string[] | undefined): string;
+    (elementName: string, mixin?: string | string[] | undefined): string;
+    (elementName: string, modifiers: import("bem-cn-lite").Modifications): string;
+    (mods: import("bem-cn-lite").Modifications | null, mixin?: string | string[] | undefined): string;
+    (elementName: string): string;
+    (mods: import("bem-cn-lite").Modifications | null): string;
+    (): string;
+    builder(): import("bem-cn").Block;
+};
+interface UserSettingsProps {
+    settings?: YDBEmbeddedUISettings;
+}
+export declare const UserSettings: ({ settings: userSettings }: UserSettingsProps) => JSX.Element;
+export {};

package/dist/containers/UserSettings/UserSettings.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import cn from 'bem-cn-lite';
+import { Settings } from '@gravity-ui/navigation';
+import { settings } from './settings';
+import { Setting } from './Setting';
+import './UserSettings.scss';
+export const b = cn('ydb-user-settings');
+export const UserSettings = ({ settings: userSettings = settings }) => {
+    return (_jsx(Settings, { children: userSettings.map((page) => {
+            const { id, title, icon, sections = [] } = page;
+            return (_jsx(Settings.Page, Object.assign({ id: id, title: title, icon: icon }, { children: sections.map((section) => {
+                    const { title: sectionTitle, settings: sectionSettings = [] } = section;
+                    return (_jsx(Settings.Section, Object.assign({ title: sectionTitle }, { children: sectionSettings.map((setting) => {
+                            return _jsx(Setting, Object.assign({}, setting), setting.settingKey);
+                        }) }), id));
+                }) }), id));
+        }) }));
+};

package/dist/containers/UserSettings/i18n/en.json

@@ -1,30 +1,20 @@
 {
-  "page.general": "General",
-  "section.appearance": "Appearance",
-
-  "page.experiments": "Experiments",
-  "section.experiments": "Experiments",
-
-  "settings.theme.title": "Interface theme",
-  "settings.theme.option-dark": "Dark",
-  "settings.theme.option-light": "Light",
-  "settings.theme.option-system": "System",
-
-  "settings.language.title": "Interface language",
-  "settings.language.option-russian": "Russian",
-  "settings.language.option-english": "English",
-
-  "settings.invertedDisks.title": "Inverted disks space indicators",
-
-  "settings.useNodesEndpoint.title": "Break the Nodes tab in Diagnostics",
-  "settings.useNodesEndpoint.popover": "Use /viewer/json/nodes endpoint for Nodes Tab in diagnostics. It could return incorrect data on some versions",
-
-  "settings.useVirtualTables.title": "Use table with data load on scroll for Nodes and Storage tabs",
-  "settings.useVirtualTables.popover": "It will increase performance, but could work unstable",
-
-  "settings.queryUseMultiSchema.title": "Allow queries with multiple result sets",
-  "settings.queryUseMultiSchema.popover": "Use 'multi' schema for queries that enables queries with multiple result sets. Returns nothing on versions 23-3 and older",
-
-  "settings.displayChartsInDbDiagnostics.title": "Display charts in database diagnostics",
-  "settings.displayChartsInDbDiagnostics.popover": "Incorrect data may be displayed (shows data only for the database related to the current node), does not work well on static nodes"
+    "page.general": "General",
+    "section.appearance": "Appearance",
+    "page.experiments": "Experiments",
+    "section.experiments": "Experiments",
+    "settings.theme.title": "Interface theme",
+    "settings.theme.option-dark": "Dark",
+    "settings.theme.option-light": "Light",
+    "settings.theme.option-system": "System",
+    "settings.language.title": "Interface language",
+    "settings.language.option-russian": "Russian",
+    "settings.language.option-english": "English",
+    "settings.invertedDisks.title": "Inverted disks space indicators",
+    "settings.useNodesEndpoint.title": "Break the Nodes tab in Diagnostics",
+    "settings.useNodesEndpoint.popover": "Use /viewer/json/nodes endpoint for Nodes Tab in diagnostics. It could return incorrect data on some versions",
+    "settings.useVirtualTables.title": "Use table with data load on scroll for Nodes and Storage tabs",
+    "settings.useVirtualTables.popover": "It will increase performance, but could work unstable",
+    "settings.queryUseMultiSchema.title": "Allow queries with multiple result sets",
+    "settings.queryUseMultiSchema.popover": "Use 'multi' schema for queries that enables queries with multiple result sets. Returns nothing on versions 23-3 and older"
 }

package/dist/containers/UserSettings/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: string, params?: import("@gravity-ui/i18n").Params | undefined) => string;
+export default _default;

package/dist/containers/UserSettings/i18n/index.js

@@ -0,0 +1,7 @@
+import { i18n, Lang } from '../../../utils/i18n';
+import en from './en.json';
+import ru from './ru.json';
+const COMPONENT = 'ydb-user-settings';
+i18n.registerKeyset(Lang.En, COMPONENT, en);
+i18n.registerKeyset(Lang.Ru, COMPONENT, ru);
+export default i18n.keyset(COMPONENT);

package/dist/containers/UserSettings/i18n/ru.json

@@ -1,30 +1,20 @@
 {
-  "page.general": "Общие",
-  "section.appearance": "Внешний вид",
-
-  "page.experiments": "Эксперименты",
-  "section.experiments": "Эксперименты",
-
-  "settings.theme.title": "Тема",
-  "settings.theme.option-dark": "Тёмная",
-  "settings.theme.option-light": "Светлая",
-  "settings.theme.option-system": "Системная",
-
-  "settings.language.title": "Язык интерфейса",
-  "settings.language.option-russian": "Русский",
-  "settings.language.option-english": "English",
-
-  "settings.invertedDisks.title": "Инвертированные индикаторы места на дисках",
-
-  "settings.useNodesEndpoint.title": "Сломать вкладку Nodes в диагностике",
-  "settings.useNodesEndpoint.popover": "Использовать эндпоинт /viewer/json/nodes для вкладки Nodes в диагностике. Может возвращать некорректные данные на некоторых версиях",
-
-  "settings.useVirtualTables.title": "Использовать таблицу с загрузкой данных по скроллу для вкладок Nodes и Storage",
-  "settings.useVirtualTables.popover": "Это улучшит производительность, но может работать нестабильно",
-
-  "settings.queryUseMultiSchema.title": "Разрешить запросы с несколькими результатами",
-  "settings.queryUseMultiSchema.popover": "Использовать для запросов схему 'multi', которая позволяет выполнять запросы с несколькими результатами. На версиях 23-3 и старше результат не возвращается вообще",
-
-  "settings.displayChartsInDbDiagnostics.title": "Показывать графики в диагностике базы данных",
-  "settings.displayChartsInDbDiagnostics.popover": "Могут отображаться неправильные данные (показывает данные только для базы, относящейся к текущей ноде), плохо работает на статических нодах"
+    "page.general": "Общие",
+    "section.appearance": "Внешний вид",
+    "page.experiments": "Эксперименты",
+    "section.experiments": "Эксперименты",
+    "settings.theme.title": "Тема",
+    "settings.theme.option-dark": "Тёмная",
+    "settings.theme.option-light": "Светлая",
+    "settings.theme.option-system": "Системная",
+    "settings.language.title": "Язык интерфейса",
+    "settings.language.option-russian": "Русский",
+    "settings.language.option-english": "English",
+    "settings.invertedDisks.title": "Инвертированные индикаторы места на дисках",
+    "settings.useNodesEndpoint.title": "Сломать вкладку Nodes в диагностике",
+    "settings.useNodesEndpoint.popover": "Использовать эндпоинт /viewer/json/nodes для вкладки Nodes в диагностике. Может возвращать некорректные данные на некоторых версиях",
+    "settings.useVirtualTables.title": "Использовать таблицу с загрузкой данных по скроллу для вкладок Nodes и Storage",
+    "settings.useVirtualTables.popover": "Это улучшит производительность, но может работать нестабильно",
+    "settings.queryUseMultiSchema.title": "Разрешить запросы с несколькими результатами",
+    "settings.queryUseMultiSchema.popover": "Использовать для запросов схему 'multi', которая позволяет выполнять запросы с несколькими результатами. На версиях 23-3 и старше результат не возвращается вообще"
 }

package/dist/containers/UserSettings/settings.d.ts

@@ -0,0 +1,25 @@
+import type { IconProps } from '@gravity-ui/uikit';
+import type { SettingProps } from './Setting';
+export interface SettingsSection {
+    id: string;
+    title: string;
+    settings: SettingProps[];
+}
+export interface SettingsPage {
+    id: string;
+    title: string;
+    icon: IconProps;
+    sections: SettingsSection[];
+}
+export declare type YDBEmbeddedUISettings = SettingsPage[];
+export declare const themeSetting: SettingProps;
+export declare const languageSetting: SettingProps;
+export declare const invertedDisksSetting: SettingProps;
+export declare const useNodesEndpointSetting: SettingProps;
+export declare const useVirtualTables: SettingProps;
+export declare const queryUseMultiSchemaSetting: SettingProps;
+export declare const appearanceSection: SettingsSection;
+export declare const experimentsSection: SettingsSection;
+export declare const generalPage: SettingsPage;
+export declare const experimentsPage: SettingsPage;
+export declare const settings: YDBEmbeddedUISettings;