ydb-embedded-ui 5.2.1 → 5.3.0

package/dist/utils/yqlSuggestions/generateSuggestions.js

@@ -0,0 +1,252 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { AggregateFunctions, Pragmas, SimpleFunctions, SimpleTypes, TableFunction, Udfs, WindowFunctions, } from './constants';
+const re = /[\s'"-/@]/;
+function wrapStringToBackticks(value) {
+    let result = value;
+    if (value.match(re)) {
+        result = `\`${value}\``;
+    }
+    return result;
+}
+function removeBackticks(value) {
+    let normalizedValue = value;
+    if (value.startsWith('`')) {
+        normalizedValue = value.slice(1, -1);
+    }
+    return normalizedValue;
+}
+const SuggestionsWeight = {
+    suggestTemplates: 0,
+    suggestPragmas: 1,
+    suggestEntity: 2,
+    suggestColumns: 3,
+    suggestColumnAliases: 4,
+    suggestKeywords: 5,
+    suggestAggregateFunctions: 6,
+    suggestTableFunctions: 7,
+    suggestWindowFunctions: 8,
+    suggestFunctions: 9,
+    suggestUdfs: 10,
+    suggestSimpleTypes: 11,
+};
+const KEEP_CACHE_MILLIS = 5 * 60 * 1000;
+function getColumnsWithCache() {
+    const cache = new Map();
+    return async (path) => {
+        var _a, _b, _c, _d;
+        const normalizedPath = removeBackticks(path);
+        const existed = cache.get(path);
+        if (existed) {
+            return existed;
+        }
+        const columns = [];
+        const data = await window.api.getDescribe({ path: normalizedPath });
+        if ((data === null || data === void 0 ? void 0 : data.Status) === 'StatusSuccess') {
+            const desc = data.PathDescription;
+            if ((_a = desc === null || desc === void 0 ? void 0 : desc.Table) === null || _a === void 0 ? void 0 : _a.Columns) {
+                for (const c of desc.Table.Columns) {
+                    if (c.Name) {
+                        columns.push(c.Name);
+                    }
+                }
+            }
+            if ((_c = (_b = desc === null || desc === void 0 ? void 0 : desc.ColumnTableDescription) === null || _b === void 0 ? void 0 : _b.Schema) === null || _c === void 0 ? void 0 : _c.Columns) {
+                for (const c of desc.ColumnTableDescription.Schema.Columns) {
+                    if (c.Name) {
+                        columns.push(c.Name);
+                    }
+                }
+            }
+            if ((_d = desc === null || desc === void 0 ? void 0 : desc.ExternalTableDescription) === null || _d === void 0 ? void 0 : _d.Columns) {
+                for (const c of desc.ExternalTableDescription.Columns) {
+                    if (c.Name) {
+                        columns.push(c.Name);
+                    }
+                }
+            }
+        }
+        cache.set(path, columns);
+        setTimeout(() => {
+            cache.delete(path);
+        }, KEEP_CACHE_MILLIS);
+        return columns;
+    };
+}
+const getColumns = getColumnsWithCache();
+function getSuggestionIndex(suggestionType) {
+    return SuggestionsWeight[suggestionType];
+}
+async function getSimpleFunctions() {
+    return SimpleFunctions;
+}
+async function getWindowFunctions() {
+    return WindowFunctions;
+}
+async function getTableFunctions() {
+    return TableFunction;
+}
+async function getAggregateFunctions() {
+    return AggregateFunctions;
+}
+async function getPragmas() {
+    return Pragmas;
+}
+async function getUdfs() {
+    return Udfs;
+}
+async function getSimpleTypes() {
+    return SimpleTypes;
+}
+export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggestColumns, database) {
+    var _a;
+    if (!(suggestColumns === null || suggestColumns === void 0 ? void 0 : suggestColumns.tables)) {
+        return [];
+    }
+    const suggestions = [];
+    const multi = suggestColumns.tables.length > 1;
+    for (const entity of (_a = suggestColumns.tables) !== null && _a !== void 0 ? _a : []) {
+        let normalizedEntityName = removeBackticks(entity.name);
+        // if it's relative entity path
+        if (!normalizedEntityName.startsWith('/')) {
+            normalizedEntityName = `${database}/${normalizedEntityName}`;
+        }
+        const fields = await getColumns(normalizedEntityName);
+        fields.forEach((columnName) => {
+            const normalizedName = wrapStringToBackticks(columnName);
+            let columnNameSuggestion = normalizedName;
+            if (entity.alias) {
+                columnNameSuggestion = `${entity.alias}.${normalizedName}`;
+            }
+            else if (multi) {
+                // no need to wrap entity.name to backticks, because it's already with them if needed
+                columnNameSuggestion = `${entity.name}.${normalizedName}`;
+            }
+            suggestions.push({
+                label: columnNameSuggestion,
+                insertText: columnNameSuggestion,
+                kind: monaco.languages.CompletionItemKind.Field,
+                detail: 'Column',
+                range: rangeToInsertSuggestion,
+                sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')),
+            });
+        });
+    }
+    return suggestions;
+}
+export function generateColumnAliasesSuggestion(rangeToInsertSuggestion, suggestColumnAliases) {
+    if (!suggestColumnAliases) {
+        return [];
+    }
+    return suggestColumnAliases === null || suggestColumnAliases === void 0 ? void 0 : suggestColumnAliases.map((columnAliasSuggestion) => ({
+        label: columnAliasSuggestion.name,
+        insertText: columnAliasSuggestion.name,
+        kind: monaco.languages.CompletionItemKind.Field,
+        detail: 'Column alias',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumnAliases')),
+    }));
+}
+export function generateKeywordsSuggestion(rangeToInsertSuggestion, suggestKeywords) {
+    if (!suggestKeywords) {
+        return [];
+    }
+    return suggestKeywords === null || suggestKeywords === void 0 ? void 0 : suggestKeywords.map((keywordSuggestion) => ({
+        label: keywordSuggestion.value,
+        insertText: keywordSuggestion.value,
+        kind: monaco.languages.CompletionItemKind.Keyword,
+        detail: 'Keyword',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestKeywords')),
+    }));
+}
+export async function generateEntitiesSuggestion(_rangeToInsertSuggestion) {
+    return [];
+}
+export async function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion) {
+    const functions = await getSimpleFunctions();
+    return functions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestFunctions')),
+    }));
+}
+export async function generateSimpleTypesSuggestion(rangeToInsertSuggestion) {
+    const simpleTypes = await getSimpleTypes();
+    return simpleTypes.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.TypeParameter,
+        detail: 'Type',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestSimpleTypes')),
+    }));
+}
+export async function generateUdfSuggestion(rangeToInsertSuggestion) {
+    const udfs = await getUdfs();
+    return udfs.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'UDF',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestUdfs')),
+    }));
+}
+export async function generateWindowFunctionsSuggestion(rangeToInsertSuggestion) {
+    const windowFunctions = await getWindowFunctions();
+    return windowFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Window function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestWindowFunctions')),
+    }));
+}
+export async function generateTableFunctionsSuggestion(rangeToInsertSuggestion) {
+    const tableFunctions = await getTableFunctions();
+    return tableFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Table function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestTableFunctions')),
+    }));
+}
+export async function generateAggregateFunctionsSuggestion(rangeToInsertSuggestion) {
+    const aggreagteFunctions = await getAggregateFunctions();
+    return aggreagteFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Function,
+        detail: 'Aggregate function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestAggregateFunctions')),
+    }));
+}
+export async function generatePragmasSuggestion(rangeToInsertSuggestion) {
+    const pragmas = await getPragmas();
+    return pragmas.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: monaco.languages.CompletionItemKind.Module,
+        detail: 'Pragma',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestPragmas')),
+    }));
+}
+const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+function suggestionIndexToWeight(index) {
+    const characterInsideAlphabet = alphabet[index];
+    if (characterInsideAlphabet) {
+        return characterInsideAlphabet;
+    }
+    const duplicateTimes = Math.floor(index / alphabet.length);
+    const remains = index % alphabet.length;
+    const lastCharacter = alphabet.slice(-1);
+    return lastCharacter.repeat(duplicateTimes) + alphabet[remains];
+}

