ydb-embedded-ui 6.11.0 → 6.12.0

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

@@ -1,6 +1,6 @@
 export declare const vDiskApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
-    getVDiskData: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", {
+    getVDiskData: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData", {
         vDiskData: import("./types").VDiskData;
         groupData: Partial<import("../storage/types").PreparedStorageGroup> | undefined;
     } | undefined, "api">;
-}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/store/reducers/vdisk/vdisk.js

@@ -26,7 +26,7 @@ export const vDiskApi = api.injectEndpoints({
 async function requestVDiskData({ nodeId, pDiskId, vDiskSlotId }, { signal } = {}) {
     const vDiskDataResponse = await Promise.all([
         window.api.getVDiskInfo({ nodeId, pDiskId, vDiskSlotId }, { signal }),
-        window.api.getPDiskInfo({ nodeId, pDiskId }, { signal }),
+        window.api.getNodeWhiteboardPDiskInfo({ nodeId, pDiskId }, { signal }),
         window.api.getNodeInfo(nodeId, { signal }),
     ]);
     const vDiskData = prepareVDiskDataResponse(vDiskDataResponse);

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

@@ -2,5 +2,5 @@ export declare const viewSchemaApi: import("@reduxjs/toolkit/query").Api<import(
     getViewSchema: import("@reduxjs/toolkit/query").QueryDefinition<{
         database: string;
         path: string;
-    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/query").ColumnType[] | undefined, "api">;
-}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData", import("../../../types/api/query").ColumnType[] | undefined, "api">;
+}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/store/reducers/viewSchema/viewSchema.js

@@ -13,7 +13,7 @@ export const viewSchemaApi = api.injectEndpoints({
                         query: createViewSchemaQuery(path),
                         database,
                         action: 'execute-scan',
-                    });
+                    }, { withRetries: true });
                     if (isQueryErrorResponse(response)) {
                         return { error: response };
                     }

package/dist/store/state-url-mapping.d.ts

@@ -1,5 +1,75 @@
 import type { Action, Reducer, UnknownAction } from '@reduxjs/toolkit';
 import type { History, Location } from 'history';
+export declare const paramSetup: {
+    readonly global: {
+        readonly problemFilter: {
+            readonly stateKey: "settings.problemFilter";
+            readonly initialState: import("./reducers/settings/types").ProblemFilterValue;
+        };
+    };
+    readonly '/tenant': {
+        readonly sort: {
+            readonly stateKey: "heatmap.sort";
+            readonly initialState: boolean;
+            readonly type: "bool";
+        };
+        readonly heatmap: {
+            readonly stateKey: "heatmap.heatmap";
+            readonly initialState: boolean;
+            readonly type: "bool";
+        };
+        readonly currentMetric: {
+            readonly stateKey: "heatmap.currentMetric";
+            readonly initialState: import("../types/store/heatmap").IHeatmapMetricValue | undefined;
+        };
+        readonly stateFilter: {
+            readonly stateKey: "tablets.stateFilter";
+            readonly type: "array";
+        };
+        readonly typeFilter: {
+            readonly stateKey: "tablets.typeFilter";
+            readonly type: "array";
+        };
+        readonly tenantPage: {
+            readonly stateKey: "tenant.tenantPage";
+        };
+        readonly queryTab: {
+            readonly stateKey: "tenant.queryTab";
+        };
+        readonly diagnosticsTab: {
+            readonly stateKey: "tenant.diagnosticsTab";
+        };
+        readonly summaryTab: {
+            readonly stateKey: "tenant.summaryTab";
+        };
+        readonly metricsTab: {
+            readonly stateKey: "tenant.metricsTab";
+        };
+        readonly shardsMode: {
+            readonly stateKey: "shardsWorkload.mode";
+        };
+        readonly shardsDateFrom: {
+            readonly stateKey: "shardsWorkload.from";
+        };
+        readonly shardsDateTo: {
+            readonly stateKey: "shardsWorkload.to";
+        };
+        readonly topQueriesDateFrom: {
+            readonly stateKey: "executeTopQueries.from";
+        };
+        readonly topQueriesDateTo: {
+            readonly stateKey: "executeTopQueries.to";
+        };
+        readonly selectedConsumer: {
+            readonly stateKey: "partitions.selectedConsumer";
+        };
+    };
+    readonly '/cluster/tenants': {
+        readonly search: {
+            readonly stateKey: "tenants.searchValue";
+        };
+    };
+};
 export default function getLocationMiddleware<S = any, A extends Action = UnknownAction, P = S>(history: History, rootReducer: Reducer<S, A, P>): {
     locationMiddleware: import("redux").Middleware<{}, S, import("redux").Dispatch<{
         payload: Location<unknown>;

package/dist/store/state-url-mapping.js

@@ -9,7 +9,7 @@ import { parseQuery } from 'redux-location-state/lib/parseQuery';
 import { stateToParams } from 'redux-location-state/lib/stateToParams';
 import { initialState as initialHeatmapState } from './reducers/heatmap';
 import { initialState as initialSettingsState } from './reducers/settings/settings';
-const paramSetup = {
+export const paramSetup = {
     global: {
         problemFilter: {
             stateKey: 'settings.problemFilter',
@@ -59,19 +59,15 @@ const paramSetup = {
         },
         shardsDateFrom: {
             stateKey: 'shardsWorkload.from',
-            type: 'number',
         },
         shardsDateTo: {
             stateKey: 'shardsWorkload.to',
-            type: 'number',
         },
         topQueriesDateFrom: {
             stateKey: 'executeTopQueries.from',
-            type: 'number',
         },
         topQueriesDateTo: {
             stateKey: 'executeTopQueries.to',
-            type: 'number',
         },
         selectedConsumer: {
             stateKey: 'partitions.selectedConsumer',

package/dist/styles/mixins.scss

@@ -40,6 +40,11 @@
     line-height: var(--g-text-subheader-2-line-height);
 }
 
+@mixin subheader-3-typography() {
+    font-size: var(--g-text-subheader-3-font-size);
+    line-height: var(--g-text-subheader-3-line-height);
+}
+
 @mixin header-1-typography() {
     font-size: var(--g-text-header-1-font-size);
     line-height: var(--g-text-header-1-line-height);
@@ -285,3 +290,9 @@
         max-width: calc(100% - 50px);
     }
 }
+
+@mixin tabs-wrapper-styles() {
+    --g-tabs-border-width: 0;
+
+    box-shadow: inset 0 -1px 0 0 var(--g-color-line-generic);
+}

package/dist/types/api/acl.d.ts

@@ -13,6 +13,7 @@ export interface TMetaCommonInfo {
     Path: string;
     Owner?: string;
     ACL?: TACE[];
+    EffectiveACL?: TACE[];
 }
 export interface TACE {
     AccessType: string;

package/dist/types/api/pdisk.d.ts

@@ -1,8 +1,7 @@
 import type { EFlag } from './enums';
+import type { TVDiskStateInfo, TVSlotEntry } from './vdisk';
 /**
  * endpoint: /viewer/json/pdiskinfo
- *
- * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/node_whiteboard.proto
  */
 export interface TEvPDiskStateResponse {
     PDiskStateInfo?: TPDiskStateInfo[];
@@ -10,6 +9,11 @@ export interface TEvPDiskStateResponse {
     ResponseTime?: string;
     ResponseDuration?: number;
 }
+/**
+ * Node whiteboard PDisk data
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/node_whiteboard.proto
+ */
 export interface TPDiskStateInfo {
     PDiskId?: number;
     /** uint64 */
@@ -33,6 +37,15 @@ export interface TPDiskStateInfo {
     StateFlag?: EFlag;
     Overall?: EFlag;
     SerialNumber?: string;
+    /** uint64 */
+    SystemSize?: string;
+    /** uint64 */
+    LogUsedSize?: string;
+    /** uint64 */
+    LogTotalSize?: string;
+    /** uint64 */
+    EnforcedDynamicSlotSize?: string;
+    ExpectedSlotCount?: number;
 }
 export declare enum TPDiskState {
     Initial = "Initial",
@@ -54,3 +67,53 @@ export declare enum TPDiskState {
     NodeDisconnected = "NodeDisconnected",
     Unknown = "Unknown"
 }
+/**
+ * endpoint: /pdisk/info
+ */
+export interface TPDiskInfoResponse {
+    Whiteboard?: TPDiskInfoWhiteboard;
+    BSC?: TPDiskInfoBSC;
+}
+interface TPDiskInfoWhiteboard {
+    PDisk?: TPDiskStateInfo;
+    VDisks?: TVDiskStateInfo[];
+}
+interface TPDiskInfoBSC {
+    PDisk?: TPDiskInfo;
+    VDisks?: TVSlotEntry;
+}
+/**
+ * BSC PDisk data
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/sys_view.proto
+ */
+export interface TPDiskInfo {
+    Type?: EPDiskType;
+    /** uint64 */
+    Kind?: string;
+    Path?: string;
+    /** uint64 */
+    Guid?: string;
+    /** uint64 */
+    BoxId?: string;
+    SharedWithOs?: boolean;
+    ReadCentric?: boolean;
+    /** uint64 */
+    AvailableSize?: string;
+    /** uint64 */
+    TotalSize?: string;
+    StatusV2?: EDriveStatus;
+    /** uint64 */
+    StatusChangeTimestamp?: string;
+    /** uint64 */
+    EnforcedDynamicSlotSize?: string;
+    ExpectedSlotCount?: number;
+    NumActiveSlots?: number;
+    /** uint64 */
+    Category?: string;
+    DecommitStatus?: EDecommitStatus;
+}
+type EDriveStatus = 'UNKNOWN' | 'ACTIVE' | 'INACTIVE' | 'BROKEN' | 'FAULTY' | 'TO_BE_REMOVED';
+type EDecommitStatus = 'DECOMMIT_UNSET' | 'DECOMMIT_NONE' | 'DECOMMIT_PENDING' | 'DECOMMIT_IMMINENT' | 'DECOMMIT_REJECTED';
+type EPDiskType = 'ROT' | 'SSD' | 'NVME' | 'UNKNOWN_TYPE';
+export {};

package/dist/types/api/vdisk.d.ts

@@ -2,14 +2,17 @@ import type { EFlag } from './enums';
 import type { TPDiskStateInfo } from './pdisk';
 /**
  * endpoint: /viewer/json/vdiskinfo
- *
- * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/node_whiteboard.proto
  */
 export interface TEvVDiskStateResponse {
     VDiskStateInfo?: TVDiskStateInfo[];
     ResponseTime?: string;
     ResponseDuration?: number;
 }
+/**
+ * Node whiteboard VDisk data
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/node_whiteboard.proto
+ */
 export interface TVDiskStateInfo {
     VDiskId?: TVDiskID;
     /** uint64 */
@@ -38,6 +41,9 @@ export interface TVDiskStateInfo {
     UnreplicatedPhantoms?: boolean;
     /** The same for the non-phantom-like blobs. */
     UnreplicatedNonPhantoms?: boolean;
+    /** Replication progress (0 to 1) */
+    ReplicationProgress?: number;
+    ReplicationSecondsRemaining?: number;
     /**
      * uint64
      * How many unsynced VDisks from current BlobStorage group we see
@@ -116,4 +122,29 @@ export declare enum EVDiskState {
     OK = "OK",
     PDiskError = "PDiskError"
 }
+/**
+ * BSC VDisk data
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/sys_view.proto
+ */
+export interface TVSlotEntry {
+    Key?: TVSlotKey;
+    Info?: TVSlotInfo;
+}
+type TVSlotKey = TVSlotId;
+export interface TVSlotInfo {
+    GroupId?: number;
+    GroupGeneration?: number;
+    FailRealm?: number;
+    FailDomain?: number;
+    VDisk?: number;
+    /** uint64 */
+    AllocatedSize?: string;
+    /** uint64 */
+    AvailableSize?: string;
+    StatusV2?: EVDiskStatus;
+    Kind?: string;
+    IsBeingDeleted?: boolean;
+}
+type EVDiskStatus = 'ERROR' | 'INIT_PENDING' | 'REPLICATING' | 'READY';
 export {};

package/dist/types/common.d.ts

@@ -1 +1,4 @@
 export type ValueOf<T extends Object> = T[keyof T];
+export type ExtractType<T> = T extends {
+    type: infer U;
+} ? U : string;

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

@@ -13,4 +13,5 @@ export interface IHeatmapState {
 export interface IHeatmapApiRequestParams {
     nodes?: string[];
     path: string;
+    database: string;
 }

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

@@ -1,4 +1,4 @@
-import type { QUERY_ACTIONS, QUERY_MODES, QUERY_SYNTAX } from '../../utils/query';
+import type { ISOLATION_LEVELS, QUERY_ACTIONS, QUERY_MODES, QUERY_SYNTAX, STATISTICS_MODES, TRACING_LEVELS } from '../../utils/query';
 import type { IResponseError, NetworkError } from '../api/error';
 import type { ColumnType, KeyValueRow, ErrorResponse as QueryErrorResponseData, QueryPlan, ScriptPlan, TKqpStatsQuery } from '../api/query';
 import type { ValueOf } from '../common';
@@ -23,6 +23,9 @@ export type QueryError = NetworkError | QueryErrorResponse;
 export type QueryAction = ValueOf<typeof QUERY_ACTIONS>;
 export type QueryMode = ValueOf<typeof QUERY_MODES>;
 export type QuerySyntax = ValueOf<typeof QUERY_SYNTAX>;
+export type IsolationLevel = ValueOf<typeof ISOLATION_LEVELS>;
+export type StatisticsMode = ValueOf<typeof STATISTICS_MODES>;
+export type TracingLevel = ValueOf<typeof TRACING_LEVELS>;
 export interface SavedQuery {
     name: string;
     body: string;

package/dist/utils/constants.d.ts

@@ -106,3 +106,4 @@ export declare const AUTOCOMPLETE_ON_ENTER = "autocompleteOnEnter";
 export declare const IS_HOTKEYS_HELP_HIDDEN_KEY = "isHotKeysHelpHidden";
 export declare const USE_SEPARATE_DISKS_PAGES_KEY = "useSeparateDisksPages";
 export declare const USE_DIRECTORY_OPERATIONS = "useDirectoryOperations";
+export declare const QUERY_SETTINGS = "query_settings";

package/dist/utils/constants.js

@@ -110,3 +110,4 @@ export const AUTOCOMPLETE_ON_ENTER = 'autocompleteOnEnter';
 export const IS_HOTKEYS_HELP_HIDDEN_KEY = 'isHotKeysHelpHidden';
 export const USE_SEPARATE_DISKS_PAGES_KEY = 'useSeparateDisksPages';
 export const USE_DIRECTORY_OPERATIONS = 'useDirectoryOperations';
+export const QUERY_SETTINGS = 'query_settings';

package/dist/utils/dataFormatters/dataFormatters.d.ts

@@ -4,10 +4,6 @@ export declare const formatBytes: (bytes?: string | number) => string;
 export declare const formatBps: (bytes?: string | number) => string;
 export declare const formatBytesToGigabyte: (bytes: number | string) => string;
 export declare const stringifyVdiskId: (id?: TVDiskID | TVSlotId) => string;
-export declare const getPDiskId: (info: {
-    NodeId?: number;
-    PDiskId?: number;
-}) => string | undefined;
 export declare const formatUptime: (seconds: number) => string;
 export declare const formatMsToUptime: (ms?: number) => string | 0 | undefined;
 export declare const formatStorageValues: (value?: number, total?: number, size?: BytesSizes) => string[];

package/dist/utils/dataFormatters/dataFormatters.js

@@ -26,9 +26,6 @@ export const formatBytesToGigabyte = (bytes) => {
 export const stringifyVdiskId = (id) => {
     return id ? Object.values(id).join('-') : '';
 };
-export const getPDiskId = (info) => {
-    return info.NodeId && info.PDiskId ? `${info.NodeId}-${info.PDiskId}` : undefined;
-};
 export const formatUptime = (seconds) => {
     const days = Math.floor(seconds / DAY_IN_SECONDS);
     const remain = seconds % DAY_IN_SECONDS;
@@ -103,13 +100,10 @@ export const formatCPUWithLabel = (value) => {
     const localizedCores = configuredNumeral(cores).format('0.[000]');
     return `${localizedCores} ${i18n('format-cpu.cores', { count: cores })}`;
 };
-export const formatDateTime = (value, defaultValue = 'N/A') => {
+export const formatDateTime = (value, defaultValue = '') => {
     var _a;
-    if (!isNumeric(value)) {
-        return '';
-    }
     const formattedData = (_a = dateTimeParse(Number(value))) === null || _a === void 0 ? void 0 : _a.format('YYYY-MM-DD HH:mm');
-    return Number(value) > 0 && formattedData ? formattedData : defaultValue;
+    return formattedData !== null && formattedData !== void 0 ? formattedData : defaultValue;
 };
 export const calcUptimeInSeconds = (milliseconds) => {
     const currentDate = new Date();

package/dist/utils/developerUI/developerUI.d.ts

@@ -9,4 +9,5 @@ interface VDiskDeveloperUILinkParams extends PDiskDeveloperUILinkParams {
     vDiskSlotId: number | string;
 }
 export declare const createVDiskDeveloperUILink: ({ nodeId, pDiskId, vDiskSlotId, host, }: VDiskDeveloperUILinkParams) => string;
+export declare function createTabletDeveloperUIHref(tabletId: number | string, host?: string | undefined): string;
 export {};

package/dist/utils/developerUI/developerUI.js

@@ -18,3 +18,6 @@ export const createVDiskDeveloperUILink = ({ nodeId, pDiskId, vDiskSlotId, host,
     const vdiskPath = 'actors/vdisks/vdisk' + pad9(pDiskId) + '_' + pad9(vDiskSlotId);
     return createDeveloperUILinkWithNodeId(nodeId, host) + vdiskPath;
 };
+export function createTabletDeveloperUIHref(tabletId, host = backend) {
+    return `${host}/tablets?TabletID=${tabletId}`;
+}

package/dist/utils/disks/getPDiskType.d.ts

@@ -1,7 +1,7 @@
 import type { PDiskType } from './types';
 export declare const PDISK_TYPES: {
-    HDD: string;
-    SSD: string;
-    MVME: string;
+    readonly HDD: "HDD";
+    readonly SSD: "SSD";
+    readonly MVME: "NVME";
 };
 export declare function getPDiskType(category?: string): PDiskType | undefined;

package/dist/utils/disks/helpers.d.ts

@@ -1,3 +1,4 @@
 import type { TVDiskStateInfo, TVSlotId } from '../../types/api/vdisk';
 export declare function isFullVDiskData(disk: TVDiskStateInfo | TVSlotId): disk is TVDiskStateInfo;
 export declare function getSeverityColor(severity: number | undefined): import("../../types/api/enums").EFlag;
+export declare function getPDiskId(nodeId: string | number, pDiskId: string | number): string;

package/dist/utils/disks/helpers.js

@@ -8,3 +8,6 @@ export function getSeverityColor(severity) {
     }
     return DISK_NUMERIC_SEVERITY_TO_STATE_COLOR[severity] || NOT_AVAILABLE_SEVERITY_COLOR;
 }
+export function getPDiskId(nodeId, pDiskId) {
+    return `${nodeId}-${pDiskId}`;
+}

package/dist/utils/disks/prepareDisks.d.ts

@@ -1,5 +1,5 @@
-import type { TPDiskStateInfo } from '../../types/api/pdisk';
+import type { TPDiskInfo, TPDiskStateInfo } from '../../types/api/pdisk';
 import type { TVDiskStateInfo } from '../../types/api/vdisk';
 import type { PreparedPDisk, PreparedVDisk } from './types';
 export declare function prepareVDiskData(vdiskState?: TVDiskStateInfo): PreparedVDisk;
-export declare function preparePDiskData(pdiskState?: TPDiskStateInfo): PreparedPDisk;
+export declare function preparePDiskData(pdiskState?: TPDiskStateInfo, bscPDiskInfo?: TPDiskInfo): PreparedPDisk;

package/dist/utils/disks/prepareDisks.js

@@ -1,14 +1,16 @@
-import { isNumeric } from '../utils';
 import { calculatePDiskSeverity } from './calculatePDiskSeverity';
 import { calculateVDiskSeverity } from './calculateVDiskSeverity';
 import { getPDiskType } from './getPDiskType';
 export function prepareVDiskData(vdiskState = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     // Prepare PDisk only if it is present
     const PDisk = vdiskState.PDisk ? preparePDiskData(vdiskState.PDisk) : undefined;
     const PDiskId = (_a = vdiskState.PDiskId) !== null && _a !== void 0 ? _a : PDisk === null || PDisk === void 0 ? void 0 : PDisk.PDiskId;
-    const AllocatedPercent = calculateVDiskAllocatedPercent(vdiskState.AllocatedSize, vdiskState.AvailableSize, PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize);
-    const Donors = (_b = vdiskState.Donors) === null || _b === void 0 ? void 0 : _b.map((donor) => {
+    const available = Number((_b = vdiskState.AvailableSize) !== null && _b !== void 0 ? _b : PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize);
+    const allocated = Number(vdiskState.AllocatedSize);
+    const total = allocated + available;
+    const allocatedPercent = Math.round((allocated * 100) / total);
+    const Donors = (_c = vdiskState.Donors) === null || _c === void 0 ? void 0 : _c.map((donor) => {
         return prepareVDiskData({ ...donor, DonorMode: true });
     });
     const Severity = calculateVDiskSeverity(vdiskState);
@@ -16,33 +18,26 @@ export function prepareVDiskData(vdiskState = {}) {
         ...vdiskState,
         PDisk,
         PDiskId,
-        AllocatedPercent,
         Donors,
         Severity,
+        TotalSize: total,
+        AllocatedPercent: allocatedPercent,
     };
 }
-export function preparePDiskData(pdiskState = {}) {
+export function preparePDiskData(pdiskState = {}, bscPDiskInfo = {}) {
     const { AvailableSize, TotalSize, Category } = pdiskState;
     const Type = getPDiskType(Category);
-    const AllocatedPercent = calculatePDiskAllocatedPercent(AvailableSize, TotalSize);
-    const Severity = calculatePDiskSeverity(pdiskState, AllocatedPercent);
+    const available = Number(AvailableSize);
+    const total = Number(TotalSize);
+    const allocated = total - available;
+    const allocatedPercent = Math.round((allocated * 100) / total);
+    const Severity = calculatePDiskSeverity(pdiskState, allocatedPercent);
     return {
+        ...bscPDiskInfo,
         ...pdiskState,
         Type,
-        AllocatedPercent,
         Severity,
+        AllocatedSize: allocated,
+        AllocatedPercent: allocatedPercent,
     };
 }
-function calculatePDiskAllocatedPercent(available, total) {
-    if (!isNumeric(available) || !isNumeric(total)) {
-        return undefined;
-    }
-    return Math.round(((Number(total) - Number(available)) * 100) / Number(total));
-}
-function calculateVDiskAllocatedPercent(allocated, availableOnVDisk, availableOnPDisk) {
-    const available = availableOnVDisk !== null && availableOnVDisk !== void 0 ? availableOnVDisk : availableOnPDisk;
-    if (!isNumeric(allocated) || !isNumeric(available)) {
-        return undefined;
-    }
-    return Math.round((Number(allocated) * 100) / (Number(allocated) + Number(available)));
-}

package/dist/utils/disks/types.d.ts

@@ -1,16 +1,18 @@
-import type { TPDiskStateInfo } from '../../types/api/pdisk';
+import type { TPDiskInfo, TPDiskStateInfo } from '../../types/api/pdisk';
 import type { TVDiskStateInfo, TVSlotId } from '../../types/api/vdisk';
 import type { ValueOf } from '../../types/common';
 import type { PDISK_TYPES } from './getPDiskType';
-export interface PreparedPDisk extends TPDiskStateInfo {
+export type PreparedPDisk = TPDiskStateInfo & Omit<Partial<TPDiskInfo>, 'Type'> & {
     Type?: PDiskType;
-    AllocatedPercent?: number;
     Severity?: number;
-}
+    AllocatedSize?: number;
+    AllocatedPercent?: number;
+};
 export interface PreparedVDisk extends TVDiskStateInfo {
     PDisk?: PreparedPDisk;
-    AllocatedPercent?: number;
     Severity?: number;
+    TotalSize?: number;
+    AllocatedPercent?: number;
 }
 export type PDiskType = ValueOf<typeof PDISK_TYPES>;
 export interface UnavailableDonor extends TVSlotId {

package/dist/utils/monaco/constats.d.ts

@@ -0,0 +1,2 @@
+export declare const S_EXPRESSION_LANGUAGE_ID = "s-expression";
+export declare const YQL_LANGUAGE_ID = "yql";

package/dist/utils/monaco/constats.js

@@ -0,0 +1,2 @@
+export const S_EXPRESSION_LANGUAGE_ID = 's-expression';
+export const YQL_LANGUAGE_ID = 'yql';

package/dist/utils/monaco/yql/constants.d.ts

@@ -1,5 +1,4 @@
 import type { YQLEntity } from '@gravity-ui/websql-autocomplete';
-export declare const LANGUAGE_YQL_ID = "yql";
 export declare const SimpleTypes: string[];
 export declare const SimpleFunctions: string[];
 export declare const AggregateFunctions: string[];

package/dist/utils/monaco/yql/constants.js

@@ -1,4 +1,3 @@
-export const LANGUAGE_YQL_ID = 'yql';
 export const SimpleTypes = [
     'String',
     'Bool',

package/dist/utils/monaco/yql/yql.completionItemProvider.js

@@ -1,5 +1,5 @@
 import * as monaco from 'monaco-editor';
-import { LANGUAGE_YQL_ID } from './constants';
+import { LANGUAGE_ID } from 'monaco-yql-languages/build/yql/yql.contribution';
 import { createProvideSuggestionsFunction } from './yqlSuggestions';
 let completionProvider;
 function disableCodeSuggestions() {
@@ -9,7 +9,7 @@ function disableCodeSuggestions() {
 }
 export function registerYQLCompletionItemProvider(database) {
     disableCodeSuggestions();
-    completionProvider = monaco.languages.registerCompletionItemProvider(LANGUAGE_YQL_ID, {
+    completionProvider = monaco.languages.registerCompletionItemProvider(LANGUAGE_ID, {
         triggerCharacters: [' ', '.', '`', '(', '/'],
         provideCompletionItems: createProvideSuggestionsFunction(database),
     });

package/dist/utils/query.d.ts

@@ -1,5 +1,28 @@
 import type { AnyExecuteResponse, AnyExplainResponse, ErrorResponse, KeyValueRow, QueryPlan, ScriptPlan } from '../types/api/query';
-import type { IQueryResult, QueryMode } from '../types/store/query';
+import type { IQueryResult, IsolationLevel, QueryMode, StatisticsMode, TracingLevel } from '../types/store/query';
+export declare const ISOLATION_LEVELS: {
+    readonly serializable: "serializable-read-write";
+    readonly stalero: "stale-read-only";
+    readonly onlinero: "online-read-only";
+    readonly snapshot: "snapshot-read-only";
+};
+export declare const ISOLATION_LEVELS_TITLES: Record<IsolationLevel, string>;
+export declare const STATISTICS_MODES: {
+    readonly none: "none";
+    readonly basic: "basic";
+    readonly full: "full";
+    readonly profile: "profile";
+};
+export declare const STATISTICS_MODES_TITLES: Record<StatisticsMode, string>;
+export declare const TRACING_LEVELS: {
+    readonly off: "off";
+    readonly toplevel: "toplevel";
+    readonly basic: "basic";
+    readonly detailed: "detailed";
+    readonly diagnostic: "diagnostic";
+    readonly trace: "trace";
+};
+export declare const TRACING_LEVELS_TITLES: Record<TracingLevel, string>;
 export declare const QUERY_ACTIONS: {
     readonly execute: "execute";
     readonly explain: "explain";