ydb-embedded-ui 20.2.1 → 20.3.0

package/src/containers/Storage/StorageExpertModePanel/components/StateLegend.tsx

@@ -0,0 +1,56 @@
+import {CircleExclamationFill, CircleXmarkFill, ClockFill} from '@gravity-ui/icons';
+import type {IconData, LabelProps} from '@gravity-ui/uikit';
+import {Flex, Icon, Label, Text} from '@gravity-ui/uikit';
+
+import {b} from '../constants';
+import i18n from '../i18n';
+
+interface StateLegendProps {
+    className?: string;
+}
+
+interface StateLegendItem {
+    text: string;
+    theme: LabelProps['theme'];
+    icon?: IconData;
+    className?: string;
+}
+
+const iconSize = 12;
+
+const legendItems: StateLegendItem[] = [
+    {text: i18n('value_ok'), theme: 'success'},
+    {text: i18n('value_replication'), theme: 'info'},
+    {text: i18n('value_initial'), theme: 'warning', icon: ClockFill},
+    {text: i18n('value_pdisk-error'), theme: 'danger', icon: CircleExclamationFill},
+    {
+        text: i18n('value_error'),
+        theme: 'danger',
+        icon: CircleXmarkFill,
+        className: b('label-danger-heavy'),
+    },
+    {text: i18n('value_no-data'), theme: 'unknown'},
+];
+
+export function StateLegend({className}: StateLegendProps) {
+    return (
+        <Flex className={className} gap={3} alignItems="center" wrap="wrap">
+            <Flex gap={2} alignItems="center" wrap="wrap">
+                {legendItems.map(({text, theme, icon, className: labelClassName}) => (
+                    <Label
+                        key={text}
+                        size="xs"
+                        theme={theme}
+                        className={labelClassName}
+                        icon={icon ? <Icon data={icon} size={iconSize} /> : undefined}
+                    >
+                        {text}
+                    </Label>
+                ))}
+            </Flex>
+            <Text className={b('empty-statistics')} color="secondary">
+                {i18n('context_no-statistics')}
+            </Text>
+        </Flex>
+    );
+}

package/src/containers/Storage/StorageExpertModePanel/components/StatusPairLegend.tsx

@@ -0,0 +1,61 @@
+import {
+    CircleCheckFill,
+    CircleExclamationFill,
+    CircleXmarkFill,
+    TriangleExclamationFill,
+} from '@gravity-ui/icons';
+import type {IconData, LabelProps} from '@gravity-ui/uikit';
+import {Flex, Icon, Label, Text} from '@gravity-ui/uikit';
+
+import {b} from '../constants';
+import i18n from '../i18n';
+
+interface StatusPairLegendProps {
+    className?: string;
+    label: string;
+}
+
+interface StatusPairLegendItem {
+    text: string;
+    theme: LabelProps['theme'];
+    icon: IconData;
+    className?: string;
+}
+
+const iconSize = 12;
+
+const legendItems: StatusPairLegendItem[] = [
+    {text: i18n('compaction_ok'), theme: 'success', icon: CircleCheckFill},
+    {text: i18n('compaction_notice'), theme: 'warning', icon: TriangleExclamationFill},
+    {text: i18n('compaction_warning'), theme: 'danger', icon: CircleExclamationFill},
+    {
+        text: i18n('compaction_impaired'),
+        theme: 'danger',
+        icon: CircleXmarkFill,
+        className: b('label-danger-heavy'),
+    },
+];
+
+export function StatusPairLegend({className, label}: StatusPairLegendProps) {
+    return (
+        <Flex className={className} gap={3} alignItems="center" wrap="wrap">
+            <Flex gap={2} alignItems="center" wrap="wrap">
+                <Text color="secondary">{label}</Text>
+                {legendItems.map(({text, theme, icon, className: labelClassName}) => (
+                    <Label
+                        key={text}
+                        size="xs"
+                        theme={theme}
+                        className={labelClassName}
+                        icon={<Icon data={icon} size={iconSize} />}
+                    >
+                        {text}
+                    </Label>
+                ))}
+            </Flex>
+            <Text className={b('empty-statistics')} color="secondary">
+                {i18n('context_no-statistics')}
+            </Text>
+        </Flex>
+    );
+}

package/src/containers/Storage/StorageExpertModePanel/components/getSpaceLegendSelection.ts