package/dist/utils/yqlSuggestions/yqlSuggestions.d.ts

@@ -0,0 +1,4 @@
+import type Monaco from 'monaco-editor';
+export declare function createProvideSuggestionsFunction(database: string): (model: Monaco.editor.ITextModel, monacoCursorPosition: Monaco.Position, _context: Monaco.languages.CompletionContext, _token: Monaco.CancellationToken) => Promise<{
+    suggestions: Monaco.languages.CompletionItem[];
+}>;

package/dist/utils/yqlSuggestions/yqlSuggestions.js

@@ -0,0 +1,76 @@
+import { parseYqlQuery } from '@gravity-ui/websql-autocomplete';
+import { generateAggregateFunctionsSuggestion, generateColumnAliasesSuggestion, generateColumnsSuggestion, generateEntitiesSuggestion, generateKeywordsSuggestion, generatePragmasSuggestion, generateSimpleFunctionsSuggestion, generateSimpleTypesSuggestion, generateTableFunctionsSuggestion, generateUdfSuggestion, generateWindowFunctionsSuggestion, } from './generateSuggestions';
+export function createProvideSuggestionsFunction(database) {
+    return async (model, monacoCursorPosition, _context, _token) => {
+        const cursorPosition = {
+            line: monacoCursorPosition.lineNumber,
+            column: monacoCursorPosition.column,
+        };
+        const rangeToInsertSuggestion = getRangeToInsertSuggestion(model, monacoCursorPosition);
+        const suggestions = await getSuggestions(model, cursorPosition, rangeToInsertSuggestion, database);
+        return { suggestions };
+    };
+}
+async function getSuggestions(model, cursorPosition, rangeToInsertSuggestion, database) {
+    const parseResult = parseYqlQuery(model.getValue(), cursorPosition);
+    let entitiesSuggestions = [];
+    let functionsSuggestions = [];
+    let aggregateFunctionsSuggestions = [];
+    let windowFunctionsSuggestions = [];
+    let tableFunctionsSuggestions = [];
+    let udfsSuggestions = [];
+    let simpleTypesSuggestions = [];
+    let pragmasSuggestions = [];
+    if (parseResult.suggestEntity) {
+        entitiesSuggestions = await generateEntitiesSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestFunctions) {
+        functionsSuggestions = await generateSimpleFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestAggregateFunctions) {
+        aggregateFunctionsSuggestions = await generateAggregateFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestWindowFunctions) {
+        windowFunctionsSuggestions = await generateWindowFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestTableFunctions) {
+        tableFunctionsSuggestions = await generateTableFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestSimpleTypes) {
+        simpleTypesSuggestions = await generateSimpleTypesSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestUdfs) {
+        udfsSuggestions = await generateUdfSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestPragmas) {
+        pragmasSuggestions = await generatePragmasSuggestion(rangeToInsertSuggestion);
+    }
+    const columnAliasSuggestion = await generateColumnAliasesSuggestion(rangeToInsertSuggestion, parseResult.suggestColumnAliases);
+    const columnsSuggestions = await generateColumnsSuggestion(rangeToInsertSuggestion, parseResult.suggestColumns, database);
+    const keywordsSuggestions = generateKeywordsSuggestion(rangeToInsertSuggestion, parseResult.suggestKeywords);
+    const suggestions = [
+        ...entitiesSuggestions,
+        ...functionsSuggestions,
+        ...windowFunctionsSuggestions,
+        ...tableFunctionsSuggestions,
+        ...udfsSuggestions,
+        ...simpleTypesSuggestions,
+        ...pragmasSuggestions,
+        ...columnAliasSuggestion,
+        ...columnsSuggestions,
+        ...keywordsSuggestions,
+        ...aggregateFunctionsSuggestions,
+    ];
+    return suggestions;
+}
+function getRangeToInsertSuggestion(model, cursorPosition) {
+    const { startColumn: lastWordStartColumn, endColumn: lastWordEndColumn } = model.getWordUntilPosition(cursorPosition);
+    // https://github.com/microsoft/Monaco-editor/discussions/3639#discussioncomment-5190373 if user already typed "$" sign, it should not be duplicated
+    const dollarBeforeLastWordStart = model.getLineContent(cursorPosition.lineNumber)[lastWordStartColumn - 2] === '$' ? 1 : 0;
+    return {
+        startColumn: lastWordStartColumn - dollarBeforeLastWordStart,
+        startLineNumber: cursorPosition.lineNumber,
+        endColumn: lastWordEndColumn,
+        endLineNumber: cursorPosition.lineNumber,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-embedded-ui",
-  "version": "5.2.1",
+  "version": "5.3.0",
   "files": [
     "dist"
   ],
@@ -10,7 +10,7 @@
     "url": "git@github.com:ydb-platform/ydb-embedded-ui.git"
   },
   "dependencies": {
-    "@gravity-ui/axios-wrapper": "^1.3.0",
+    "@gravity-ui/axios-wrapper": "^1.4.1",
     "@gravity-ui/chartkit": "^4.20.1",
     "@gravity-ui/components": "^2.12.0",
     "@gravity-ui/date-utils": "^1.4.2",
@@ -20,7 +20,9 @@
     "@gravity-ui/paranoid": "^1.4.0",
     "@gravity-ui/react-data-table": "^1.2.0",
     "@gravity-ui/uikit": "^5.30.1",
-    "axios": "^0.21.2",
+    "@gravity-ui/websql-autocomplete": "^8.0.2",
+    "@reduxjs/toolkit": "^2.2.1",
+    "axios": "^1.6.7",
     "bem-cn-lite": "^4.1.0",
     "copy-to-clipboard": "^3.3.3",
     "crc-32": "^1.2.2",
@@ -31,18 +33,17 @@
     "path-to-regexp": "^3.0.0",
     "qs": "^6.11.0",
     "react-error-boundary": "^4.0.12",
-    "react-json-inspector": "^7.1.1",
     "react-helmet-async": "2.0.4",
+    "react-json-inspector": "^7.1.1",
     "react-list": "^0.8.11",
     "react-monaco-editor": "^0.47.0",
     "react-redux": "^7.2.6",
     "react-router": "^5.2.1",
     "react-router-dom": "^5.3.0",
     "react-split": "^2.0.14",
-    "redux": "^4.0.1",
-    "redux-location-state": "^2.6.0",
-    "redux-thunk": "^2.3.0",
-    "reselect": "^4.1.6",
+    "redux": "^5.0.1",
+    "redux-location-state": "^2.8.2",
+    "tslib": "^2.6.2",
     "url": "^0.11.0",
     "use-query-params": "^2.2.1",
     "web-vitals": "^1.1.2",
@@ -99,7 +100,8 @@
     ],
     "testEnvironment": "jsdom",
     "moduleNameMapper": {
-      "\\.(css|less|scss|sass)$": "jest-transform-css"
+      "\\.(css|less|scss|sass)$": "jest-transform-css",
+      "^axios$": "axios/dist/node/axios.cjs"
     }
   },
   "browserslist": {
@@ -141,6 +143,7 @@
     "npm-run-all": "^4.1.5",
     "postcss": "^8.4.6",
     "prettier": "^2.5.1",
+    "prop-types": "^15.8.1",
     "react": "^17.0.2",
     "react-app-rewired": "^2.1.11",
     "react-dom": "^17.0.2",
@@ -151,12 +154,13 @@
     "typescript": "^4.5.5"
   },
   "peerDependencies": {
+    "prop-types": "^15.8.1",
     "react": "^17.0.2",
     "react-dom": "^17.0.2"
   },
   "overrides": {
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
-    "redux": "^4.0.1"
+    "redux": "^5.0.1"
   }
 }

