ydb-embedded-ui 4.33.0 → 5.0.0

package/dist/utils/query.d.ts

@@ -0,0 +1,28 @@
+import type { AnyExecuteResponse, AnyExplainResponse, KeyValueRow, QueryPlan, ScriptPlan } from '../types/api/query';
+import type { IQueryResult, QueryErrorResponse, QueryMode } from '../types/store/query';
+export declare const QUERY_ACTIONS: {
+    readonly execute: "execute";
+    readonly explain: "explain";
+};
+export declare const QUERY_MODES: {
+    readonly scan: "scan";
+    readonly script: "script";
+    readonly data: "data";
+    readonly query: "query";
+    readonly pg: "pg";
+};
+export declare const QUERY_MODES_TITLES: Record<QueryMode, string>;
+export declare const QUERY_SYNTAX: {
+    readonly yql: "yql_v1";
+    readonly pg: "pg";
+};
+export declare const getColumnType: (type: string) => "boolean" | "number" | "string" | "date" | undefined;
+declare type UnsupportedQueryResponseFormat = Array<unknown> | string | null | undefined | {
+    result: string | Record<string, unknown>;
+};
+export declare const parseQueryAPIExecuteResponse: (data: AnyExecuteResponse | UnsupportedQueryResponseFormat) => IQueryResult;
+export declare const parseQueryAPIExplainResponse: (data: AnyExplainResponse | UnsupportedQueryResponseFormat) => IQueryResult;
+export declare const parseQueryExplainPlan: (plan: ScriptPlan | QueryPlan) => QueryPlan;
+export declare const prepareQueryResponse: (data?: KeyValueRow<import("../types/api/query").CellValue>[] | undefined) => KeyValueRow<import("../types/api/query").CellValue>[];
+export declare function prepareQueryError(error: QueryErrorResponse): string | undefined;
+export {};

package/dist/utils/query.js

