ydb-embedded-ui 4.33.0 → 5.0.0

package/dist/store/reducers/header/header.js

@@ -0,0 +1,23 @@
+const SET_HEADER_BREADCRUMBS = 'header/SET_HEADER_BREADCRUMBS';
+const initialState = {
+    pageBreadcrumbsOptions: {},
+};
+const header = (state = initialState, action) => {
+    switch (action.type) {
+        case SET_HEADER_BREADCRUMBS:
+            return {
+                page: action.page,
+                pageBreadcrumbsOptions: action.options,
+            };
+        default:
+            return state;
+    }
+};
+export function setHeaderBreadcrumbs(page, options) {
+    return {
+        type: SET_HEADER_BREADCRUMBS,
+        page,
+        options,
+    };
+}
+export default header;

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

@@ -0,0 +1,28 @@
+import type { ClusterTab } from '../../../containers/Cluster/utils';
+import type { EType } from '../../../types/api/tablet';
+import { setHeaderBreadcrumbs } from './header';
+export declare type Page = 'cluster' | 'tenant' | 'node' | 'tablets' | 'tablet' | undefined;
+export interface ClusterBreadcrumbsOptions {
+    clusterName?: string;
+    clusterTab?: ClusterTab;
+}
+export interface TenantBreadcrumbsOptions extends ClusterBreadcrumbsOptions {
+    tenantName?: string;
+}
+export interface NodeBreadcrumbsOptions extends TenantBreadcrumbsOptions {
+    nodeId?: string | number;
+}
+export interface TabletsBreadcrumbsOptions extends TenantBreadcrumbsOptions {
+    nodeIds?: string[] | number[];
+}
+export interface TabletBreadcrumbsOptions extends TabletsBreadcrumbsOptions {
+    tabletId?: string;
+    tabletType?: EType;
+}
+export declare type BreadcrumbsOptions = ClusterBreadcrumbsOptions | TenantBreadcrumbsOptions | NodeBreadcrumbsOptions | TabletsBreadcrumbsOptions | TabletBreadcrumbsOptions;
+export declare type PageBreadcrumbsOptions<T extends Page = undefined> = T extends 'cluster' ? ClusterBreadcrumbsOptions : T extends 'tenant' ? TenantBreadcrumbsOptions : T extends 'node' ? NodeBreadcrumbsOptions : T extends 'tablets' ? TabletsBreadcrumbsOptions : T extends 'tablet' ? TabletBreadcrumbsOptions : {};
+export interface HeaderState {
+    page?: Page;
+    pageBreadcrumbsOptions: BreadcrumbsOptions;
+}
+export declare type HeaderAction = ReturnType<typeof setHeaderBreadcrumbs>;

package/dist/store/reducers/header/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,21 @@
+import { Selector } from 'reselect';
+import { Reducer } from 'redux';
+import type { IHealthCheckInfoAction, IHealthcheckInfoRootStateSlice, IHealthcheckInfoState, IIssuesTree } from '../../types/store/healthcheck';
+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";
+};
+declare const healthcheckInfo: Reducer<IHealthcheckInfoState, IHealthCheckInfoAction>;
+export declare const selectIssuesTreesRoots: Selector<IHealthcheckInfoRootStateSlice, IssueLog[]>;
+export declare const selectIssuesTrees: Selector<IHealthcheckInfoRootStateSlice, IIssuesTree[]>;
+export declare const selectIssuesStatistics: Selector<IHealthcheckInfoRootStateSlice, [
+    StatusFlag,
+    number
+][]>;
+export declare function getHealthcheckInfo(database: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "healthcheckInfo/SET_DATA_WAS_NOT_LOADED";
+};
+export default healthcheckInfo;

package/dist/store/reducers/healthcheckInfo.js