@@ -0,0 +1,52 @@
+import {ECapacityAlert, isCapacityAlert} from '../../../../types/api/enums';
+import {loadFromSessionStorage, saveToSessionStorage} from '../../../../utils';
+
+export const SPACE_LEGEND_STORAGE_KEY = 'ydb-space-legend-inactive';
+export const SPACE_LEGEND_CHANGE_EVENT = 'spaceLegendChange';
+
+export type SpaceLegendSelectionScope = 'vdisks' | 'pdisks';
+
+// By default, GREEN and CYAN are inactive (deselected)
+const defaultInactive = new Set([ECapacityAlert.GREEN, ECapacityAlert.CYAN]);
+
+function getStorageKey(scope: SpaceLegendSelectionScope) {
+    return scope === 'vdisks' ? SPACE_LEGEND_STORAGE_KEY : `${SPACE_LEGEND_STORAGE_KEY}-${scope}`;
+}
+
+function getChangeEvent(scope: SpaceLegendSelectionScope) {
+    return scope === 'vdisks' ? SPACE_LEGEND_CHANGE_EVENT : `${SPACE_LEGEND_CHANGE_EVENT}-${scope}`;
+}
+
+function loadInactiveItems(scope: SpaceLegendSelectionScope): Set<ECapacityAlert> {
+    const stored = loadFromSessionStorage(getStorageKey(scope));
+
+    if (Array.isArray(stored)) {
+        const normalizedStored = new Set<ECapacityAlert>();
+        stored.forEach((item) => {
+            if (isCapacityAlert(item)) {
+                normalizedStored.add(item);
+            }
+        });
+        return normalizedStored;
+    }
+
+    return new Set(defaultInactive);
+}
+
+/**
+ * Get the set of inactive (deselected) capacityAlert values for Space mode legend
+ * Returns a Set of ECapacityAlert values that are currently deselected in the legend
+ */
+export function getSpaceLegendSelection(
+    scope: SpaceLegendSelectionScope = 'vdisks',
+): Set<ECapacityAlert> {
+    return loadInactiveItems(scope);
+}
+
+export function saveSpaceLegendSelection(
+    selection: Set<ECapacityAlert>,
+    scope: SpaceLegendSelectionScope = 'vdisks',
+): void {
+    saveToSessionStorage(getStorageKey(scope), Array.from(selection));
+    window.dispatchEvent(new CustomEvent(getChangeEvent(scope)));
+}

package/src/containers/Storage/StorageExpertModePanel/components/index.ts

@@ -0,0 +1,10 @@
+export {StateLegend} from './StateLegend';
+export {PDiskStateLegend} from './PDiskStateLegend';
+export {PDiskDriveLegend} from './PDiskDriveLegend';
+export {PDiskDecommitLegend} from './PDiskDecommitLegend';
+export {PDiskMaintenanceLegend} from './PDiskMaintenanceLegend';
+export {PDiskDeviceLegend} from './PDiskDeviceLegend';
+export {SpaceLegend} from './SpaceLegend';
+export {FrontQueuesLegend} from './FrontQueuesLegend';
+export {CompactionLegend} from './CompactionLegend';
+export {AllLegend} from './AllLegend';

package/src/containers/Storage/StorageExpertModePanel/components/useSpaceLegendSelection.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+
+import type {ECapacityAlert} from '../../../../types/api/enums';
+
+import {SPACE_LEGEND_CHANGE_EVENT, getSpaceLegendSelection} from './getSpaceLegendSelection';
+import type {SpaceLegendSelectionScope} from './getSpaceLegendSelection';
+
+/**
+ * Hook to get the set of inactive (deselected) legend items for Space mode
+ * Returns a Set of ECapacityAlert values that are currently deselected in the legend
+ * Automatically updates when legend selection changes
+ */
+function getChangeEvent(scope: SpaceLegendSelectionScope) {
+    return scope === 'vdisks' ? SPACE_LEGEND_CHANGE_EVENT : `${SPACE_LEGEND_CHANGE_EVENT}-${scope}`;
+}
+
+export function useSpaceLegendSelection(
+    scope: SpaceLegendSelectionScope = 'vdisks',
+): Set<ECapacityAlert> {
+    const [selection, setSelection] = React.useState<Set<ECapacityAlert>>(() =>
+        getSpaceLegendSelection(scope),
+    );
+
+    React.useEffect(() => {
+        const handleLegendChange = () => {
+            setSelection(getSpaceLegendSelection(scope));
+        };
+
+        const changeEvent = getChangeEvent(scope);
+        window.addEventListener(changeEvent, handleLegendChange);
+        return () => {
+            window.removeEventListener(changeEvent, handleLegendChange);
+        };
+    }, [scope]);
+
+    return selection;
+}

