ydb-embedded-ui 5.5.0 → 6.0.1

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

@@ -1,42 +1,1647 @@
-import type { Reducer, Selector } from '@reduxjs/toolkit';
-import type { HealthCheckInfoAction, HealthcheckInfoRootStateSlice, HealthcheckInfoState, IssuesTree } from './types';
 import type { IssueLog, StatusFlag } from '../../../types/api/healthcheck';
-export declare const FETCH_HEALTHCHECK: {
-    readonly REQUEST: "cluster/FETCH_HEALTHCHECK_REQUEST";
-    readonly SUCCESS: "cluster/FETCH_HEALTHCHECK_SUCCESS";
-    readonly FAILURE: "cluster/FETCH_HEALTHCHECK_FAILURE";
+import type { RootState } from '../../defaultStore';
+import type { IssuesTree } from './types';
+export declare const healthcheckApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export declare const selectIssuesTreesRoots: ((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;
+}, database: string) => IssueLog[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IssueLog[]) => IssueLog[];
+    memoizedResultFunc: ((resultFuncArgs_0: IssueLog[]) => IssueLog[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IssueLog[];
+    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;
+    }, database: string) => IssueLog[]) & {
+        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<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => IssueLog[];
+        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<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => IssueLog[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IssueLog[];
+        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, database: string) => (state: import("@reduxjs/toolkit/query").RootState<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            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 selectIssuesTrees: ((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;
+}, database: string) => IssuesTree[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IssueLog[], resultFuncArgs_1: IssueLog[]) => IssuesTree[];
+    memoizedResultFunc: ((resultFuncArgs_0: IssueLog[], resultFuncArgs_1: IssueLog[]) => IssuesTree[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => IssuesTree[];
+    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;
+    }, database: string) => IssueLog[]) & {
+        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<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => IssueLog[];
+        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<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => IssueLog[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IssueLog[];
+        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, database: string) => (state: import("@reduxjs/toolkit/query").RootState<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            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;
+    }, ((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;
+    }, database: string) => IssueLog[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: IssueLog[]) => IssueLog[];
+        memoizedResultFunc: ((resultFuncArgs_0: IssueLog[]) => IssueLog[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IssueLog[];
+        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;
+        }, database: string) => IssueLog[]) & {
+            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<{
+                getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+                requestId: string;
+                endpointName: string;
+                startedTimeStamp: number;
+                data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+                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: string;
+                requestId: string;
+                data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+                fulfilledTimeStamp?: number | undefined;
+                originalArgs: string;
+                requestId: string;
+                endpointName: string;
+                startedTimeStamp: number;
+                error: unknown;
+            } & {
+                status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+                isUninitialized: false;
+                isLoading: false;
+                isSuccess: false;
+                isError: true;
+            })) => IssueLog[];
+            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<{
+                getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+                requestId: string;
+                endpointName: string;
+                startedTimeStamp: number;
+                data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+                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: string;
+                requestId: string;
+                data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+                fulfilledTimeStamp?: number | undefined;
+                originalArgs: string;
+                requestId: string;
+                endpointName: string;
+                startedTimeStamp: number;
+                error: unknown;
+            } & {
+                status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+                isUninitialized: false;
+                isLoading: false;
+                isSuccess: false;
+                isError: true;
+            })) => IssueLog[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => IssueLog[];
+            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, database: string) => (state: import("@reduxjs/toolkit/query").RootState<{
+                getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+                requestId: string;
+                endpointName: string;
+                startedTimeStamp: number;
+                data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+                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: string;
+                requestId: string;
+                data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+                fulfilledTimeStamp?: number | undefined;
+                originalArgs: string;
+                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;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-declare const healthcheckInfo: Reducer<HealthcheckInfoState, HealthCheckInfoAction>;
-export declare const selectIssuesTreesRoots: Selector<HealthcheckInfoRootStateSlice, IssueLog[]>;
-export declare const selectIssuesTrees: Selector<HealthcheckInfoRootStateSlice, IssuesTree[]>;
-export declare const selectIssuesStatistics: Selector<HealthcheckInfoRootStateSlice, [
-    StatusFlag,
-    number
-][]>;
-export declare function getHealthcheckInfo(database: string): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+export declare const selectIssuesStatistics: ((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: 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: {
@@ -78,25 +1683,491 @@ export declare function getHealthcheckInfo(database: string): (dispatch: import(
     };
     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: 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 setDataWasNotLoaded: () => {
-    readonly type: "healthcheckInfo/SET_DATA_WAS_NOT_LOADED";
+    clusters: import("../clusters/types").ClustersFilters;
+}, database: string) => [StatusFlag, number][]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: IssueLog[]) => [StatusFlag, number][];
+    memoizedResultFunc: ((resultFuncArgs_0: IssueLog[]) => [StatusFlag, number][]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => [StatusFlag, number][];
+    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;
+    }, database: string) => IssueLog[]) & {
+        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<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => IssueLog[];
+        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<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            error: unknown;
+        } & {
+            status: import("@reduxjs/toolkit/query").QueryStatus.rejected;
+            isUninitialized: false;
+            isLoading: false;
+            isSuccess: false;
+            isError: true;
+        })) => IssueLog[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => IssueLog[];
+        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, database: string) => (state: import("@reduxjs/toolkit/query").RootState<{
+            getHealthcheckInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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: string;
+            requestId: string;
+            endpointName: string;
+            startedTimeStamp: number;
+            data: import("../../../types/api/healthcheck").HealthCheckAPIResponse;
+            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: string;
+            requestId: string;
+            data?: import("../../../types/api/healthcheck").HealthCheckAPIResponse | 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/healthcheck").HealthCheckAPIResponse | undefined;
+            fulfilledTimeStamp?: number | undefined;
+            originalArgs: string;
+            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 default healthcheckInfo;