package/dist/assets/icons/flask.svg

@@ -1,3 +0,0 @@
-<svg width="16" height="16" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512">
-    <path d="M437.2 403.5L320 215V64h8c13.3 0 24-10.7 24-24V24c0-13.3-10.7-24-24-24H120c-13.3 0-24 10.7-24 24v16c0 13.3 10.7 24 24 24h8v151L10.8 403.5C-18.5 450.6 15.3 512 70.9 512h306.2c55.7 0 89.4-61.5 60.1-108.5zM137.9 320l48.2-77.6c3.7-5.2 5.8-11.6 5.8-18.4V64h64v160c0 6.9 2.2 13.2 5.8 18.4l48.2 77.6h-172z"/>
-</svg>

package/dist/assets/icons/star.svg

@@ -1 +0,0 @@
-<svg aria-hidden="true" focusable="false" data-prefix="fas" data-icon="star" class="svg-inline--fa fa-star" role="img" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path fill="currentColor" d="M316.7 17.8l65.43 132.4l146.4 21.29c26.27 3.796 36.79 36.09 17.75 54.59l-105.9 102.1l25.05 145.5c4.508 26.31-23.23 45.9-46.49 33.7L288 439.6l-130.9 68.7C133.8 520.5 106.1 500.9 110.6 474.6l25.05-145.5L29.72 226.1c-19.03-18.5-8.516-50.79 17.75-54.59l146.4-21.29l65.43-132.4C271.1-6.083 305-5.786 316.7 17.8z"></path></svg>