@@ -0,0 +1,93 @@
+import { createSelector } from 'reselect';
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_HEALTHCHECK = createRequestActionTypes('cluster', 'FETCH_HEALTHCHECK');
+const SET_DATA_WAS_NOT_LOADED = 'healthcheckInfo/SET_DATA_WAS_NOT_LOADED';
+const initialState = { loading: false, wasLoaded: false };
+const healthcheckInfo = function (state = initialState, action) {
+    var _a;
+    switch (action.type) {
+        case FETCH_HEALTHCHECK.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HEALTHCHECK.SUCCESS: {
+            const { data } = action;
+            return Object.assign(Object.assign({}, state), { data, wasLoaded: true, loading: false, error: undefined });
+        }
+        case FETCH_HEALTHCHECK.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false, wasLoaded: true, data: undefined });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+const mapStatusToPriority = {
+    RED: 0,
+    ORANGE: 1,
+    YELLOW: 2,
+    BLUE: 3,
+    GREEN: 4,
+};
+const sortIssues = (data) => {
+    return data.sort((a, b) => {
+        const aPriority = mapStatusToPriority[a.status] || 0;
+        const bPriority = mapStatusToPriority[b.status] || 0;
+        return aPriority - bPriority;
+    });
+};
+const getReasonsForIssue = ({ issue, data }) => {
+    return sortIssues(data.filter((item) => issue.reason && issue.reason.indexOf(item.id) !== -1));
+};
+const getRoots = (data) => {
+    return sortIssues(data.filter((item) => {
+        return !data.find((issue) => issue.reason && issue.reason.indexOf(item.id) !== -1);
+    }));
+};
+const getInvertedConsequencesTree = ({ data, roots, }) => {
+    return roots
+        ? roots.map((issue) => {
+            const reasonsItems = getInvertedConsequencesTree({
+                roots: getReasonsForIssue({ issue, data }),
+                data,
+            });
+            return Object.assign(Object.assign({}, issue), { reasonsItems });
+        })
+        : [];
+};
+const getIssuesStatistics = (data) => {
+    const issuesMap = {};
+    for (const issue of data) {
+        if (!issuesMap[issue.status]) {
+            issuesMap[issue.status] = 0;
+        }
+        issuesMap[issue.status]++;
+    }
+    return Object.entries(issuesMap).sort(([aStatus], [bStatus]) => {
+        const bPriority = mapStatusToPriority[bStatus] || 0;
+        const aPriority = mapStatusToPriority[aStatus] || 0;
+        return aPriority - bPriority;
+    });
+};
+const getIssuesLog = (state) => { var _a; return (_a = state.healthcheckInfo.data) === null || _a === void 0 ? void 0 : _a.issue_log; };
+export const selectIssuesTreesRoots = createSelector(getIssuesLog, (issues = []) => getRoots(issues));
+export const selectIssuesTrees = createSelector([getIssuesLog, selectIssuesTreesRoots], (data = [], roots = []) => {
+    return getInvertedConsequencesTree({ data, roots });
+});
+export const selectIssuesStatistics = createSelector(getIssuesLog, (issues = []) => getIssuesStatistics(issues));
+export function getHealthcheckInfo(database) {
+    return createApiRequest({
+        request: window.api.getHealthcheckInfo(database, { concurrentId: 'getHealthcheckInfo' }),
+        actions: FETCH_HEALTHCHECK,
+    });
+}
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export default healthcheckInfo;

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

