ydb-embedded-ui 5.5.0 → 6.0.0

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

@@ -1,41 +1,1174 @@
-import type { Reducer, Selector } from '@reduxjs/toolkit';
-import type { IPreparedConsumerData, IPreparedTopicStats, ITopicAction, ITopicRootStateSlice, ITopicState } from '../../types/store/topic';
-export declare const FETCH_TOPIC: {
-    readonly REQUEST: "topic/FETCH_TOPIC_REQUEST";
-    readonly SUCCESS: "topic/FETCH_TOPIC_SUCCESS";
-    readonly FAILURE: "topic/FETCH_TOPIC_FAILURE";
-};
-declare const topic: Reducer<ITopicState, ITopicAction>;
-export declare const setDataWasNotLoaded: () => {
-    readonly type: "topic/SET_DATA_WAS_NOT_LOADED";
+import type { RootState } from '../defaultStore';
+export declare const topicApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path?: string | undefined;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export declare const selectConsumersNames: ((state: {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    nodes: import("./nodes/types").NodesState;
+    cluster: import("./cluster/types").ClusterState;
+    tenant: import("./tenant/types").TenantState;
+    storage: import("./storage/types").StorageState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").TabletsState;
+    schema: import("./schema/types").SchemaState;
+    host: import("../../types/store/host").IHostState;
+    tenants: import("./tenants/types").TenantsState;
+    partitions: import("./partitions/types").PartitionsState;
+    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;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("./hotKeys/types").HotKeysState;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersFilters;
+}, path?: string | undefined) => string[] | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../types/api/consumer").Consumer[] | undefined) => string[] | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../types/api/consumer").Consumer[] | undefined) => string[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[] | undefined;
+    dependencies: [((state: {
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+        singleClusterMode: boolean;
+        nodes: import("./nodes/types").NodesState;
+        cluster: import("./cluster/types").ClusterState;
+        tenant: import("./tenant/types").TenantState;
+        storage: import("./storage/types").StorageState;
+        tooltip: import("../../types/store/tooltip").ITooltipState;
+        tablets: import("../../types/store/tablets").TabletsState;
+        schema: import("./schema/types").SchemaState;
+        host: import("../../types/store/host").IHostState;
+        tenants: import("./tenants/types").TenantsState;
+        partitions: import("./partitions/types").PartitionsState;
+        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;
+        schemaAcl: import("./schemaAcl/types").SchemaAclState;
+        executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+        shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+        hotKeys: import("./hotKeys/types").HotKeysState;
+        authentication: import("./authentication/types").AuthenticationState;
+        header: import("./header/types").HeaderState;
+        saveQuery: string | null;
+        fullscreen: boolean;
+        clusters: import("./clusters/types").ClustersFilters;
+    }, path?: string | undefined) => import("../../types/api/consumer").Consumer[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, resultFuncArgs_1: (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => import("../../types/api/consumer").Consumer[] | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, resultFuncArgs_1: (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => import("../../types/api/consumer").Consumer[] | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("../../types/api/consumer").Consumer[] | undefined;
+        dependencies: [(state: RootState) => {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, (_state: RootState, path?: string) => (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const cleanTopicData: () => {
-    readonly type: "topic/CLEAN_TOPIC_DATA";
+export declare const selectPreparedTopicStats: ((state: {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    nodes: import("./nodes/types").NodesState;
+    cluster: import("./cluster/types").ClusterState;
+    tenant: import("./tenant/types").TenantState;
+    storage: import("./storage/types").StorageState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").TabletsState;
+    schema: import("./schema/types").SchemaState;
+    host: import("../../types/store/host").IHostState;
+    tenants: import("./tenants/types").TenantsState;
+    partitions: import("./partitions/types").PartitionsState;
+    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;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("./hotKeys/types").HotKeysState;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersFilters;
+}, path?: string | undefined) => {
+    storeSize: string;
+    partitionsIdleTime: number;
+    partitionsWriteLag: number;
+    writeSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+} | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../types/api/topic").TopicStats | undefined) => {
+        storeSize: string;
+        partitionsIdleTime: number;
+        partitionsWriteLag: number;
+        writeSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+    } | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../types/api/topic").TopicStats | undefined) => {
+        storeSize: string;
+        partitionsIdleTime: number;
+        partitionsWriteLag: number;
+        writeSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+    } | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        storeSize: string;
+        partitionsIdleTime: number;
+        partitionsWriteLag: number;
+        writeSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+    } | undefined;
+    dependencies: [((state: {
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+        singleClusterMode: boolean;
+        nodes: import("./nodes/types").NodesState;
+        cluster: import("./cluster/types").ClusterState;
+        tenant: import("./tenant/types").TenantState;
+        storage: import("./storage/types").StorageState;
+        tooltip: import("../../types/store/tooltip").ITooltipState;
+        tablets: import("../../types/store/tablets").TabletsState;
+        schema: import("./schema/types").SchemaState;
+        host: import("../../types/store/host").IHostState;
+        tenants: import("./tenants/types").TenantsState;
+        partitions: import("./partitions/types").PartitionsState;
+        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;
+        schemaAcl: import("./schemaAcl/types").SchemaAclState;
+        executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+        shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+        hotKeys: import("./hotKeys/types").HotKeysState;
+        authentication: import("./authentication/types").AuthenticationState;
+        header: import("./header/types").HeaderState;
+        saveQuery: string | null;
+        fullscreen: boolean;
+        clusters: import("./clusters/types").ClustersFilters;
+    }, path?: string | undefined) => import("../../types/api/topic").TopicStats | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, resultFuncArgs_1: (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => import("../../types/api/topic").TopicStats | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, resultFuncArgs_1: (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => import("../../types/api/topic").TopicStats | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("../../types/api/topic").TopicStats | undefined;
+        dependencies: [(state: RootState) => {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, (_state: RootState, path?: string) => (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare function getTopic(path?: string): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+export declare const selectPreparedConsumersData: ((state: {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     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;
+    tablets: import("../../types/store/tablets").TabletsState;
     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: ITopicState;
     partitions: import("./partitions/types").PartitionsState;
-    pDisk: import("./pdisk/types").PDiskState;
     executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
     explainQuery: import("../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
@@ -77,25 +1210,539 @@ export declare function getTopic(path?: string): (dispatch: import("redux").Disp
     };
     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;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
     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;
-    vDisk: import("./vdisk/types").VDiskState;
-}) => Promise<unknown>;
-export declare const selectConsumersNames: Selector<ITopicRootStateSlice, string[] | undefined>;
-export declare const selectPreparedTopicStats: Selector<ITopicRootStateSlice, IPreparedTopicStats | undefined>;
-export declare const selectPreparedConsumersData: Selector<ITopicRootStateSlice, IPreparedConsumerData[] | undefined>;
-export default topic;
+    clusters: import("./clusters/types").ClustersFilters;
+}, path?: string | undefined) => {
+    name: string | undefined;
+    readSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+    writeLag: number;
+    readLag: number;
+    readIdleTime: number;
+}[] | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../types/api/consumer").Consumer[] | undefined) => {
+        name: string | undefined;
+        readSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+        writeLag: number;
+        readLag: number;
+        readIdleTime: number;
+    }[] | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../types/api/consumer").Consumer[] | undefined) => {
+        name: string | undefined;
+        readSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+        writeLag: number;
+        readLag: number;
+        readIdleTime: number;
+    }[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        name: string | undefined;
+        readSpeed: import("../../utils/bytesParsers").ProcessSpeedStats;
+        writeLag: number;
+        readLag: number;
+        readIdleTime: number;
+    }[] | undefined;
+    dependencies: [((state: {
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+        singleClusterMode: boolean;
+        nodes: import("./nodes/types").NodesState;
+        cluster: import("./cluster/types").ClusterState;
+        tenant: import("./tenant/types").TenantState;
+        storage: import("./storage/types").StorageState;
+        tooltip: import("../../types/store/tooltip").ITooltipState;
+        tablets: import("../../types/store/tablets").TabletsState;
+        schema: import("./schema/types").SchemaState;
+        host: import("../../types/store/host").IHostState;
+        tenants: import("./tenants/types").TenantsState;
+        partitions: import("./partitions/types").PartitionsState;
+        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;
+        schemaAcl: import("./schemaAcl/types").SchemaAclState;
+        executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+        shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+        hotKeys: import("./hotKeys/types").HotKeysState;
+        authentication: import("./authentication/types").AuthenticationState;
+        header: import("./header/types").HeaderState;
+        saveQuery: string | null;
+        fullscreen: boolean;
+        clusters: import("./clusters/types").ClustersFilters;
+    }, path?: string | undefined) => import("../../types/api/consumer").Consumer[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, resultFuncArgs_1: (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => import("../../types/api/consumer").Consumer[] | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, resultFuncArgs_1: (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => import("../../types/api/consumer").Consumer[] | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("../../types/api/consumer").Consumer[] | undefined;
+        dependencies: [(state: RootState) => {
+            api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+            singleClusterMode: boolean;
+            nodes: import("./nodes/types").NodesState;
+            cluster: import("./cluster/types").ClusterState;
+            tenant: import("./tenant/types").TenantState;
+            storage: import("./storage/types").StorageState;
+            tooltip: import("../../types/store/tooltip").ITooltipState;
+            tablets: import("../../types/store/tablets").TabletsState;
+            schema: import("./schema/types").SchemaState;
+            host: import("../../types/store/host").IHostState;
+            tenants: import("./tenants/types").TenantsState;
+            partitions: import("./partitions/types").PartitionsState;
+            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;
+            schemaAcl: import("./schemaAcl/types").SchemaAclState;
+            executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+            shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+            hotKeys: import("./hotKeys/types").HotKeysState;
+            authentication: import("./authentication/types").AuthenticationState;
+            header: import("./header/types").HeaderState;
+            saveQuery: string | null;
+            fullscreen: boolean;
+            clusters: import("./clusters/types").ClustersFilters;
+        }, (_state: RootState, path?: string) => (state: import("@reduxjs/toolkit/query").RootState<{
+            getTopic: import("@reduxjs/toolkit/query").QueryDefinition<{
+                path?: string | undefined;
+            }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/topic").DescribeTopicResult | undefined, "api">;
+        }, "All", "api">) => ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            originalArgs?: undefined;
+            data?: undefined;
+            error?: undefined;
+            requestId?: undefined;
+            endpointName?: string | undefined;
+            startedTimeStamp?: undefined;
+            fulfilledTimeStamp?: undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.uninitialized;
+            isUninitialized: true;
+            isLoading: false;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            error: undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../types/api/topic").DescribeTopicResult;
+            fulfilledTimeStamp: number;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.fulfilled;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: true;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            error?: unknown;
+            endpointName: string;
+            startedTimeStamp: number;
+            fulfilledTimeStamp?: number | undefined;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.pending;
+            isUninitialized: false;
+            isLoading: true;
+            isSuccess: false;
+            isError: false;
+        }) | ({
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            data?: import("../../types/api/topic").DescribeTopicResult | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: {
+                path?: string | undefined;
+            };
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};