ydb-embedded-ui 5.2.0 → 5.3.0

package/dist/store/reducers/storage/types.d.ts

@@ -1,21 +1,20 @@
 import type { OrderType } from '@gravity-ui/react-data-table';
 import type { IResponseError } from '../../../types/api/error';
 import type { TSystemStateInfo } from '../../../types/api/nodes';
-import type { TPDiskStateInfo } from '../../../types/api/pdisk';
 import type { EVersion, TStorageGroupInfo } from '../../../types/api/storage';
-import type { TVDiskStateInfo } from '../../../types/api/vdisk';
+import type { PreparedPDisk, PreparedVDisk } from '../../../utils/disks/types';
 import type { ValueOf } from '../../../types/common';
 import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
 import type { StorageSortValue } from '../../../utils/storage';
 import type { ApiRequestAction } from '../../utils';
 import { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
 import { FETCH_STORAGE, setDataWasNotLoaded, setGroupsSortParams, setInitialState, setNodesSortParams, setNodesUptimeFilter, setStorageTextFilter, setStorageType, setUsageFilter, setVisibleEntities } from './storage';
-export declare type VisibleEntities = ValueOf<typeof VISIBLE_ENTITIES>;
-export declare type StorageType = ValueOf<typeof STORAGE_TYPES>;
+export type VisibleEntities = ValueOf<typeof VISIBLE_ENTITIES>;
+export type StorageType = ValueOf<typeof STORAGE_TYPES>;
 export interface PreparedStorageNode extends TSystemStateInfo {
     NodeId: number;
-    PDisks: TPDiskStateInfo[] | undefined;
-    VDisks: TVDiskStateInfo[] | undefined;
+    PDisks?: PreparedPDisk[];
+    VDisks?: PreparedVDisk[];
     DC?: string;
     Rack?: string;
     Missing: number;
@@ -29,8 +28,9 @@ export interface PreparedStorageGroup extends TStorageGroupInfo {
     Used: number;
     Limit: number;
     Degraded: number;
-    Kind: string | undefined;
+    Kind?: string;
     UsedSpaceFlag: number;
+    VDisks?: PreparedVDisk[];
 }
 export interface UsageFilter {
     threshold: number;
@@ -47,7 +47,7 @@ export interface StorageSortAndFilterParams extends StorageSortParams {
 }
 export interface StorageApiRequestParams extends StorageSortAndFilterParams {
     tenant?: string;
-    nodeId?: string;
+    nodeId?: string | number;
     visibleEntities?: VisibleEntities;
     version?: EVersion;
 }
@@ -75,8 +75,8 @@ export interface PreparedStorageResponse {
     found: number | undefined;
     total: number | undefined;
 }
-declare type GetStorageInfoApiRequestAction = ApiRequestAction<typeof FETCH_STORAGE, PreparedStorageResponse, IResponseError>;
-export declare type StorageAction = GetStorageInfoApiRequestAction | ReturnType<typeof setInitialState> | ReturnType<typeof setStorageType> | ReturnType<typeof setStorageTextFilter> | ReturnType<typeof setUsageFilter> | ReturnType<typeof setVisibleEntities> | ReturnType<typeof setNodesUptimeFilter> | ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setNodesSortParams> | ReturnType<typeof setGroupsSortParams>;
+type GetStorageInfoApiRequestAction = ApiRequestAction<typeof FETCH_STORAGE, PreparedStorageResponse, IResponseError>;
+export type StorageAction = GetStorageInfoApiRequestAction | ReturnType<typeof setInitialState> | ReturnType<typeof setStorageType> | ReturnType<typeof setStorageTextFilter> | ReturnType<typeof setUsageFilter> | ReturnType<typeof setVisibleEntities> | ReturnType<typeof setNodesUptimeFilter> | ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setNodesSortParams> | ReturnType<typeof setGroupsSortParams>;
 export interface StorageStateSlice {
     storage: StorageState;
 }

package/dist/store/reducers/storage/utils.d.ts

@@ -1,6 +1,8 @@
 import type { TNodesInfo } from '../../../types/api/nodes';
-import type { TStorageGroupInfoV2, TStorageInfo, TStoragePoolInfo } from '../../../types/api/storage';
+import type { TStorageGroupInfo, TStorageGroupInfoV2, TStorageInfo, TStoragePoolInfo } from '../../../types/api/storage';
 import type { PreparedStorageGroup, PreparedStorageResponse } from './types';
-export declare const prepareStorageGroups: (StorageGroups?: TStorageGroupInfoV2[] | undefined, StoragePools?: TStoragePoolInfo[] | undefined) => PreparedStorageGroup[];
+export declare const prepareStorageGroupData: (group: TStorageGroupInfo, poolName?: string) => PreparedStorageGroup;
+export declare const prepareStorageGroupDataV2: (group: TStorageGroupInfoV2) => PreparedStorageGroup;
+export declare const prepareStorageGroups: (StorageGroups?: TStorageGroupInfoV2[], StoragePools?: TStoragePoolInfo[]) => PreparedStorageGroup[];
 export declare const prepareStorageNodesResponse: (data: TNodesInfo) => PreparedStorageResponse;
 export declare const prepareStorageGroupsResponse: (data: TStorageInfo) => PreparedStorageResponse;

package/dist/store/reducers/storage/utils.js

@@ -1,11 +1,14 @@
 import { EVDiskState } from '../../../types/api/vdisk';
 import { TPDiskState } from '../../../types/api/pdisk';
 import { EFlag } from '../../../types/api/enums';
-import { getPDiskType } from '../../../utils/pdisk';
+import { preparePDiskData, prepareVDiskData } from '../../../utils/disks/prepareDisks';
 import { getUsage } from '../../../utils/storage';
-import { calcUptime } from '../../../utils/dataFormatters/dataFormatters';
+import { prepareNodeSystemState } from '../../../utils/nodes';
 // ==== Constants  ====
+// Do not count Grey and Blue statuses in used space severity calculations
 const FLAGS_POINTS = {
+    [EFlag.Grey]: 0,
+    [EFlag.Blue]: 0,
     [EFlag.Green]: 1,
     [EFlag.Yellow]: 100,
     [EFlag.Orange]: 10000,
@@ -14,10 +17,11 @@ const FLAGS_POINTS = {
 // ==== Prepare groups ====
 const prepareVDisk = (vDisk, poolName) => {
     var _a;
+    const preparedVDisk = prepareVDiskData(vDisk);
     // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
-    return Object.assign(Object.assign({}, vDisk), { StoragePoolName: poolName, Donors: (_a = vDisk.Donors) === null || _a === void 0 ? void 0 : _a.map((donor) => (Object.assign(Object.assign({}, donor), { StoragePoolName: poolName }))) });
+    return Object.assign(Object.assign({}, preparedVDisk), { StoragePoolName: poolName, Donors: (_a = preparedVDisk === null || preparedVDisk === void 0 ? void 0 : preparedVDisk.Donors) === null || _a === void 0 ? void 0 : _a.map((donor) => (Object.assign(Object.assign({}, donor), { StoragePoolName: poolName }))) });
 };
-const prepareStorageGroupData = (group, poolName) => {
+export const prepareStorageGroupData = (group, poolName) => {
     var _a;
     let missing = 0;
     let usedSpaceFlag = 0;
@@ -29,32 +33,28 @@ const prepareStorageGroupData = (group, poolName) => {
     if (group.VDisks) {
         for (const vDisk of group.VDisks) {
             const { Replicated, VDiskState, AvailableSize, AllocatedSize, PDisk, DiskSpace, ReadThroughput, WriteThroughput, } = vDisk;
-            if (!Replicated ||
-                (PDisk === null || PDisk === void 0 ? void 0 : PDisk.State) !== TPDiskState.Normal ||
-                VDiskState !== EVDiskState.OK) {
+            const { Type: PDiskType, State: PDiskState, AvailableSize: PDiskAvailableSize, } = preparePDiskData(PDisk);
+            if (!Replicated || PDiskState !== TPDiskState.Normal || VDiskState !== EVDiskState.OK) {
                 missing += 1;
             }
-            if (DiskSpace && DiskSpace !== EFlag.Grey) {
+            if (DiskSpace) {
                 usedSpaceFlag += FLAGS_POINTS[DiskSpace];
             }
-            const available = Number(AvailableSize !== null && AvailableSize !== void 0 ? AvailableSize : PDisk === null || PDisk === void 0 ? void 0 : PDisk.AvailableSize) || 0;
+            const available = Number(AvailableSize !== null && AvailableSize !== void 0 ? AvailableSize : PDiskAvailableSize) || 0;
             const allocated = Number(AllocatedSize) || 0;
             usedSpaceBytes += allocated;
             limitSizeBytes += available + allocated;
             readSpeedBytesPerSec += Number(ReadThroughput) || 0;
             writeSpeedBytesPerSec += Number(WriteThroughput) || 0;
-            const currentType = getPDiskType(PDisk || {});
             mediaType =
-                currentType && (currentType === mediaType || mediaType === '')
-                    ? currentType
-                    : 'Mixed';
+                PDiskType && (PDiskType === mediaType || mediaType === '') ? PDiskType : 'Mixed';
         }
     }
     const vDisks = (_a = group.VDisks) === null || _a === void 0 ? void 0 : _a.map((vdisk) => prepareVDisk(vdisk, poolName));
     const usage = getUsage({ Used: usedSpaceBytes, Limit: limitSizeBytes }, 5);
     return Object.assign(Object.assign({}, group), { VDisks: vDisks, Usage: usage, Read: readSpeedBytesPerSec, Write: writeSpeedBytesPerSec, PoolName: poolName, Used: usedSpaceBytes, Limit: limitSizeBytes, Degraded: missing, UsedSpaceFlag: usedSpaceFlag, Kind: mediaType || undefined });
 };
-const prepareStorageGroupDataV2 = (group) => {
+export const prepareStorageGroupDataV2 = (group) => {
     const { VDisks = [], PoolName, Usage = 0, Read = 0, Write = 0, Used = 0, Limit = 0, Degraded = 0, Kind, } = group;
     const UsedSpaceFlag = VDisks.reduce((acc, { DiskSpace }) => {
         if (DiskSpace && DiskSpace !== EFlag.Grey) {
@@ -85,24 +85,17 @@ export const prepareStorageGroups = (StorageGroups, StoragePools) => {
 };
 // ==== Prepare nodes ====
 const prepareStorageNodeData = (node) => {
-    var _a, _b, _c, _d;
-    const systemState = (_a = node.SystemState) !== null && _a !== void 0 ? _a : {};
-    const missing = ((_b = node.PDisks) === null || _b === void 0 ? void 0 : _b.filter((pDisk) => {
+    var _a, _b, _c;
+    const missing = ((_a = node.PDisks) === null || _a === void 0 ? void 0 : _a.filter((pDisk) => {
         return pDisk.State !== TPDiskState.Normal;
     }).length) || 0;
-    return {
-        NodeId: node.NodeId,
-        SystemState: systemState.SystemState,
-        DC: (_c = systemState.Location) === null || _c === void 0 ? void 0 : _c.DataCenter,
-        Rack: (_d = systemState.Location) === null || _d === void 0 ? void 0 : _d.Rack,
-        Host: systemState.Host,
-        Endpoints: systemState.Endpoints,
-        Uptime: calcUptime(systemState.StartTime),
-        StartTime: systemState.StartTime,
-        PDisks: node.PDisks,
-        VDisks: node.VDisks,
-        Missing: missing,
-    };
+    const pDisks = (_b = node.PDisks) === null || _b === void 0 ? void 0 : _b.map((pDisk) => {
+        return Object.assign(Object.assign({}, preparePDiskData(pDisk)), { NodeId: node.NodeId });
+    });
+    const vDisks = (_c = node.VDisks) === null || _c === void 0 ? void 0 : _c.map((vDisk) => {
+        return Object.assign(Object.assign({}, prepareVDiskData(vDisk)), { NodeId: node.NodeId });
+    });
+    return Object.assign(Object.assign({}, prepareNodeSystemState(node.SystemState)), { NodeId: node.NodeId, PDisks: pDisks, VDisks: vDisks, Missing: missing });
 };
 // ==== Prepare responses ====
 export const prepareStorageNodesResponse = (data) => {

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

@@ -1,4 +1,4 @@
-import type { Reducer } from 'redux';
+import type { Reducer } from '@reduxjs/toolkit';
 import type { TDomainKey } from '../../types/api/tablet';
 import type { ITabletAction, ITabletDescribeHandledResponse, ITabletHandledResponse, ITabletState } from '../../types/store/tablet';
 export declare const FETCH_TABLET: {
@@ -12,8 +12,170 @@ export declare const FETCH_TABLET_DESCRIBE: {
     readonly FAILURE: "TABLET/FETCH_TABLET_DESCRIBE_FAILURE";
 };
 declare const tablet: Reducer<ITabletState, ITabletAction>;
-export declare const getTablet: (id: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<ITabletHandledResponse | undefined>;
-export declare const getTabletDescribe: (tenantId?: TDomainKey) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<ITabletDescribeHandledResponse | undefined>;
+export declare const getTablet: (id: string) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+    singleClusterMode: boolean;
+    nodes: import("./nodes/types").NodesState;
+    topNodesByLoad: import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+    topNodesByCpu: import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+    topNodesByMemory: import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+    cluster: import("./cluster/types").ClusterState;
+    clusterNodes: import("./clusterNodes/types").ClusterNodesState;
+    tenant: import("./tenant/types").TenantState;
+    storage: import("./storage/types").StorageState;
+    topStorageGroups: import("./tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+    node: import("./node/types").NodeState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").ITabletsState;
+    schema: import("./schema/types").SchemaState;
+    overview: import("./overview/types").OverviewState;
+    olapStats: import("../../types/store/olapStats").OlapStatsState;
+    host: import("../../types/store/host").IHostState;
+    network: import("./network/types").NetworkState;
+    tenants: import("./tenants/types").TenantsState;
+    tablet: ITabletState;
+    topic: import("../../types/store/topic").ITopicState;
+    partitions: import("./partitions/types").PartitionsState;
+    pDisk: import("./pdisk/types").PDiskState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    explainQuery: import("../../types/store/explainQuery").ExplainQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    preview: any;
+    nodesList: import("../../types/store/nodesList").NodesListState;
+    describe: import("../../types/store/describe").IDescribeState;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").ITopQueriesState;
+    executeTopTables: import("./tenantOverview/executeTopTables/types").TopTablesState;
+    tenantOverviewTopQueries: import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+    healthcheckInfo: import("./healthcheckInfo/types").HealthcheckInfoState;
+    shardsWorkload: import("./shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("./tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: import("./hotKeys/types").HotKeysState;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersState;
+}) => Promise<ITabletHandledResponse | undefined>;
+export declare const getTabletDescribe: (tenantId?: TDomainKey) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+    singleClusterMode: boolean;
+    nodes: import("./nodes/types").NodesState;
+    topNodesByLoad: import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+    topNodesByCpu: import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+    topNodesByMemory: import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+    cluster: import("./cluster/types").ClusterState;
+    clusterNodes: import("./clusterNodes/types").ClusterNodesState;
+    tenant: import("./tenant/types").TenantState;
+    storage: import("./storage/types").StorageState;
+    topStorageGroups: import("./tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+    node: import("./node/types").NodeState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").ITabletsState;
+    schema: import("./schema/types").SchemaState;
+    overview: import("./overview/types").OverviewState;
+    olapStats: import("../../types/store/olapStats").OlapStatsState;
+    host: import("../../types/store/host").IHostState;
+    network: import("./network/types").NetworkState;
+    tenants: import("./tenants/types").TenantsState;
+    tablet: ITabletState;
+    topic: import("../../types/store/topic").ITopicState;
+    partitions: import("./partitions/types").PartitionsState;
+    pDisk: import("./pdisk/types").PDiskState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    explainQuery: import("../../types/store/explainQuery").ExplainQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    preview: any;
+    nodesList: import("../../types/store/nodesList").NodesListState;
+    describe: import("../../types/store/describe").IDescribeState;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").ITopQueriesState;
+    executeTopTables: import("./tenantOverview/executeTopTables/types").TopTablesState;
+    tenantOverviewTopQueries: import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+    healthcheckInfo: import("./healthcheckInfo/types").HealthcheckInfoState;
+    shardsWorkload: import("./shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("./tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: import("./hotKeys/types").HotKeysState;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersState;
+}) => Promise<ITabletDescribeHandledResponse | undefined>;
 export declare const clearTabletData: () => {
     readonly type: "tablet/CLEAR_TABLET_DATA";
 };

package/dist/store/reducers/tablet.js

@@ -72,7 +72,7 @@ export const getTabletDescribe = (tenantId = {}) => {
         actions: FETCH_TABLET_DESCRIBE,
         dataHandler: (tabletDescribe) => {
             const { SchemeShard, PathId } = tenantId;
-            const tenantPath = tabletDescribe.Path || `${SchemeShard}:${PathId}`;
+            const tenantPath = (tabletDescribe === null || tabletDescribe === void 0 ? void 0 : tabletDescribe.Path) || `${SchemeShard}:${PathId}`;
             return { tenantPath };
         },
     });

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

@@ -1,4 +1,4 @@
-import type { Reducer } from 'redux';
+import type { Reducer } from '@reduxjs/toolkit';
 import type { ETabletState, EType } from '../../types/api/tablet';
 import type { ITabletsAction, ITabletsApiRequestParams, ITabletsState } from '../../types/store/tablets';
 export declare const FETCH_TABLETS: {
@@ -18,5 +18,86 @@ export declare const setTypeFilter: (typeFilter: EType[]) => {
 export declare const clearWasLoadingFlag: () => {
     readonly type: "tablets/CLEAR_WAS_LOADING_TABLETS";
 };
-export declare function getTabletsInfo(data: ITabletsApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export declare function getTabletsInfo(data: ITabletsApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+    singleClusterMode: boolean;
+    nodes: import("./nodes/types").NodesState;
+    topNodesByLoad: import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+    topNodesByCpu: import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+    topNodesByMemory: import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+    cluster: import("./cluster/types").ClusterState;
+    clusterNodes: import("./clusterNodes/types").ClusterNodesState;
+    tenant: import("./tenant/types").TenantState;
+    storage: import("./storage/types").StorageState;
+    topStorageGroups: import("./tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+    node: import("./node/types").NodeState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: ITabletsState;
+    schema: import("./schema/types").SchemaState;
+    overview: import("./overview/types").OverviewState;
+    olapStats: import("../../types/store/olapStats").OlapStatsState;
+    host: import("../../types/store/host").IHostState;
+    network: import("./network/types").NetworkState;
+    tenants: import("./tenants/types").TenantsState;
+    tablet: import("../../types/store/tablet").ITabletState;
+    topic: import("../../types/store/topic").ITopicState;
+    partitions: import("./partitions/types").PartitionsState;
+    pDisk: import("./pdisk/types").PDiskState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    explainQuery: import("../../types/store/explainQuery").ExplainQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    preview: any;
+    nodesList: import("../../types/store/nodesList").NodesListState;
+    describe: import("../../types/store/describe").IDescribeState;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").ITopQueriesState;
+    executeTopTables: import("./tenantOverview/executeTopTables/types").TopTablesState;
+    tenantOverviewTopQueries: import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+    healthcheckInfo: import("./healthcheckInfo/types").HealthcheckInfoState;
+    shardsWorkload: import("./shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("./tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: import("./hotKeys/types").HotKeysState;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersState;
+}) => Promise<unknown>;
 export default tablets;

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

@@ -1,4 +1,85 @@
-export function getTabletsInfo(data: any): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<any>;
+export function getTabletsInfo(data: any): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+    singleClusterMode: boolean;
+    nodes: import("./nodes/types").NodesState;
+    topNodesByLoad: import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+    topNodesByCpu: import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+    topNodesByMemory: import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+    cluster: import("./cluster/types").ClusterState;
+    clusterNodes: import("./clusterNodes/types").ClusterNodesState;
+    tenant: import("./tenant/types").TenantState;
+    storage: import("./storage/types").StorageState;
+    topStorageGroups: import("./tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+    node: import("./node/types").NodeState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").ITabletsState;
+    schema: import("./schema/types").SchemaState;
+    overview: import("./overview/types").OverviewState;
+    olapStats: import("../../types/store/olapStats").OlapStatsState;
+    host: import("../../types/store/host").IHostState;
+    network: import("./network/types").NetworkState;
+    tenants: import("./tenants/types").TenantsState;
+    tablet: import("../../types/store/tablet").ITabletState;
+    topic: import("../../types/store/topic").ITopicState;
+    partitions: import("./partitions/types").PartitionsState;
+    pDisk: import("./pdisk/types").PDiskState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    explainQuery: import("../../types/store/explainQuery").ExplainQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    preview: any;
+    nodesList: import("../../types/store/nodesList").NodesListState;
+    describe: import("../../types/store/describe").IDescribeState;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").ITopQueriesState;
+    executeTopTables: import("./tenantOverview/executeTopTables/types").TopTablesState;
+    tenantOverviewTopQueries: import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+    healthcheckInfo: import("./healthcheckInfo/types").HealthcheckInfoState;
+    shardsWorkload: import("./shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("./tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: import("./hotKeys/types").HotKeysState;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersState;
+}) => Promise<any>;
 export function clearWasLoadingFlag(): {
     type: string;
 };
@@ -11,8 +92,26 @@ export function setTypeFilter(typeFilter: any): {
     data: any;
 };
 export function getTablets(state: any): any;
-export const getFilteredTablets: ((state: {}) => any) & import("reselect").OutputSelectorFields<(args_0: any, args_1: any, args_2: any) => any> & {
+export const getFilteredTablets: ((state: any) => any) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: any, resultFuncArgs_1: any, resultFuncArgs_2: any) => any;
+    memoizedResultFunc: ((resultFuncArgs_0: any, resultFuncArgs_1: any, resultFuncArgs_2: any) => any) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => any;
+    dependencies: [(state: any) => any, (state: any) => any, (state: any) => any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
 export default tabletsFilters;
 declare function tabletsFilters(state: {

package/dist/store/reducers/tabletsFilters.js

@@ -1,4 +1,4 @@
-import { createSelector } from 'reselect';
+import { createSelector } from '@reduxjs/toolkit';
 import { createRequestActionTypes, createApiRequest } from '../utils';
 import { AUTO_RELOAD_INTERVAL } from '../../utils/constants';
 const FETCH_TABLETS_FILTERS = createRequestActionTypes('tabletsFilters', 'FETCH_TABLETS_FILTERS');