@@ -0,0 +1,27 @@
+import type { Reducer } from 'redux';
+import type { IHeatmapAction, IHeatmapApiRequestParams, IHeatmapState, IHeatmapTabletData } from '../../types/store/heatmap';
+export declare const FETCH_HEATMAP: {
+    readonly REQUEST: "heatmap/FETCH_HEATMAP_REQUEST";
+    readonly SUCCESS: "heatmap/FETCH_HEATMAP_SUCCESS";
+    readonly FAILURE: "heatmap/FETCH_HEATMAP_FAILURE";
+};
+export declare const initialState: {
+    loading: boolean;
+    wasLoaded: boolean;
+    currentMetric: undefined;
+    sort: boolean;
+    heatmap: boolean;
+};
+declare const heatmap: Reducer<IHeatmapState, IHeatmapAction>;
+export declare function getTabletsInfo({ nodes, path }: IHeatmapApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<{
+    data: IHeatmapTabletData[];
+    metrics: {
+        value: string;
+        content: string;
+    }[] | undefined;
+} | undefined>;
+export declare function setHeatmapOptions(options: Partial<IHeatmapState>): {
+    readonly type: "heatmap/SET_HEATMAP_OPTIONS";
+    readonly data: Partial<IHeatmapState>;
+};
+export default heatmap;

package/dist/store/reducers/heatmap.js

@@ -0,0 +1,70 @@
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_HEATMAP = createRequestActionTypes('heatmap', 'FETCH_HEATMAP');
+const SET_HEATMAP_OPTIONS = 'heatmap/SET_HEATMAP_OPTIONS';
+export const initialState = {
+    loading: false,
+    wasLoaded: false,
+    currentMetric: undefined,
+    sort: false,
+    heatmap: false,
+};
+const heatmap = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_HEATMAP.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HEATMAP.SUCCESS: {
+            return Object.assign(Object.assign(Object.assign({}, state), action.data), { loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_HEATMAP.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false, wasLoaded: false });
+        }
+        case SET_HEATMAP_OPTIONS:
+            return Object.assign(Object.assign({}, state), action.data);
+        default:
+            return state;
+    }
+};
+export function getTabletsInfo({ nodes, path }) {
+    return createApiRequest({
+        request: Promise.all([
+            window.api.getTabletsInfo({ nodes, path }),
+            window.api.getHeatmapData({ path }),
+        ]),
+        actions: FETCH_HEATMAP,
+        dataHandler: ([tabletsData = {}, describe = {}]) => {
+            const { TabletStateInfo: tablets = [] } = tabletsData;
+            const TabletsMap = new Map();
+            const { PathDescription = {} } = describe;
+            const { TablePartitions = [], TablePartitionStats = [], TablePartitionMetrics = [], } = PathDescription;
+            tablets.forEach((item) => {
+                if (item.TabletId) {
+                    TabletsMap.set(item.TabletId, item);
+                }
+            });
+            TablePartitions.forEach((item, index) => {
+                const metrics = Object.assign({}, TablePartitionStats[index], TablePartitionMetrics[index]);
+                if (item.DatashardId) {
+                    TabletsMap.set(item.DatashardId, Object.assign(Object.assign({}, TabletsMap.get(item.DatashardId)), { metrics }));
+                }
+            });
+            const preparedTablets = Array.from(TabletsMap.values());
+            const selectMetrics = preparedTablets[0] &&
+                preparedTablets[0].metrics &&
+                Object.keys(preparedTablets[0].metrics).map((item) => {
+                    return {
+                        value: item,
+                        content: item,
+                    };
+                });
+            return { data: preparedTablets, metrics: selectMetrics };
+        },
+    });
+}
+export function setHeatmapOptions(options) {
+    return {
+        type: SET_HEATMAP_OPTIONS,
+        data: options,
+    };
+}
+export default heatmap;

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

@@ -0,0 +1,10 @@
+import type { Reducer } from 'redux';
+import type { IHostAction, IHostState } from '../../types/store/host';
+export declare const FETCH_HOST: {
+    readonly REQUEST: "host/FETCH_HOST_REQUEST";
+    readonly SUCCESS: "host/FETCH_HOST_SUCCESS";
+    readonly FAILURE: "host/FETCH_HOST_FAILURE";
+};
+declare const host: Reducer<IHostState, IHostAction>;
+export declare function getHostInfo(): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export default host;

package/dist/store/reducers/host.js