package/dist/components/ExternalLinkWithIcon/ExternalLinkWithIcon.d.ts

@@ -1,7 +0,0 @@
-import './ExternalLinkWithIcon.scss';
-interface ExternalLinkWithIconProps {
-    title: string;
-    url: string;
-}
-export declare const ExternalLinkWithIcon: ({ title, url }: ExternalLinkWithIconProps) => JSX.Element;
-export {};

package/dist/components/ExternalLinkWithIcon/ExternalLinkWithIcon.js

@@ -1,9 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import block from 'bem-cn-lite';
-import { Link } from '@gravity-ui/uikit';
-import { Icon } from '../Icon/Icon';
-import './ExternalLinkWithIcon.scss';
-const b = block('ydb-external-link-with-icon');
-export const ExternalLinkWithIcon = ({ title, url }) => {
-    return (_jsxs(Link, Object.assign({ href: url, target: "_blank", className: b() }, { children: [title, '\u00a0', _jsx(Icon, { name: "external", viewBox: '0 0 16 16', width: 16, height: 16 })] })));
-};

package/dist/containers/Cluster/ClusterInfoSkeleton/ClusterInfoSkeleton.d.ts

@@ -1,7 +0,0 @@
-import './ClusterInfoSkeleton.scss';
-interface ClusterInfoSkeletonProps {
-    className?: string;
-    rows?: number;
-}
-export declare const ClusterInfoSkeleton: ({ rows, className }: ClusterInfoSkeletonProps) => JSX.Element;
-export {};