package/src/containers/Storage/StorageExpertModePanel/constants.ts

@@ -0,0 +1,25 @@
+import {z} from 'zod';
+
+import {cn} from '../../../utils/cn';
+import {VDisksGroupBy} from '../../../utils/disks/groupBy';
+import type {VDisksGroupByValue} from '../../../utils/disks/groupBy';
+
+export {VDisksGroupBy};
+export type {VDisksGroupByValue};
+
+export const PDisksGroupBy = {
+    State: 'State',
+    Space: 'Space',
+    Drive: 'Drive',
+    Decommit: 'Decommit',
+    Maintenance: 'Maintenance',
+    Device: 'Device',
+    All: 'All',
+} as const;
+
+export type PDisksGroupByValue = (typeof PDisksGroupBy)[keyof typeof PDisksGroupBy];
+
+export const vdisksGroupBySchema = z.nativeEnum(VDisksGroupBy).catch(VDisksGroupBy.State);
+export const pdisksGroupBySchema = z.nativeEnum(PDisksGroupBy).catch(PDisksGroupBy.State);
+
+export const b = cn('ydb-storage-expert-mode-panel');

package/src/containers/Storage/StorageExpertModePanel/i18n/en.json

@@ -0,0 +1,69 @@
+{
+  "label_vdisks": "VDisks:",
+  "label_pdisks": "PDisks:",
+  "value_state": "State",
+  "value_space": "Space",
+  "value_front-queues": "Front queues",
+  "value_compaction": "Compaction",
+  "value_all": "All",
+  "value_pdisks-state": "State",
+  "value_pdisks-space": "Space",
+  "value_pdisks-drive": "Drive",
+  "value_pdisks-decommit": "Decommit",
+  "value_pdisks-maintenance": "Maintenance",
+  "value_pdisks-device": "Device",
+  "value_pdisks-all": "All",
+  "value_ok": "Ok",
+  "value_replication": "Replication",
+  "value_initial": "Initial",
+  "value_pdisk-error": "PDisk Error",
+  "value_error": "Error",
+  "value_attention": "Attention",
+  "value_stopped": "Stopped",
+  "value_no-data": "N/D",
+  "drive_active": "Active",
+  "drive_inactive": "Inactive",
+  "drive_to-be-removed": "To be removed",
+  "drive_faulty": "Faulty",
+  "drive_broken": "Broken",
+  "value_decommit-imminent": "Imminent",
+  "value_decommit-rejected": "Rejected",
+  "value_decommit-pending": "Pending",
+  "value_decommit-none": "No decommission",
+  "value_maintenance-long-term-planned": "Long term planned",
+  "value_maintenance-no-new-vdisks": "No new VDisks",
+  "value_maintenance-no-request": "No request",
+  "context_no-statistics": "No statistics available",
+  "label_capacity-alerts": "Capacity alerts:",
+  "capacity-alerts_all": "All",
+  "capacity-alerts_none": "None",
+  "capacity-alerts_except": "Except {{alerts}}",
+  "capacity-alert_green": "Green",
+  "capacity-alert_cyan": "Cyan",
+  "capacity-alert_light-yellow": "Light Yellow",
+  "capacity-alert_yellow": "Yellow",
+  "capacity-alert_light-orange": "Light Orange",
+  "capacity-alert_pre-orange": "Pre Orange",
+  "capacity-alert_orange": "Orange",
+  "capacity-alert_red": "Red",
+  "capacity-alert_black": "Black",
+  "space_green": "G",
+  "space_cyan": "C",
+  "space_light-yellow": "LY",
+  "space_yellow": "Y",
+  "space_light-orange": "LO",
+  "space_pre-orange": "PO",
+  "space_orange": "O",
+  "space_red": "R",
+  "space_black": "B",
+  "front-queues_ok": "OK",
+  "front-queues_notice": "Notice",
+  "front-queues_warning": "Warning",
+  "front-queues_impaired": "Impaired",
+  "compaction_key": "Fresh / Level Rank Satisfaction:",
+  "device_key": "Device / Realtime:",
+  "compaction_ok": "OK",
+  "compaction_notice": "Notice",
+  "compaction_warning": "Warning",
+  "compaction_impaired": "Impaired"
+}