@@ -0,0 +1,26 @@
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_HOST = createRequestActionTypes('host', 'FETCH_HOST');
+const initialState = { loading: true, wasLoaded: false, data: {} };
+const host = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_HOST.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HOST.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: (_a = action.data.SystemStateInfo) === null || _a === void 0 ? void 0 : _a[0], loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_HOST.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        default:
+            return state;
+    }
+};
+export function getHostInfo() {
+    return createApiRequest({
+        request: window.api.getHostInfo(),
+        actions: FETCH_HOST,
+    });
+}
+export default host;

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

@@ -0,0 +1,11 @@
+export function getHotKeys(currentSchemaPath: any, enableSampling: any): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<any>;
+export function setHotKeysOptions(options: any): {
+    type: string;
+    data: any;
+};
+export default hotKeys;
+declare function hotKeys(state: {
+    loading: boolean;
+    data: {};
+    wasLoaded: boolean;
+} | undefined, action: any): any;

package/dist/store/reducers/hotKeys.js

@@ -1,57 +1,34 @@
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import '../../services/api';
-
+import { createRequestActionTypes, createApiRequest } from '../utils';
 const FETCH_HOT_KEYS = createRequestActionTypes('hot_keys', 'FETCH_HOT_KEYS');
 const SET_HOT_KEYS_OPTIONS = 'hot_keys/SET_HOT_KEYS_OPTIONS';
-
-const initialState = {loading: true, data: {}, wasLoaded: false};
-
+const initialState = { loading: true, data: {}, wasLoaded: false };
 const hotKeys = function (state = initialState, action) {
     switch (action.type) {
         case FETCH_HOT_KEYS.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
+            return Object.assign(Object.assign({}, state), { loading: true });
         }
         case FETCH_HOT_KEYS.SUCCESS: {
-            return {
-                ...state,
-                data: action.data.hotkeys,
-                loading: false,
-                error: undefined,
-                wasLoaded: true,
-            };
+            return Object.assign(Object.assign({}, state), { data: action.data.hotkeys, loading: false, error: undefined, wasLoaded: true });
         }
         case FETCH_HOT_KEYS.FAILURE: {
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
         }
         case SET_HOT_KEYS_OPTIONS:
-            return {
-                ...state,
-                ...action.data,
-            };
+            return Object.assign(Object.assign({}, state), action.data);
         default:
             return state;
     }
 };
-
 export function getHotKeys(currentSchemaPath, enableSampling) {
     return createApiRequest({
         request: window.api.getHotKeys(currentSchemaPath, enableSampling),
         actions: FETCH_HOT_KEYS,
     });
 }
-
 export function setHotKeysOptions(options) {
     return {
         type: SET_HOT_KEYS_OPTIONS,
         data: options,
     };
 }
-
 export default hotKeys;

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