package/dist/containers/Cluster/ClusterInfoSkeleton/ClusterInfoSkeleton.js

@@ -1,7 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import block from 'bem-cn-lite';
-import { Skeleton } from '@gravity-ui/uikit';
-import './ClusterInfoSkeleton.scss';
-const b = block('ydb-cluster-info-skeleton');
-const SkeletonLabel = () => (_jsxs("div", Object.assign({ className: b('label') }, { children: [_jsx(Skeleton, { className: b('label__text') }), _jsx("div", { className: b('label__dots') })] })));
-export const ClusterInfoSkeleton = ({ rows = 8, className }) => (_jsxs("div", Object.assign({ className: b(null, className) }, { children: [[...new Array(rows)].map((_, index) => (_jsxs("div", Object.assign({ className: b('row') }, { children: [_jsx(SkeletonLabel, {}), _jsx(Skeleton, { className: b('value') })] }), `skeleton-row-${index}`))), _jsxs("div", Object.assign({ className: b('row') }, { children: [_jsx(SkeletonLabel, {}), _jsx(Skeleton, { className: b('versions') })] }), "versions")] })));

package/dist/containers/Storage/utils/constants.d.ts

@@ -1,2 +0,0 @@
-import { EDiskStateSeverity } from '../DiskStateProgressBar';
-export declare const NOT_AVAILABLE_SEVERITY = EDiskStateSeverity.Grey;

