ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/utils/__test__/parseBalancer.test.js

@@ -0,0 +1,68 @@
+import { removeViewerPathname, removeProtocol, removePort, getCleanBalancerValue, parseBalancer, } from '../parseBalancer';
+describe('parseBalancer', () => {
+    it('should parse balancer with viewer proxy', () => {
+        const rawValue = 'https://viewer.ydb.ru:443/ydb-testing-0000.search.ydb.net:8765/viewer/json';
+        const balancer = 'ydb-testing-0000.search.ydb.net:8765';
+        const proxy = 'viewer.ydb.ru:443';
+        const parsedBalancerWithViewer = parseBalancer(rawValue);
+        expect(parsedBalancerWithViewer.balancer).toBe(balancer);
+        expect(parsedBalancerWithViewer.proxy).toBe(proxy);
+    });
+    it('should parse balancer with bastion proxy', () => {
+        const rawValue = 'https://ydb.bastion.cloud.ru:443/ydbproxy.ydb.cloud.net:8765/viewer/json';
+        const balancer = 'ydbproxy.ydb.cloud.net:8765';
+        const proxy = 'ydb.bastion.cloud.ru:443';
+        const parsedBalancerWithBastion = parseBalancer(rawValue);
+        expect(parsedBalancerWithBastion.balancer).toBe(balancer);
+        expect(parsedBalancerWithBastion.proxy).toBe(proxy);
+    });
+    it('should parse balancer with custom proxy', () => {
+        const rawValue = 'https://proxy.ydb.mdb.cloud-preprod.net:443/ydbproxy-public.ydb.cloud-preprod.net:8765/viewer/json';
+        const balancer = 'ydbproxy-public.ydb.cloud-preprod.net:8765';
+        const proxy = 'proxy.ydb.mdb.cloud-preprod.net:443';
+        const parsedBalancerWithCustomProxy = parseBalancer(rawValue);
+        expect(parsedBalancerWithCustomProxy.balancer).toBe(balancer);
+        expect(parsedBalancerWithCustomProxy.proxy).toBe(proxy);
+    });
+    it('should parse balancer without proxy', () => {
+        const rawValue = 'https://ydb-testing-0000.search.net:8765/viewer/json';
+        const balancer = 'ydb-testing-0000.search.net:8765';
+        const parsedBalancerWithoutProxy = parseBalancer(rawValue);
+        expect(parsedBalancerWithoutProxy.balancer).toBe(balancer);
+        expect(parsedBalancerWithoutProxy.proxy).toBe(undefined);
+    });
+    it('should parse pure balancer', () => {
+        const pureBalancer = 'ydb-testing-0000.search.net:8765';
+        const parsedPureBalancer = parseBalancer(pureBalancer);
+        expect(parsedPureBalancer.balancer).toBe(pureBalancer);
+        expect(parsedPureBalancer.proxy).toBe(undefined);
+    });
+});
+describe('removeViewerPathname', () => {
+    it('should remove pathname', () => {
+        const initialValue = 'https://ydb-testing-0000.search.net:8765/viewer/json';
+        const result = 'https://ydb-testing-0000.search.net:8765';
+        expect(removeViewerPathname(initialValue)).toBe(result);
+    });
+});
+describe('removeProtocol', () => {
+    it('should remove protocol', () => {
+        const initialValue = 'https://ydb-testing-0000.search.net:8765/viewer/json';
+        const result = 'ydb-testing-0000.search.net:8765/viewer/json';
+        expect(removeProtocol(initialValue)).toBe(result);
+    });
+});
+describe('removePort', () => {
+    it('should remove port', () => {
+        const initialValue = 'ydb-testing-0000.search.net:8765';
+        const result = 'ydb-testing-0000.search.net';
+        expect(removePort(initialValue)).toBe(result);
+    });
+});
+describe('getCleanBalancerValue', () => {
+    it('should return balancer value without protocol, proxy, port and pathname', () => {
+        const initialValue = 'https://ydb.bastion.cloud.ru:443/ydbproxy.ydb.cloud.net:8765/viewer/json';
+        const result = 'ydbproxy.ydb.cloud.net';
+        expect(getCleanBalancerValue(initialValue)).toBe(result);
+    });
+});