package/src/containers/Storage/StorageExpertModePanel/i18n/index.ts

@@ -0,0 +1,7 @@
+import {registerKeysets} from '../../../../utils/i18n';
+
+import en from './en.json';
+
+const COMPONENT = 'ydb-storage-expert-mode-panel';
+
+export default registerKeysets(COMPONENT, {en});

package/src/containers/Storage/StorageTypeFilter/StorageTypeFilter.tsx

@@ -0,0 +1,29 @@
+import {SegmentedRadioGroup} from '@gravity-ui/uikit';
+
+import {STORAGE_TYPES} from '../../../store/reducers/storage/constants';
+import type {StorageType} from '../../../store/reducers/storage/types';
+
+const StorageTypesTitles = {
+    [STORAGE_TYPES.groups]: 'Groups',
+    [STORAGE_TYPES.nodes]: 'Nodes',
+};
+
+interface StorageTypeFilterProps {
+    value: StorageType;
+    onChange: (value: StorageType) => void;
+}
+
+const storageTypeFilterQa = 'storage-type-filter';
+
+export const StorageTypeFilter = ({value, onChange}: StorageTypeFilterProps) => {
+    return (
+        <SegmentedRadioGroup value={value} onUpdate={onChange} qa={storageTypeFilterQa}>
+            <SegmentedRadioGroup.Option value={STORAGE_TYPES.groups}>
+                {StorageTypesTitles[STORAGE_TYPES.groups]}
+            </SegmentedRadioGroup.Option>
+            <SegmentedRadioGroup.Option value={STORAGE_TYPES.nodes}>
+                {StorageTypesTitles[STORAGE_TYPES.nodes]}
+            </SegmentedRadioGroup.Option>
+        </SegmentedRadioGroup>
+    );
+};

package/src/containers/Storage/StorageVisibleEntitiesFilter/StorageVisibleEntitiesFilter.tsx

@@ -0,0 +1,33 @@
+import {SegmentedRadioGroup} from '@gravity-ui/uikit';
+
+import {VISIBLE_ENTITIES} from '../../../store/reducers/storage/constants';
+import type {VisibleEntities} from '../../../store/reducers/storage/types';
+
+const VisibleEntitiesTitles = {
+    [VISIBLE_ENTITIES.all]: 'All',
+    [VISIBLE_ENTITIES.missing]: 'Degraded',
+    [VISIBLE_ENTITIES.space]: 'Out of Space',
+};
+
+interface StorageProblemFilterProps {
+    value: VisibleEntities;
+    onChange: (value: VisibleEntities) => void;
+}
+
+const storageVisibleEntitiesFilterQa = 'storage-visible-entities-filter';
+
+export const StorageVisibleEntitiesFilter = ({value, onChange}: StorageProblemFilterProps) => {
+    return (
+        <SegmentedRadioGroup value={value} onUpdate={onChange} qa={storageVisibleEntitiesFilterQa}>
+            <SegmentedRadioGroup.Option value={VISIBLE_ENTITIES.missing}>
+                {VisibleEntitiesTitles[VISIBLE_ENTITIES.missing]}
+            </SegmentedRadioGroup.Option>
+            <SegmentedRadioGroup.Option value={VISIBLE_ENTITIES.space}>
+                {VisibleEntitiesTitles[VISIBLE_ENTITIES.space]}
+            </SegmentedRadioGroup.Option>
+            <SegmentedRadioGroup.Option value={VISIBLE_ENTITIES.all}>
+                {VisibleEntitiesTitles[VISIBLE_ENTITIES.all]}
+            </SegmentedRadioGroup.Option>
+        </SegmentedRadioGroup>
+    );
+};

package/src/containers/Storage/TableGroup/TableGroup.scss