@@ -0,0 +1,181 @@
+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 { YQLType } from '../types';
+export const QUERY_ACTIONS = {
+    execute: 'execute',
+    explain: 'explain',
+};
+export const QUERY_MODES = {
+    scan: 'scan',
+    script: 'script',
+    data: 'data',
+    query: 'query',
+    pg: 'pg',
+};
+export const QUERY_MODES_TITLES = {
+    scan: 'Scan',
+    script: 'YQL Script',
+    data: 'Data',
+    query: 'YQL - QueryService',
+    pg: 'PostgreSQL',
+};
+export const QUERY_SYNTAX = {
+    yql: 'yql_v1',
+    pg: 'pg',
+};
+// eslint-disable-next-line complexity
+export const getColumnType = (type) => {
+    switch (type.replace(/\?$/, '')) {
+        case YQLType.Bool:
+            return 'boolean';
+        case YQLType.Int8:
+        case YQLType.Int16:
+        case YQLType.Int32:
+        case YQLType.Int64:
+        case YQLType.Uint8:
+        case YQLType.Uint16:
+        case YQLType.Uint32:
+        case YQLType.Uint64:
+        case YQLType.Float:
+        case YQLType.Double:
+        case YQLType.Decimal:
+            return 'number';
+        case YQLType.String:
+        case YQLType.Utf8:
+        case YQLType.Json:
+        case YQLType.JsonDocument:
+        case YQLType.Yson:
+        case YQLType.Uuid:
+            return 'string';
+        case YQLType.Date:
+        case YQLType.Datetime:
+        case YQLType.Timestamp:
+        case YQLType.Interval:
+        case YQLType.TzDate:
+        case YQLType.TzDateTime:
+        case YQLType.TzTimestamp:
+            return 'date';
+        default:
+            return undefined;
+    }
+};
+/** parse response result from ArrayRow to KeyValueRow */
+const parseModernResult = (rows, columns) => {
+    return rows.map((row) => {
+        return row.reduce((newRow, cellData, columnIndex) => {
+            const { name } = columns[columnIndex];
+            newRow[name] = cellData;
+            return newRow;
+        }, {});
+    });
+};
+const parseExecuteModernResponse = (data) => {
+    const { result, columns } = data, restData = __rest(data, ["result", "columns"]);
+    return Object.assign({ result: result && columns && parseModernResult(result, columns), columns }, restData);
+};
+const parseExecuteMultiResponse = (data) => {
+    const { result } = data, restData = __rest(data, ["result"]);
+    const parsedResult = result === null || result === void 0 ? void 0 : result.map((resultSet) => {
+        const { rows, columns } = resultSet;
+        let parsedRows;
+        if (columns) {
+            // Result shouldn't be null if there are columns
+            parsedRows = [];
+        }
+        if (rows && columns) {
+            parsedRows = parseModernResult(rows, columns);
+        }
+        return {
+            columns: columns,
+            result: parsedRows,
+        };
+    });
+    return Object.assign({ resultSets: parsedResult }, restData);
+};
+const isModern = (response) => Boolean(response &&
+    !Array.isArray(response) &&
+    Array.isArray(response.result) &&
+    Array.isArray(response.columns));
+const isMulti = (response) => Boolean(response &&
+    !Array.isArray(response) &&
+    Array.isArray(response.result) &&
+    typeof response.result[0] === 'object' &&
+    'rows' in response.result[0] &&
+    'columns' in response.result[0]);
+const isUnsupportedType = (data) => {
+    return Boolean(!data ||
+        typeof data !== 'object' ||
+        Array.isArray(data) ||
+        ('result' in data && !Array.isArray(data.result)));
+};
+// Although schema is set in request, if schema is not supported default schema for the version will be used
+// So we should additionally parse response
+export const parseQueryAPIExecuteResponse = (data) => {
+    if (isUnsupportedType(data)) {
+        return {};
+    }
+    if (isMulti(data)) {
+        return parseExecuteMultiResponse(data);
+    }
+    if (isModern(data)) {
+        return parseExecuteModernResponse(data);
+    }
+    return data;
+};
+export const parseQueryAPIExplainResponse = (data) => {
+    if (isUnsupportedType(data)) {
+        return {};
+    }
+    return data;
+};
+const isExplainScriptPlan = (plan) => Boolean(plan && 'queries' in plan);
+export const parseQueryExplainPlan = (plan) => {
+    if (isExplainScriptPlan(plan)) {
+        if (!plan.queries || !plan.queries.length) {
+            return { meta: plan.meta };
+        }
+        return {
+            Plan: plan.queries[0].Plan,
+            tables: plan.queries[0].tables,
+            meta: plan.meta,
+        };
+    }
+    return plan;
+};
+export const prepareQueryResponse = (data) => {
+    if (!Array.isArray(data)) {
+        return [];
+    }
+    return data.map((row) => {
+        const formattedData = {};
+        for (const field in row) {
+            if (Object.prototype.hasOwnProperty.call(row, field)) {
+                const type = typeof row[field];
+                // Although typeof null == 'object'
+                // null result should be preserved
+                if ((row[field] !== null && type === 'object') ||
+                    type === 'boolean' ||
+                    Array.isArray(row[field])) {
+                    formattedData[field] = JSON.stringify(row[field]);
+                }
+                else {
+                    formattedData[field] = row[field];
+                }
+            }
+        }
+        return formattedData;
+    });
+};
+export function prepareQueryError(error) {
+    var _a, _b;
+    return ((_b = (_a = error.data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.message) || error.statusText;
+}

package/dist/utils/query.test.d.ts

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

package/dist/utils/query.test.js

@@ -0,0 +1,164 @@
+import { parseQueryAPIExecuteResponse, parseQueryAPIExplainResponse, parseQueryExplainPlan, } from './query';
+describe('API utils', () => {
+    describe('json/viewer/query', () => {
+        describe('parseQueryAPIExecuteResponse', () => {
+            describe('should handle responses with incorrect format', () => {
+                it('should handle null response', () => {
+                    expect(parseQueryAPIExecuteResponse(null)).toEqual({});
+                });
+                it('should handle undefined response', () => {
+                    expect(parseQueryAPIExecuteResponse(undefined)).toEqual({});
+                });
+                it('should handle string response', () => {
+                    expect(parseQueryAPIExecuteResponse('foo')).toEqual({});
+                });
+                it('should handle array response', () => {
+                    expect(parseQueryAPIExecuteResponse([{ foo: 'bar' }])).toEqual({});
+                });
+                it('should handle json string in the result field', () => {
+                    const json = { foo: 'bar' };
+                    const response = { result: JSON.stringify(json) };
+                    expect(parseQueryAPIExecuteResponse(response)).toEqual({});
+                });
+                it('should handle object with request plan in the result field', () => {
+                    const response = { result: { queries: 'some queries' } };
+                    expect(parseQueryAPIExecuteResponse(response)).toEqual({});
+                });
+            });
+            describe('should correctly parse data', () => {
+                it('should parse modern schema result to KeyValueRow', () => {
+                    const response = {
+                        result: [['42', 'hello world']],
+                        columns: [
+                            {
+                                name: 'id',
+                                type: 'Uint64?',
+                            },
+                            {
+                                name: 'value',
+                                type: 'Utf8?',
+                            },
+                        ],
+                    };
+                    const parsedResponse = parseQueryAPIExecuteResponse(response);
+                    expect(parsedResponse.result).toEqual([
+                        {
+                            id: '42',
+                            value: 'hello world',
+                        },
+                    ]);
+                    expect(parsedResponse.columns).toEqual(response.columns);
+                });
+                it('should return KeyValueRow result for ydb and classic schemas unchanged', () => {
+                    const response = { result: [{ foo: 'bar' }] };
+                    expect(parseQueryAPIExecuteResponse(response).result).toEqual(response.result);
+                });
+                it('shoudl return stats for modern schema', () => {
+                    const result = [['42', 'hello world']];
+                    const columns = [
+                        {
+                            name: 'id',
+                            type: 'Uint64?',
+                        },
+                        {
+                            name: 'value',
+                            type: 'Utf8?',
+                        },
+                    ];
+                    const stats = { metric: 'good' };
+                    const response = { result, columns, stats };
+                    const parsedResponse = parseQueryAPIExecuteResponse(response);
+                    expect(parsedResponse.result).toEqual([
+                        {
+                            id: '42',
+                            value: 'hello world',
+                        },
+                    ]);
+                    expect(parsedResponse.columns).toEqual(response.columns);
+                    expect(parsedResponse.stats).toEqual(response.stats);
+                });
+                it('shoudl return stats for ydb and classic schemas', () => {
+                    const result = [{ foo: 'bar' }];
+                    const stats = { metric: 'good' };
+                    const response = { result, stats };
+                    const parsedResponse = parseQueryAPIExecuteResponse(response);
+                    expect(parsedResponse.result).toEqual(response.result);
+                    expect(parsedResponse.stats).toEqual(response.stats);
+                });
+                it('should accept stats without a result', () => {
+                    const stats = { metric: 'good' };
+                    const response = { stats };
+                    const actual = parseQueryAPIExecuteResponse(response);
+                    expect(actual.result).toBeUndefined();
+                    expect(actual.columns).toBeUndefined();
+                    expect(actual.stats).toEqual(response.stats);
+                });
+            });
+        });
+        describe('parseQueryAPIExplainResponse', () => {
+            describe('should handle responses with incorrect format', () => {
+                it('should handle null response', () => {
+                    expect(parseQueryAPIExecuteResponse(null)).toEqual({});
+                });
+                it('should handle undefined response', () => {
+                    expect(parseQueryAPIExecuteResponse(undefined)).toEqual({});
+                });
+                it('should handle object with plan in the result field', () => {
+                    const response = { result: { foo: 'bar' } };
+                    expect(parseQueryAPIExecuteResponse(response)).toEqual({});
+                });
+            });
+            describe('should correctly parse data', () => {
+                it('should parse explain-scan', () => {
+                    const plan = {};
+                    const tables = [];
+                    const meta = { version: '0.2', type: 'script' };
+                    const ast = 'ast';
+                    const response = { plan: { Plan: plan, tables, meta }, ast };
+                    expect(parseQueryAPIExplainResponse(response)).toBe(response);
+                });
+                it('should parse explain-script', () => {
+                    const plan = {};
+                    const tables = [];
+                    const meta = { version: '0.2', type: 'script' };
+                    const response = {
+                        plan: { queries: [{ Plan: plan, tables }], meta },
+                    };
+                    expect(parseQueryAPIExplainResponse(response)).toBe(response);
+                });
+            });
+        });
+        describe('parseQueryExplainPlan', () => {
+            it('should parse explain script plan to explain scan', () => {
+                const plan = {};
+                const tables = [];
+                const meta = { version: '0.2', type: 'script' };
+                const rawPlan = {
+                    queries: [
+                        {
+                            Plan: plan,
+                            tables,
+                        },
+                    ],
+                    meta,
+                };
+                const parsedPlan = parseQueryExplainPlan(rawPlan);
+                expect(parsedPlan.Plan).toEqual(plan);
+                expect(parsedPlan.tables).toBe(tables);
+                expect(parsedPlan.meta).toEqual(meta);
+            });
+            it('should left scan plan unchanged', () => {
+                const plan = {};
+                const tables = [];
+                const meta = { version: '0.2', type: 'script' };
+                const rawPlan = {
+                    Plan: plan,
+                    tables: tables,
+                    meta: meta,
+                };
+                const parsedPlan = parseQueryExplainPlan(rawPlan);
+                expect(parsedPlan).toEqual(rawPlan);
+            });
+        });
+    });
+});

package/dist/utils/registerError.d.ts

@@ -0,0 +1 @@
+export declare function registerError(error: Error, message?: string, type?: string): void;

package/dist/utils/registerError.js

@@ -0,0 +1,17 @@
+export function registerError(error, message, type = 'error') {
+    var _a;
+    if (typeof window !== 'undefined' && ((_a = window.Ya) === null || _a === void 0 ? void 0 : _a.Rum)) {
+        window.Ya.Rum.logError({
+            additional: {
+                url: window.location.href,
+            },
+            type,
+            message,
+            level: window.Ya.Rum.ERROR_LEVEL.ERROR,
+        }, error);
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.error(error);
+    }
+}

package/dist/utils/storage.d.ts

@@ -0,0 +1,28 @@
+import type { TVSlotId, TVDiskStateInfo } from '../types/api/vdisk';
+import type { ValueOf } from '../types/common';
+export declare const isFullVDiskData: (disk: TVDiskStateInfo | TVSlotId) => disk is TVDiskStateInfo;
+interface EntityWithUsage {
+    Used: number;
+    Limit: number;
+}
+export declare const getUsage: <T extends EntityWithUsage>(data: T, step?: number) => number;
+/**
+ * Values to sort /storage v2 response
+ *
+ * Source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/json_storage.h
+ */
+export declare const STORAGE_SORT_VALUES: {
+    readonly PoolName: "PoolName";
+    readonly Kind: "Kind";
+    readonly Erasure: "Erasure";
+    readonly Degraded: "Degraded";
+    readonly Usage: "Usage";
+    readonly GroupId: "GroupId";
+    readonly Used: "Used";
+    readonly Limit: "Limit";
+    readonly Read: "Read";
+    readonly Write: "Write";
+};
+export declare type StorageSortValue = ValueOf<typeof STORAGE_SORT_VALUES>;
+export declare const isSortableStorageProperty: (value: string) => value is StorageSortValue;
+export {};

package/dist/utils/storage.js

@@ -0,0 +1,24 @@
+export const isFullVDiskData = (disk) => 'VDiskId' in disk;
+export const getUsage = (data, step = 1) => {
+    // if limit is 0, display 0
+    const usage = data.Limit ? (data.Used * 100) / data.Limit : 0;
+    return Math.floor(usage / step) * step;
+};
+/**
+ * Values to sort /storage v2 response
+ *
+ * Source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/json_storage.h
+ */
+export const STORAGE_SORT_VALUES = {
+    PoolName: 'PoolName',
+    Kind: 'Kind',
+    Erasure: 'Erasure',
+    Degraded: 'Degraded',
+    Usage: 'Usage',
+    GroupId: 'GroupId',
+    Used: 'Used',
+    Limit: 'Limit',
+    Read: 'Read',
+    Write: 'Write',
+};
+export const isSortableStorageProperty = (value) => Object.values(STORAGE_SORT_VALUES).includes(value);

package/dist/utils/tablet.d.ts

@@ -0,0 +1,5 @@
+import { EFlag } from '../types/api/enums';
+import { ETabletState } from '../types/api/tablet';
+export declare const tabletStates: string[];
+export declare const tabletColorToTabletState: Record<EFlag, ETabletState[]>;
+export declare const mapTabletStateToColorState: (state?: ETabletState | EFlag | undefined) => EFlag;

package/dist/utils/tablet.js

@@ -0,0 +1,41 @@
+import { EFlag } from '../types/api/enums';
+import { ETabletState } from '../types/api/tablet';
+// Similar to mapping in https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/viewer.cpp
+const tabletStateToColorState = {
+    [ETabletState.Dead]: EFlag.Red,
+    [ETabletState.Created]: EFlag.Yellow,
+    [ETabletState.ResolveStateStorage]: EFlag.Yellow,
+    [ETabletState.Candidate]: EFlag.Yellow,
+    [ETabletState.BlockBlobStorage]: EFlag.Yellow,
+    [ETabletState.WriteZeroEntry]: EFlag.Yellow,
+    [ETabletState.Restored]: EFlag.Yellow,
+    [ETabletState.Discover]: EFlag.Yellow,
+    [ETabletState.Lock]: EFlag.Yellow,
+    [ETabletState.Stopped]: EFlag.Yellow,
+    [ETabletState.ResolveLeader]: EFlag.Yellow,
+    [ETabletState.RebuildGraph]: EFlag.Yellow,
+    [ETabletState.Deleted]: EFlag.Green,
+    [ETabletState.Active]: EFlag.Green,
+};
+export const tabletStates = Object.keys(ETabletState);
+export const tabletColorToTabletState = Object.entries(tabletStateToColorState).reduce((acc, [state, color]) => {
+    if (acc[color]) {
+        acc[color].push(state);
+    }
+    else {
+        acc[color] = [state];
+    }
+    return acc;
+}, {});
+// Tablet State in different versions or in different endpoint
+// could be represented as ETabletState of EFlag
+export const mapTabletStateToColorState = (state) => {
+    if (!state) {
+        return EFlag.Grey;
+    }
+    const isEFlag = (value) => Object.values(EFlag).includes(value);
+    if (isEFlag(state)) {
+        return state;
+    }
+    return tabletStateToColorState[state];
+};

package/dist/utils/timeParsers/__test__/formatDuration.test.d.ts

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

package/dist/utils/timeParsers/__test__/formatDuration.test.js

@@ -0,0 +1,39 @@
+import { formatDurationToShortTimeFormat } from '../formatDuration';
+import i18n from '../i18n';
+describe('formatDurationToShortTimeFormat', () => {
+    // 1 - ms
+    const timeWithMs = 123;
+    const formattedTimeWithMs = i18n('ms', { seconds: 0, ms: 123 });
+    // 2 - seconds and ms
+    const timeWithSecondsAndMsInMs = 12345;
+    const formattedTimeWithSecondsAndMs = i18n('secMs', { seconds: 12, ms: 345 });
+    // 3 - minutes
+    const timeWithMinutesInMs = 754567;
+    const formattedTimeWithMinutes = i18n('minSec', { minutes: 12, seconds: 34 });
+    // 4 - hours
+    const timeWithHoursInMs = 9245678;
+    const formattedTimeWithHours = i18n('hoursMin', { hours: 2, minutes: 34 });
+    // 5 - days
+    const timeWithDaysInMs = 439234123;
+    const formattedTimeWithDays = i18n('daysHours', { days: 5, hours: 2 });
+    // 6 - zero
+    const formattedZero = i18n('ms', { seconds: 0, ms: 0 });
+    it('should return ms on values less than second', () => {
+        expect(formatDurationToShortTimeFormat(timeWithMs)).toEqual(formattedTimeWithMs);
+    });
+    it('should return seconds and ms', () => {
+        expect(formatDurationToShortTimeFormat(timeWithSecondsAndMsInMs)).toEqual(formattedTimeWithSecondsAndMs);
+    });
+    it('should return minutes and seconds', () => {
+        expect(formatDurationToShortTimeFormat(timeWithMinutesInMs)).toEqual(formattedTimeWithMinutes);
+    });
+    it('should return hours and minutes', () => {
+        expect(formatDurationToShortTimeFormat(timeWithHoursInMs)).toEqual(formattedTimeWithHours);
+    });
+    it('should return days and hours', () => {
+        expect(formatDurationToShortTimeFormat(timeWithDaysInMs)).toEqual(formattedTimeWithDays);
+    });
+    it('should process zero values', () => {
+        expect(formatDurationToShortTimeFormat(0)).toEqual(formattedZero);
+    });
+});

package/dist/utils/timeParsers/__test__/protobuf.test.d.ts

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

package/dist/utils/timeParsers/__test__/protobuf.test.js

@@ -0,0 +1,63 @@
+import { parseProtobufDurationToMs, parseProtobufTimeObjectToMs, parseProtobufTimestampToMs, } from '../';
+describe('Protobuf time parsers', () => {
+    // 1 - nanoseconds only
+    const timeObjectWithNanoseconds = {
+        nanos: 123000000,
+    };
+    const timeWithNanosecondsInMs = 123;
+    // 2 - seconds only
+    const timeObjectWithSeconds = {
+        seconds: '12',
+    };
+    const timeWithSecondsInMs = 12000;
+    const stringDurationSeconds = '12s';
+    // 3 - days
+    const timeObjectWithDays = {
+        seconds: '439234',
+        nanos: 123000000,
+    };
+    const timeWithDaysInMs = 439234123;
+    // 4 - TimeStamp
+    const timestamp = '2023-01-16T14:26:34.466Z';
+    const timestampInMs = 1673879194466;
+    const timestampObject = {
+        seconds: '1673879194',
+        nanos: 466000000,
+    };
+    describe('parseProtobufTimeObjectToMs', () => {
+        it('should work with timestamp object values', () => {
+            expect(parseProtobufTimeObjectToMs(timeObjectWithDays)).toEqual(timeWithDaysInMs);
+        });
+        it('should work with timestamp object without seconds', () => {
+            expect(parseProtobufTimeObjectToMs(timeObjectWithNanoseconds)).toEqual(timeWithNanosecondsInMs);
+        });
+        it('should work with timestamp object without nanos', () => {
+            expect(parseProtobufTimeObjectToMs(timeObjectWithSeconds)).toEqual(timeWithSecondsInMs);
+        });
+        it('should work with empty object values', () => {
+            expect(parseProtobufTimeObjectToMs({})).toEqual(0);
+        });
+    });
+    describe('parseProtobufTimestampToMs', () => {
+        it('should work with string date values', () => {
+            expect(parseProtobufTimestampToMs(timestamp)).toEqual(timestampInMs);
+        });
+        it('should work with timestamp object values', () => {
+            expect(parseProtobufTimestampToMs(timestampObject)).toEqual(timestampInMs);
+        });
+        it('should work with empty object values', () => {
+            expect(parseProtobufTimestampToMs({})).toEqual(0);
+        });
+    });
+    describe('parseProtobufDurationToMs', () => {
+        it('should work with string values', () => {
+            expect(parseProtobufDurationToMs(stringDurationSeconds)).toEqual(timeWithSecondsInMs);
+        });
+        it('should work with duration object values', () => {
+            expect(parseProtobufDurationToMs(timeObjectWithDays)).toEqual(timeWithDaysInMs);
+        });
+        it('should work with empty object values', () => {
+            expect(parseProtobufDurationToMs({})).toEqual(0);
+        });
+    });
+});

package/dist/utils/timeParsers/formatDuration.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Process time difference in ms and returns formated time.
+ * By default only two major values are returned (days & hours, hours & minutes, minutes & seconds, etc.).
+ * It can be altered with valuesCount arg
+ *
+ * value - duration in ms
+ */
+export declare const formatDurationToShortTimeFormat: (value: number, valuesCount?: 1 | 2) => string;
+/**
+ * Parse ms duration to string
+ */
+export declare const formatToMs: (value: number) => string;