package/dist/utils/__test__/prepareBackend.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__test__/prepareBackend.test.js

@@ -0,0 +1,42 @@
+import { prepareHost, getBackendFromNodeHost, getBackendFromRawNodeData } from '../prepareBackend';
+describe('prepareHost', () => {
+    it('should add vm prefix to cloud din nodes', () => {
+        const cloudDinNodeInitialHost = 'vm-cc8mco0j0snqehgh7r2a-ru-central1-c-nlmw-aniq.cc8mco0j0snqehgh7r2a.ydb.mdb.cloud-preprod.net';
+        const cloudDinNodeResultHost = 'u-vm-cc8mco0j0snqehgh7r2a-ru-central1-c-nlmw-aniq.cc8mco0j0snqehgh7r2a.ydb.mdb.cloud-preprod.net';
+        const commonNodeHost = 'sas09-ct5-1.cloud.net';
+        expect(prepareHost(cloudDinNodeInitialHost)).toBe(cloudDinNodeResultHost);
+        expect(prepareHost(commonNodeHost)).toBe(commonNodeHost);
+    });
+});
+describe('getBackendFromNodeHost', () => {
+    it('should prepare correct backend value from node host', () => {
+        const balancer = 'https://viewer.ydb.ru:443/dev02.ydb.net:8765';
+        const nodeHost = 'ydb-dev02-001.search.net:31012';
+        const result = 'https://viewer.ydb.ru:443/ydb-dev02-001.search.net:31012';
+        expect(getBackendFromNodeHost(nodeHost, balancer)).toBe(result);
+    });
+});
+describe('getBackendFromRawNodeData', () => {
+    it('should prepare correct backend value from raw node data', () => {
+        const balancer = 'https://viewer.ydb.ru:443/dev02.ydb.net:8765';
+        const node = {
+            Host: 'ydb-dev02-000.search.net',
+            Endpoints: [
+                {
+                    Name: 'http-mon',
+                    Address: ':8765',
+                },
+                {
+                    Name: 'ic',
+                    Address: ':19001',
+                },
+                {
+                    Name: 'grpc',
+                    Address: ':2135',
+                },
+            ],
+        };
+        const result = 'https://viewer.ydb.ru:443/ydb-dev02-000.search.net:8765/';
+        expect(getBackendFromRawNodeData(node, balancer)).toBe(result);
+    });
+});

package/dist/utils/additionalProps.d.ts

@@ -0,0 +1,2 @@
+import type { AdditionalNodesProps } from '../types/additionalProps';
+export declare const getAdditionalNodesProps: (balancer?: any, useClusterBalancerAsBackend?: boolean | undefined) => AdditionalNodesProps;

package/dist/utils/additionalProps.js

@@ -0,0 +1,7 @@
+import { backend } from '../store';
+import { getBackendFromRawNodeData } from './prepareBackend';
+export const getAdditionalNodesProps = (balancer = backend, useClusterBalancerAsBackend) => {
+    return {
+        getNodeRef: (node = {}) => getBackendFromRawNodeData(node, balancer, useClusterBalancerAsBackend),
+    };
+};

package/dist/utils/autofetcher.d.ts

@@ -0,0 +1,13 @@
+export declare class AutoFetcher {
+    static DEFAULT_TIMEOUT: number;
+    static MIN_TIMEOUT: number;
+    timeout: number;
+    active: boolean;
+    timer: undefined | ReturnType<typeof setTimeout>;
+    launchCounter: number;
+    constructor();
+    wait(ms: number): Promise<unknown>;
+    fetch(request: Function): Promise<void>;
+    stop(): void;
+    start(): void;
+}

package/dist/utils/autofetcher.js