@@ -0,0 +1,50 @@
+.ydb-table-group {
+    display: flex;
+    flex-direction: column;
+
+    width: max-content;
+    min-width: 100%;
+    margin-bottom: 20px;
+
+    border: 1px solid var(--g-color-line-generic);
+    border-radius: var(--g-spacing-2);
+
+    &__button {
+        padding: 8px 0;
+
+        cursor: pointer;
+
+        border: unset;
+        background: unset;
+    }
+
+    &__title-wrapper {
+        position: sticky;
+        left: 0;
+
+        display: flex;
+        flex-direction: row;
+        justify-content: flex-start;
+        align-items: center;
+        gap: var(--g-spacing-2);
+
+        width: max-content;
+        padding-left: 20px;
+    }
+
+    &__title {
+        display: flex;
+        flex-direction: row;
+        gap: var(--g-spacing-4);
+    }
+
+    &__count {
+        display: flex;
+        flex-direction: row;
+        gap: var(--g-spacing-3);
+    }
+
+    &__content {
+        padding: 12px 0 20px 20px;
+    }
+}

package/src/containers/Storage/TableGroup/TableGroup.tsx

@@ -0,0 +1,65 @@
+import React from 'react';
+
+import {ArrowToggle, Label, Text} from '@gravity-ui/uikit';
+
+import {cn} from '../../../utils/cn';
+
+import './TableGroup.scss';
+
+const b = cn('ydb-table-group');
+
+interface TableGroupProps {
+    children?: React.ReactNode;
+
+    title: string;
+    entityName: string;
+    count: string | number;
+    expanded: boolean;
+    onIsExpandedChange: (name: string, isExpanded: boolean) => void;
+}
+
+export const TableGroup = ({
+    children,
+    title,
+    entityName,
+    count,
+    expanded = false,
+    onIsExpandedChange,
+}: TableGroupProps) => {
+    const toggleCollapsed = () => {
+        onIsExpandedChange(title, !expanded);
+    };
+
+    const renderTitle = () => {
+        return (
+            <button onClick={toggleCollapsed} className={b('button')}>
+                <div className={b('title-wrapper')}>
+                    <ArrowToggle direction={expanded ? 'top' : 'bottom'} />
+                    <div className={b('title')}>
+                        <Text variant="subheader-2">{title}</Text>
+                        <Text variant="body-2" color="secondary" className={b('count')}>
+                            {entityName}: <Label theme="normal">{count}</Label>
+                        </Text>
+                    </div>
+                </div>
+            </button>
+        );
+    };
+
+    const renderContent = () => {
+        if (expanded) {
+            return <div className={b('content')}>{children}</div>;
+        }
+
+        return null;
+    };
+
+    return (
+        <div className={b(null)}>
+            {renderTitle()}
+            {renderContent()}
+        </div>
+    );
+};
+
+TableGroup.displayName = 'TableGroup';

package/src/containers/Storage/TableGroup/useExpandedTableGroups.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+
+import type {TableGroup} from '../../../store/reducers/storage/types';
+
+export function useExpandedGroups(groups?: TableGroup[]) {
+    const [expandedGroups, setExpandedGroups] = React.useState<Record<string, boolean>>({});
+
+    React.useEffect(() => {
+        if (groups?.length) {
+            setExpandedGroups((previousExpandedGroups) => {
+                return groups.reduce((result, {name}) => {
+                    const previousValue = previousExpandedGroups[name];
+
+                    // Preserve previously expanded groups on groups list change
+                    return {
+                        ...result,
+                        [name]: previousValue ?? false,
+                    };
+                }, {});
+            });
+        }
+    }, [groups]);
+
+    const setIsGroupExpanded = React.useCallback((name: string, isExpanded: boolean) => {
+        setExpandedGroups((previousExpandedGroups) => {
+            return {
+                ...previousExpandedGroups,
+                [name]: isExpanded,
+            };
+        });
+    }, []);
+
+    return {expandedGroups, setIsGroupExpanded};
+}

package/src/containers/Storage/VDisks/VDisks.scss

@@ -0,0 +1,28 @@
+.ydb-storage-vdisks {
+    &__wrapper {
+        display: flex;
+    }
+
+    &__item {
+        width: 55px;
+        margin-right: var(--g-spacing-1);
+
+        &_with-dc-margin {
+            margin-right: var(--g-spacing-3);
+        }
+
+        &:last-child {
+            margin-right: 0px;
+        }
+
+        .ydb-stack__item {
+            .data-table__row:hover & {
+                background: var(--ydb-data-table-color-hover);
+            }
+        }
+    }
+
+    &__vdisks-progress-bar {
+        border-radius: var(--g-border-radius-m);
+    }
+}