@@ -0,0 +1,200 @@
+import singleClusterMode from './singleClusterMode';
+export declare const rootReducer: {
+    singleClusterMode: typeof singleClusterMode;
+    nodes: import("redux").Reducer<import("./nodes/types").NodesState, import("./nodes/types").NodesAction>;
+    topNodesByLoad: import("redux").Reducer<import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadState, import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadAction>;
+    topNodesByCpu: import("redux").Reducer<import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuState, import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuAction>;
+    topNodesByMemory: import("redux").Reducer<import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryState, import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryAction>;
+    cluster: import("redux").Reducer<import("./cluster/types").ClusterState, import("./cluster/types").ClusterAction>;
+    clusterNodes: import("redux").Reducer<import("./clusterNodes/types").ClusterNodesState, import("./clusterNodes/types").ClusterNodesAction>;
+    tenant: import("redux").Reducer<import("./tenant/types").TenantState, import("./tenant/types").TenantAction>;
+    storage: import("redux").Reducer<import("./storage/types").StorageState, import("./storage/types").StorageAction>;
+    topStorageGroups: import("redux").Reducer<import("./tenantOverview/topStorageGroups/types").TopStorageGroupsState, import("./tenantOverview/topStorageGroups/types").TopStorageGroupsAction>;
+    node: import("redux").Reducer<import("./node/types").NodeState, import("./node/types").NodeAction>;
+    tooltip: import("redux").Reducer<import("../../types/store/tooltip").ITooltipState, import("../../types/store/tooltip").ITooltipAction>;
+    tablets: import("redux").Reducer<import("../../types/store/tablets").ITabletsState, import("../../types/store/tablets").ITabletsAction>;
+    schema: import("redux").Reducer<import("./schema/types").SchemaState, import("./schema/types").SchemaAction>;
+    overview: import("redux").Reducer<import("./overview/types").OverviewState, import("./overview/types").OverviewAction>;
+    olapStats: import("redux").Reducer<import("../../types/store/olapStats").OlapStatsState, import("../../types/store/olapStats").OlapStatsAction>;
+    host: import("redux").Reducer<import("../../types/store/host").IHostState, import("../../types/store/host").IHostAction>;
+    network: import("redux").Reducer<import("./network/types").NetworkState, import("./network/types").NetworkAction>;
+    tenants: import("redux").Reducer<import("./tenants/types").TenantsState, import("./tenants/types").TenantsAction>;
+    tablet: import("redux").Reducer<import("../../types/store/tablet").ITabletState, import("../../types/store/tablet").ITabletAction>;
+    topic: import("redux").Reducer<import("../../types/store/topic").ITopicState, import("../../types/store/topic").ITopicAction>;
+    partitions: import("redux").Reducer<import("./partitions/types").PartitionsState, import("./partitions/types").PartitionsAction>;
+    executeQuery: import("redux").Reducer<import("../../types/store/executeQuery").ExecuteQueryState, import("../../types/store/executeQuery").ExecuteQueryAction>;
+    explainQuery: import("redux").Reducer<import("../../types/store/explainQuery").ExplainQueryState, import("../../types/store/explainQuery").ExplainQueryAction>;
+    tabletsFilters: (state: {
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | undefined, action: any) => {
+        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("redux").Reducer<import("../../types/store/heatmap").IHeatmapState, import("../../types/store/heatmap").IHeatmapAction>;
+    settings: import("redux").Reducer<import("./settings/types").SettingsState, import("./settings/types").SettingsAction>;
+    preview: (state: {
+        loading: boolean;
+        wasLoaded: boolean;
+    } | undefined, action: import("../utils").ApiRequestAction<{
+        readonly REQUEST: "preview/SEND_QUERY_REQUEST";
+        readonly SUCCESS: "preview/SEND_QUERY_SUCCESS";
+        readonly FAILURE: "preview/SEND_QUERY_FAILURE";
+    }, import("../../types/store/query").IQueryResult, import("../../types/store/query").QueryErrorResponse> | {
+        readonly type: "preview/SET_QUERY_OPTIONS";
+        readonly data: any;
+    }) => any;
+    nodesList: import("redux").Reducer<import("../../types/store/nodesList").NodesListState, import("../../types/store/nodesList").NodesListAction>;
+    describe: import("redux").Reducer<import("../../types/store/describe").IDescribeState, import("../../types/store/describe").IDescribeAction>;
+    schemaAcl: import("redux").Reducer<import("./schemaAcl/types").SchemaAclState, import("./schemaAcl/types").SchemaAclAction>;
+    executeTopQueries: import("redux").Reducer<import("./executeTopQueries/types").ITopQueriesState, import("./executeTopQueries/types").ITopQueriesAction>;
+    executeTopTables: import("redux").Reducer<import("./tenantOverview/executeTopTables/types").TopTablesState, import("./tenantOverview/executeTopTables/types").TopTablesAction>;
+    tenantOverviewTopQueries: import("redux").Reducer<import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesState, import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesAction>;
+    healthcheckInfo: import("redux").Reducer<import("../../types/store/healthcheck").IHealthcheckInfoState, import("../../types/store/healthcheck").IHealthCheckInfoAction>;
+    shardsWorkload: import("redux").Reducer<import("./shardsWorkload/types").IShardsWorkloadState, import("./shardsWorkload/types").IShardsWorkloadAction>;
+    tenantOverviewTopShards: import("redux").Reducer<import("./tenantOverview/topShards/types").TenantOverviewTopShardsState, import("./tenantOverview/topShards/types").TenantOverviewTopShardsAction>;
+    hotKeys: (state: {
+        loading: boolean;
+        data: {};
+        wasLoaded: boolean;
+    } | undefined, action: any) => any;
+    authentication: import("redux").Reducer<import("./authentication/types").AuthenticationState, import("./authentication/types").AuthenticationAction>;
+    header: import("redux").Reducer<import("./header/types").HeaderState, {
+        readonly type: "header/SET_HEADER_BREADCRUMBS";
+        readonly page: import("./header/types").Page;
+        readonly options: {} | import("./header/types").TabletsBreadcrumbsOptions | import("./header/types").TenantBreadcrumbsOptions | import("./header/types").ClusterBreadcrumbsOptions | import("./header/types").NodeBreadcrumbsOptions | import("./header/types").TabletBreadcrumbsOptions;
+    }>;
+    saveQuery: import("redux").Reducer<string | null, {
+        readonly type: "SET_QUERY_NAME_TO_EDIT";
+        readonly data: string;
+    } | {
+        readonly type: "CLEAR_QUERY_NAME_TO_EDIT";
+    }>;
+    fullscreen: (state: boolean | undefined, action: {
+        readonly type: "ENABLE_FULLSCREEN_MODE";
+    } | {
+        readonly type: "DISABLE_FULLSCREEN_MODE";
+    }) => boolean;
+    clusters: import("redux").Reducer<import("./clusters/types").ClustersState, import("./clusters/types").ClustersAction>;
+};
+declare const combinedReducer: import("redux").Reducer<import("redux").CombinedState<{
+    singleClusterMode: boolean;
+    nodes: import("./nodes/types").NodesState;
+    topNodesByLoad: import("./tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+    topNodesByCpu: import("./tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+    topNodesByMemory: import("./tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+    cluster: import("./cluster/types").ClusterState;
+    clusterNodes: import("./clusterNodes/types").ClusterNodesState;
+    tenant: import("./tenant/types").TenantState;
+    storage: import("./storage/types").StorageState;
+    topStorageGroups: import("./tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+    node: import("./node/types").NodeState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").ITabletsState;
+    schema: import("./schema/types").SchemaState;
+    overview: import("./overview/types").OverviewState;
+    olapStats: import("../../types/store/olapStats").OlapStatsState;
+    host: import("../../types/store/host").IHostState;
+    network: import("./network/types").NetworkState;
+    tenants: import("./tenants/types").TenantsState;
+    tablet: import("../../types/store/tablet").ITabletState;
+    topic: import("../../types/store/topic").ITopicState;
+    partitions: import("./partitions/types").PartitionsState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    explainQuery: import("../../types/store/explainQuery").ExplainQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    preview: any;
+    nodesList: import("../../types/store/nodesList").NodesListState;
+    describe: import("../../types/store/describe").IDescribeState;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").ITopQueriesState;
+    executeTopTables: import("./tenantOverview/executeTopTables/types").TopTablesState;
+    tenantOverviewTopQueries: import("./tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+    healthcheckInfo: import("../../types/store/healthcheck").IHealthcheckInfoState;
+    shardsWorkload: import("./shardsWorkload/types").IShardsWorkloadState;
+    tenantOverviewTopShards: import("./tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    hotKeys: any;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersState;
+}>, any>;
+export declare type RootReducer = typeof combinedReducer;
+export declare type RootState = ReturnType<RootReducer>;
+export declare type GetState = () => RootState;
+export default combinedReducer;