@@ -0,0 +1,50 @@
+export class AutoFetcher {
+    constructor() {
+        this.timeout = AutoFetcher.DEFAULT_TIMEOUT;
+        this.active = true;
+        this.timer = undefined;
+        this.launchCounter = 0;
+    }
+    wait(ms) {
+        return new Promise((resolve) => {
+            this.timer = setTimeout(resolve, ms);
+            return;
+        });
+    }
+    async fetch(request) {
+        if (!this.active) {
+            return;
+        }
+        const currentLaunch = this.launchCounter;
+        await this.wait(this.timeout);
+        if (this.active) {
+            const startTs = Date.now();
+            await request();
+            const finishTs = Date.now();
+            if (currentLaunch !== this.launchCounter) {
+                // autofetcher was restarted while request was in progress
+                // stop further fetches, we are in deprecated thread
+                return;
+            }
+            const responseTime = finishTs - startTs;
+            const nextTimeout = responseTime > AutoFetcher.MIN_TIMEOUT ? responseTime : AutoFetcher.MIN_TIMEOUT;
+            this.timeout = nextTimeout;
+            this.fetch(request);
+        }
+        else {
+            return;
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        this.active = false;
+    }
+    start() {
+        this.launchCounter++;
+        this.active = true;
+    }
+}
+AutoFetcher.DEFAULT_TIMEOUT = 30000;
+AutoFetcher.MIN_TIMEOUT = 30000;

package/dist/utils/bytesParsers/__test__/formatBytes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/bytesParsers/__test__/formatBytes.test.js

@@ -0,0 +1,44 @@
+import { formatBytes } from '../formatBytes';
+describe('formatBytes', () => {
+    it('should work with only value', () => {
+        expect(formatBytes({ value: 100 })).toBe('100 B');
+        expect(formatBytes({ value: 100000 })).toBe('100 KB');
+        expect(formatBytes({ value: 100000000 })).toBe('100 MB');
+        expect(formatBytes({ value: 100000000000 })).toBe('100 GB');
+        expect(formatBytes({ value: 100000000000000 })).toBe('100 TB');
+    });
+    it('should convert to size', () => {
+        expect(formatBytes({ value: 100000, size: 'b' })).toBe('100,000 B');
+        expect(formatBytes({ value: 100000000000000, size: 'gb' })).toBe('100,000 GB');
+    });
+    it('should convert without labels', () => {
+        expect(formatBytes({ value: 100000, size: 'b', withSizeLabel: false })).toBe('100,000');
+        expect(formatBytes({ value: 100000000000000, size: 'gb', withSizeLabel: false })).toBe('100,000');
+    });
+    it('should convert to speed', () => {
+        expect(formatBytes({ value: 100000, withSpeedLabel: true })).toBe('100 KB/s');
+        expect(formatBytes({ value: 100000, size: 'b', withSpeedLabel: true })).toBe('100,000 B/s');
+    });
+    it('should return fixed amount of significant digits', () => {
+        expect(formatBytes({ value: 99000, significantDigits: 2 })).toEqual('99,000 B');
+        expect(formatBytes({ value: 100000, significantDigits: 2 })).toEqual('100 KB');
+        expect(formatBytes({ value: 99000000000000, significantDigits: 2 })).toEqual('99,000 GB');
+        expect(formatBytes({ value: 100000000000000, significantDigits: 2 })).toEqual('100 TB');
+    });
+    it('should return empty string on invalid data', () => {
+        expect(formatBytes({ value: undefined })).toEqual('');
+        expect(formatBytes({ value: null })).toEqual('');
+        expect(formatBytes({ value: '' })).toEqual('');
+        expect(formatBytes({ value: 'false' })).toEqual('');
+        expect(formatBytes({ value: '123qwe' })).toEqual('');
+    });
+    it('should work with precision', () => {
+        expect(formatBytes({ value: 123.123, precision: 2 })).toBe('123 B');
+        expect(formatBytes({ value: 12.123, precision: 2 })).toBe('12 B');
+        expect(formatBytes({ value: 1.123, precision: 2 })).toBe('1.1 B');
+        expect(formatBytes({ value: 0.123, precision: 2 })).toBe('0.12 B');
+        expect(formatBytes({ value: 0.012, precision: 2 })).toBe('0.01 B');
+        expect(formatBytes({ value: 0.001, precision: 2 })).toBe('0 B');
+        expect(formatBytes({ value: 0, precision: 2 })).toBe('0 B');
+    });
+});

package/dist/utils/bytesParsers/convertBytesObjectToSpeed.d.ts

@@ -0,0 +1,11 @@
+import type { MultipleWindowsStat } from '../../types/api/consumer';
+export interface ProcessSpeedStats {
+    perMinute: number;
+    perHour: number;
+    perDay: number;
+}
+/**
+ * Convert data of type MultipleWindowsStat.
+ * This data format is specific for describe_topic and describe_consumer endpoints
+ */
+export declare const convertBytesObjectToSpeed: (data: MultipleWindowsStat | undefined) => ProcessSpeedStats;

package/dist/utils/bytesParsers/convertBytesObjectToSpeed.js

@@ -0,0 +1,12 @@
+import { DAY_IN_SECONDS, HOUR_IN_SECONDS, MINUTE_IN_SECONDS } from '../constants';
+/**
+ * Convert data of type MultipleWindowsStat.
+ * This data format is specific for describe_topic and describe_consumer endpoints
+ */
+export const convertBytesObjectToSpeed = (data) => {
+    return {
+        perMinute: data && data.per_minute ? Math.round(Number(data.per_minute) / MINUTE_IN_SECONDS) : 0,
+        perHour: data && data.per_hour ? Math.round(Number(data.per_hour) / HOUR_IN_SECONDS) : 0,
+        perDay: data && data.per_day ? Math.round(Number(data.per_day) / DAY_IN_SECONDS) : 0,
+    };
+};

package/dist/utils/bytesParsers/formatBytes.d.ts

@@ -0,0 +1,57 @@
+declare const sizes: {
+    b: {
+        value: number;
+        label: string;
+    };
+    kb: {
+        value: number;
+        label: string;
+    };
+    mb: {
+        value: number;
+        label: string;
+    };
+    gb: {
+        value: number;
+        label: string;
+    };
+    tb: {
+        value: number;
+        label: string;
+    };
+};
+export declare type BytesSizes = keyof typeof sizes;
+/**
+ * This function is needed to keep more than 3 digits of the same size.
+ *
+ * @param significantDigits - number of digits above 3
+ * @returns size to format value to get required number of digits
+ *
+ * By default value converted to the next size when it's above 1000,
+ * so we have 900mb and 1gb. To extend it additional significantDigits could be set
+ *
+ * significantDigits value added above default 3
+ *
+ * significantDigits = 1 - 9 000 mb and 10 gb
+ *
+ * significantDigits = 2 - 90 000 mb and 100 gb
+ *
+ * significantDigits = 3 - 900 000 mb and 1000 gb
+ */
+export declare const getSizeWithSignificantDigits: (value: number, significantDigits: number) => "b" | "kb" | "mb" | "gb" | "tb";
+interface FormatToSizeArgs {
+    value: number;
+    size?: BytesSizes;
+    precision?: number;
+}
+export declare type FormatBytesArgs = Omit<FormatToSizeArgs, 'value'> & {
+    value: number | string | undefined | null;
+    withSpeedLabel?: boolean;
+    withSizeLabel?: boolean;
+    significantDigits?: number;
+};
+/**
+ * @param significantDigits - number of digits above 3
+ */
+export declare const formatBytes: ({ value, size, withSpeedLabel, withSizeLabel, significantDigits, ...params }: FormatBytesArgs) => string;
+export {};

package/dist/utils/bytesParsers/formatBytes.js

@@ -0,0 +1,104 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { formatNumber, roundToPrecision } from '../dataFormatters/dataFormatters';
+import { GIGABYTE, KILOBYTE, MEGABYTE, TERABYTE } from '../constants';
+import { isNumeric } from '../utils';
+import i18n from './i18n';
+const sizes = {
+    b: {
+        value: 1,
+        label: i18n('b'),
+    },
+    kb: {
+        value: KILOBYTE,
+        label: i18n('kb'),
+    },
+    mb: {
+        value: MEGABYTE,
+        label: i18n('mb'),
+    },
+    gb: {
+        value: GIGABYTE,
+        label: i18n('gb'),
+    },
+    tb: {
+        value: TERABYTE,
+        label: i18n('tb'),
+    },
+};
+/**
+ * This function is needed to keep more than 3 digits of the same size.
+ *
+ * @param significantDigits - number of digits above 3
+ * @returns size to format value to get required number of digits
+ *
+ * By default value converted to the next size when it's above 1000,
+ * so we have 900mb and 1gb. To extend it additional significantDigits could be set
+ *
+ * significantDigits value added above default 3
+ *
+ * significantDigits = 1 - 9 000 mb and 10 gb
+ *
+ * significantDigits = 2 - 90 000 mb and 100 gb
+ *
+ * significantDigits = 3 - 900 000 mb and 1000 gb
+ */
+export const getSizeWithSignificantDigits = (value, significantDigits) => {
+    const multiplier = 10 ** significantDigits;
+    const tbLevel = sizes.tb.value * multiplier;
+    const gbLevel = sizes.gb.value * multiplier;
+    const mbLevel = sizes.mb.value * multiplier;
+    const kbLevel = sizes.kb.value * multiplier;
+    let size = 'b';
+    if (value >= kbLevel) {
+        size = 'kb';
+    }
+    if (value >= mbLevel) {
+        size = 'mb';
+    }
+    if (value >= gbLevel) {
+        size = 'gb';
+    }
+    if (value >= tbLevel) {
+        size = 'tb';
+    }
+    return size;
+};
+const formatToSize = ({ value, size = 'mb', precision = 0 }) => {
+    const result = roundToPrecision(Number(value) / sizes[size].value, precision);
+    return formatNumber(result);
+};
+const addSizeLabel = (result, size) => {
+    return result + ` ${sizes[size].label}`;
+};
+const addSpeedLabel = (result, size) => {
+    return addSizeLabel(result, size) + i18n('perSecond');
+};
+/**
+ * @param significantDigits - number of digits above 3
+ */
+export const formatBytes = (_a) => {
+    var { value, size, withSpeedLabel = false, withSizeLabel = true, significantDigits = 0 } = _a, params = __rest(_a, ["value", "size", "withSpeedLabel", "withSizeLabel", "significantDigits"]);
+    if (!isNumeric(value)) {
+        return '';
+    }
+    const numValue = Number(value);
+    const sizeToConvert = size !== null && size !== void 0 ? size : getSizeWithSignificantDigits(numValue, significantDigits);
+    const result = formatToSize(Object.assign({ value: numValue, size: sizeToConvert }, params));
+    if (withSpeedLabel) {
+        return addSpeedLabel(result, sizeToConvert);
+    }
+    if (withSizeLabel) {
+        return addSizeLabel(result, sizeToConvert);
+    }
+    return result;
+};

package/dist/utils/bytesParsers/i18n/en.json

@@ -1,8 +1,8 @@
 {
-  "b": "B",
-  "kb": "KB",
-  "mb": "MB",
-  "gb": "GB",
-  "tb": "TB",
-  "perSecond": "/s"
+    "b": "B",
+    "kb": "KB",
+    "mb": "MB",
+    "gb": "GB",
+    "tb": "TB",
+    "perSecond": "/s"
 }

package/dist/utils/bytesParsers/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/utils/bytesParsers/i18n/index.js

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

package/dist/utils/bytesParsers/i18n/ru.json

@@ -1,8 +1,8 @@
 {
-  "b": "Б",
-  "kb": "КБ",
-  "mb": "МБ",
-  "gb": "ГБ",
-  "tb": "ТБ",
-  "perSecond": "/с"
+    "b": "Б",
+    "kb": "КБ",
+    "mb": "МБ",
+    "gb": "ГБ",
+    "tb": "ТБ",
+    "perSecond": "/с"
 }

package/dist/utils/bytesParsers/index.js

@@ -0,0 +1,2 @@
+export * from './formatBytes';
+export * from './convertBytesObjectToSpeed';

package/dist/utils/clusterVersionColors.d.ts

@@ -0,0 +1,11 @@
+import type { MetaClusterVersion } from '../types/api/meta';
+import type { VersionToColorMap } from '../types/versions';
+declare type VersionsMap = Map<number | string, Set<string>>;
+export declare const getVersionMap: (versions: MetaClusterVersion[], initialMap?: VersionsMap) => VersionsMap;
+export declare const getVersionColors: (versionMap: VersionsMap) => VersionToColorMap;
+export interface ExtendedMetaClusterVersion extends MetaClusterVersion {
+    minorVersion: string;
+    color: string | undefined;
+}
+export declare const prepareClusterVersions: (clusterVersions: MetaClusterVersion[] | undefined, versionToColor: VersionToColorMap) => ExtendedMetaClusterVersion[];
+export {};

package/dist/utils/clusterVersionColors.js

@@ -0,0 +1,51 @@
+import { uniqBy } from 'lodash';
+import { COLORS, GRAY_COLOR, getMinorVersion, hashCode } from './versions';
+const UNDEFINED_COLOR_INDEX = '__no_color__';
+export const getVersionMap = (versions, initialMap = new Map()) => {
+    versions.forEach(({ version, version_base_color_index: versionBaseColorIndex = UNDEFINED_COLOR_INDEX }) => {
+        var _a;
+        const minorVersion = getMinorVersion(version);
+        if (!initialMap.has(versionBaseColorIndex)) {
+            initialMap.set(versionBaseColorIndex, new Set());
+        }
+        (_a = initialMap.get(versionBaseColorIndex)) === null || _a === void 0 ? void 0 : _a.add(minorVersion);
+    });
+    return initialMap;
+};
+export const getVersionColors = (versionMap) => {
+    const versionToColor = new Map();
+    for (const [baseColorIndex, item] of versionMap) {
+        Array.from(item)
+            // descending by version name: newer versions come first,
+            // so the newer version gets the brighter color
+            .sort((a, b) => hashCode(b) - hashCode(a))
+            .forEach((minor, minorIndex) => {
+            if (baseColorIndex === UNDEFINED_COLOR_INDEX) {
+                versionToColor.set(minor, GRAY_COLOR);
+            }
+            else {
+                // baseColorIndex is numeric as we check if it is UNDEFINED_COLOR_INDEX before
+                const currentColorIndex = Number(baseColorIndex) % COLORS.length;
+                const minorQuantity = item.size;
+                const majorColor = COLORS[currentColorIndex];
+                const opacityPercent = Math.max(100 - minorIndex * (100 / minorQuantity), 20);
+                const hexOpacity = Math.round((opacityPercent * 255) / 100).toString(16);
+                const versionColor = `${majorColor}${hexOpacity}`;
+                versionToColor.set(minor, versionColor);
+            }
+        });
+    }
+    return versionToColor;
+};
+export const prepareClusterVersions = (clusterVersions = [], versionToColor) => {
+    const filteredVersions = clusterVersions.filter((item) => item.version);
+    const preparedVersions = uniqBy(filteredVersions, 'version').map((item) => {
+        return Object.assign(Object.assign({}, item), { minorVersion: getMinorVersion(item.version) });
+    });
+    const versionsColors = preparedVersions.reduce((acc, item) => {
+        const color = versionToColor.get(item.minorVersion);
+        acc.push(Object.assign(Object.assign({}, item), { color }));
+        return acc;
+    }, []);
+    return versionsColors;
+};

package/dist/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import cn from 'bem-cn-lite';
+export { cn };

package/dist/utils/cn.js

@@ -0,0 +1,2 @@
+import cn from 'bem-cn-lite';
+export { cn };

package/dist/utils/constants.d.ts

@@ -0,0 +1,86 @@
+export declare const AUTO_RELOAD_INTERVAL: number;
+export declare const KILOBYTE = 1000;
+export declare const MEGABYTE = 1000000;
+export declare const GIGABYTE = 1000000000;
+export declare const TERABYTE = 1000000000000;
+export declare const MINUTE_IN_SECONDS = 60;
+export declare const HOUR_IN_SECONDS: number;
+export declare const DAY_IN_SECONDS: number;
+export declare const MS_IN_NANOSECONDS = 1000000;
+export declare const TABLET_COLORS: {
+    Created: string;
+    ResolveStateStorage: string;
+    Candidate: string;
+    BlockBlobStorage: string;
+    RebuildGraph: string;
+    Restored: string;
+    Discover: string;
+    Lock: string;
+    Dead: string;
+    Active: string;
+};
+export declare const TABLET_SYMBOLS: {
+    OldTxProxy: string;
+    TxProxy: string;
+    BSController: string;
+    Dummy: string;
+    RTMRPartition: string;
+    PersQueueReadBalancer: string;
+    Cms: string;
+    BlockStorePartition: string;
+    BlockStoreVolume: string;
+    Console: string;
+    TenantSlotBroker: string;
+    BlockStoreDiskRegistry: string;
+};
+export declare const getTabletLabel: (type?: string | undefined) => string | undefined;
+export declare const LOAD_AVERAGE_TIME_INTERVALS: string[];
+export declare const COLORS_PRIORITY: {
+    green: number;
+    yellow: number;
+    orange: number;
+    red: number;
+    blue: number;
+    grey: number;
+};
+export declare const TENANT_OVERVIEW_TABLES_LIMIT = 5;
+export declare const EMPTY_DATA_PLACEHOLDER = "\u2014";
+export declare const DEVELOPER_UI_TITLE = "Developer UI";
+export declare const CLUSTER_DEFAULT_TITLE = "Cluster";
+export declare const TENANT_DEFAULT_TITLE = "Database";
+export declare const THEME_KEY = "theme";
+export declare const LANGUAGE_KEY = "language";
+export declare const INVERTED_DISKS_KEY = "invertedDisks";
+export declare const USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY = "useNodesEndpointInDiagnostics";
+export declare const SAVED_QUERIES_KEY = "saved_queries";
+export declare const ASIDE_HEADER_COMPACT_KEY = "asideHeaderCompact";
+export declare const QUERIES_HISTORY_KEY = "queries_history";
+export declare const DATA_QA_TUNE_COLUMNS_POPUP = "tune-columns-popup";
+export declare const DEFAULT_SIZE_RESULT_PANE_KEY = "default-size-result-pane";
+export declare const DEFAULT_SIZE_TENANT_SUMMARY_KEY = "default-size-tenant-summary-pane";
+export declare const DEFAULT_SIZE_TENANT_KEY = "default-size-tenant-pane";
+export declare const DEFAULT_IS_TENANT_SUMMARY_COLLAPSED = "default-is-tenant-summary-collapsed";
+export declare const DEFAULT_IS_TENANT_COMMON_INFO_COLLAPSED = "default-is-tenant-common-info-collapsed";
+export declare const DEFAULT_IS_QUERY_RESULT_COLLAPSED = "default-is-query-result-collapsed";
+export declare const DEFAULT_TABLE_SETTINGS: {
+    readonly displayIndices: false;
+    readonly stickyHead: "moving";
+    readonly syncHeadOnResize: true;
+    readonly dynamicRender: true;
+    readonly highlightRows: true;
+};
+export declare const TENANT_OVERVIEW_TABLES_SETTINGS: {
+    readonly stickyHead: "fixed";
+    readonly dynamicRender: false;
+    readonly displayIndices: false;
+    readonly syncHeadOnResize: true;
+    readonly highlightRows: true;
+};
+export declare const QUERY_INITIAL_MODE_KEY = "query_initial_mode";
+export declare const LAST_USED_QUERY_ACTION_KEY = "last_used_query_action";
+export declare const PARTITIONS_HIDDEN_COLUMNS_KEY = "partitionsHiddenColumns";
+export declare const CLUSTER_INFO_HIDDEN_KEY = "clusterInfoHidden";
+export declare const TENANT_INITIAL_PAGE_KEY = "saved_tenant_initial_tab";
+export declare const USE_BACKEND_PARAMS_FOR_TABLES_KEY = "useBackendParamsForTables";
+export declare const QUERY_USE_MULTI_SCHEMA_KEY = "queryUseMultiSchema";
+export declare const USE_CLUSTER_BALANCER_AS_BACKEND_KEY = "useClusterBalancerAsBacked";