package/src/containers/Storage/VDisks/VDisks.tsx

@@ -0,0 +1,47 @@
+import React from 'react';
+
+import {VDiskWithDonorsStack} from '../../../components/VDisk/VDiskWithDonorsStack';
+import type {Erasure} from '../../../types/api/storage';
+import {cn} from '../../../utils/cn';
+import type {PreparedVDisk} from '../../../utils/disks/types';
+import {DISKS_POPUP_DEBOUNCE_TIMEOUT} from '../shared';
+import type {StorageViewContext} from '../types';
+import {isVdiskActive, useVDisksWithDCMargins} from '../utils';
+
+import './VDisks.scss';
+
+const b = cn('ydb-storage-vdisks');
+
+interface VDisksProps {
+    vDisks?: PreparedVDisk[];
+    viewContext?: StorageViewContext;
+    erasure?: Erasure;
+    withIcon?: boolean;
+}
+
+export function VDisks({vDisks, viewContext, erasure, withIcon}: VDisksProps) {
+    const vDisksWithDCMargins = useVDisksWithDCMargins(vDisks, erasure);
+
+    const [highlightedVDisk, setHighlightedVDisk] = React.useState<string | undefined>();
+
+    return (
+        <div className={b('wrapper')}>
+            {vDisks?.map((vDisk, index) => (
+                <VDiskWithDonorsStack
+                    withIcon={withIcon}
+                    key={vDisk.StringifiedId}
+                    data={vDisk}
+                    inactive={!isVdiskActive(vDisk, viewContext)}
+                    delayOpen={DISKS_POPUP_DEBOUNCE_TIMEOUT}
+                    delayClose={DISKS_POPUP_DEBOUNCE_TIMEOUT}
+                    className={b('item', {
+                        'with-dc-margin': vDisksWithDCMargins.includes(index),
+                    })}
+                    highlightedVDisk={highlightedVDisk}
+                    setHighlightedVDisk={setHighlightedVDisk}
+                    progressBarClassName={b('vdisks-progress-bar')}
+                />
+            ))}
+        </div>
+    );
+}

package/src/containers/Storage/constants.ts

@@ -0,0 +1,4 @@
+export const STORAGE_SEARCH_PARAM_BY_TYPE: Record<string, string> = {
+    groups: 'groupsSearch',
+    nodes: 'nodesSearch',
+};

package/src/containers/Storage/i18n/en.json

@@ -0,0 +1,14 @@
+{
+  "groups": "Groups",
+  "nodes": "Nodes",
+
+  "controls_groups-search-placeholder": "Group ID, Pool name",
+  "controls_nodes-search-placeholder": "Node ID, FQDN",
+  "controls_group-by-placeholder": "Group by:",
+  "controls_expert-mode": "Expert mode",
+
+  "no-nodes": "No such nodes",
+  "no-groups": "No such groups",
+
+  "no-data": "N/D"
+}

package/src/containers/Storage/i18n/index.ts

@@ -0,0 +1,7 @@
+import {registerKeysets} from '../../../utils/i18n';
+
+import en from './en.json';
+
+const COMPONENT = 'ydb-storage';
+
+export default registerKeysets(COMPONENT, {en});

package/src/containers/Storage/shared.tsx

@@ -0,0 +1,5 @@
+import {cn} from '../../utils/cn';
+
+export const b = cn('global-storage');
+
+export const DISKS_POPUP_DEBOUNCE_TIMEOUT = 200;

package/src/containers/Storage/types.ts

@@ -0,0 +1,16 @@
+import type {PaginatedTableData} from '../../components/PaginatedTable';
+import type {PreparedStorageNode} from '../../store/reducers/storage/types';
+
+export type StorageViewContext = {
+    groupId?: string;
+    nodeId?: string;
+    pDiskId?: string;
+    vDiskSlotId?: string;
+};
+
+export type StorageNodesPaginatedTableData = PaginatedTableData<PreparedStorageNode> & {
+    columnsSettings?: {
+        maxSlotsPerDisk: number;
+        maxDisksPerNode: number;
+    };
+};