package/dist/containers/Storage/utils/constants.js

@@ -1,2 +0,0 @@
-import { EDiskStateSeverity } from '../DiskStateProgressBar';
-export const NOT_AVAILABLE_SEVERITY = EDiskStateSeverity.Grey;

package/dist/store/reducers/healthcheckInfo.d.ts

@@ -1,21 +0,0 @@
-import { Selector } from 'reselect';
-import { Reducer } from 'redux';
-import type { IHealthCheckInfoAction, IHealthcheckInfoRootStateSlice, IHealthcheckInfoState, IIssuesTree } from '../../types/store/healthcheck';
-import type { IssueLog, StatusFlag } from '../../types/api/healthcheck';
-export declare const FETCH_HEALTHCHECK: {
-    readonly REQUEST: "cluster/FETCH_HEALTHCHECK_REQUEST";
-    readonly SUCCESS: "cluster/FETCH_HEALTHCHECK_SUCCESS";
-    readonly FAILURE: "cluster/FETCH_HEALTHCHECK_FAILURE";
-};
-declare const healthcheckInfo: Reducer<IHealthcheckInfoState, IHealthCheckInfoAction>;
-export declare const selectIssuesTreesRoots: Selector<IHealthcheckInfoRootStateSlice, IssueLog[]>;
-export declare const selectIssuesTrees: Selector<IHealthcheckInfoRootStateSlice, IIssuesTree[]>;
-export declare const selectIssuesStatistics: Selector<IHealthcheckInfoRootStateSlice, [
-    StatusFlag,
-    number
-][]>;
-export declare function getHealthcheckInfo(database: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
-export declare const setDataWasNotLoaded: () => {
-    readonly type: "healthcheckInfo/SET_DATA_WAS_NOT_LOADED";
-};
-export default healthcheckInfo;

package/dist/types/store/healthcheck.d.ts

@@ -1,20 +0,0 @@
-import { ApiRequestAction } from '../../store/utils';
-import { FETCH_HEALTHCHECK, setDataWasNotLoaded } from '../../store/reducers/healthcheckInfo';
-import { IResponseError } from '../api/error';
-import type { HealthCheckAPIResponse, IssueLog } from '../api/healthcheck';
-export interface IIssuesTree extends IssueLog {
-    reasonsItems?: IIssuesTree[];
-}
-export declare type IHealthCheck = HealthCheckAPIResponse;
-export interface IHealthcheckInfoState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data?: HealthCheckAPIResponse;
-    error?: IResponseError;
-}
-declare type IHealthCheckApiRequestAction = ApiRequestAction<typeof FETCH_HEALTHCHECK, HealthCheckAPIResponse, IResponseError>;
-export declare type IHealthCheckInfoAction = IHealthCheckApiRequestAction | ReturnType<typeof setDataWasNotLoaded>;
-export interface IHealthcheckInfoRootStateSlice {
-    healthcheckInfo: IHealthcheckInfoState;
-}
-export {};

package/dist/utils/pdisk.d.ts

@@ -1,17 +0,0 @@
-import type { TPDiskStateInfo } from '../types/api/pdisk';
-/**
- * Parses a binary string containing a bit field into an object with binary values.
- * This is an implementation based on string manipulation, since JS can only perform
- * bitwise operations with 32-bits integers, and YDB sends uint64.
- * @see https://en.cppreference.com/w/c/language/bit_field
- * @param binaryString - binary string representing a bit field
- * @param bitFieldStruct - bit field description, <field => size in bits>, in order starting from the rightmost bit
- * @returns object with binary values
- */
-export declare const parseBitField: <T extends Record<string, number>>(binaryString: string, bitFieldStruct: T) => Record<keyof T, string>;
-export declare enum IPDiskType {
-    HDD = "HDD",
-    SSD = "SSD",
-    MVME = "NVME"
-}
-export declare const getPDiskType: (data: TPDiskStateInfo) => IPDiskType | undefined;