ydb-embedded-ui 6.6.0 → 6.7.0

package/dist/src/store/reducers/healthcheckInfo/healthcheckInfo.js

@@ -3,9 +3,9 @@ import { api } from '../api';
 export const healthcheckApi = api.injectEndpoints({
     endpoints: (builder) => ({
         getHealthcheckInfo: builder.query({
-            queryFn: async (database, { signal }) => {
+            queryFn: async ({ database, maxLevel }, { signal }) => {
                 try {
-                    const data = await window.api.getHealthcheckInfo(database, { signal });
+                    const data = await window.api.getHealthcheckInfo({ database, maxLevel }, { signal });
                     return { data };
                 }
                 catch (error) {
@@ -64,7 +64,7 @@ const getIssuesStatistics = (data) => {
         return aPriority - bPriority;
     });
 };
-const createGetHealthcheckInfoSelector = createSelector((database) => database, (database) => healthcheckApi.endpoints.getHealthcheckInfo.select(database));
+const createGetHealthcheckInfoSelector = createSelector((database) => database, (database) => healthcheckApi.endpoints.getHealthcheckInfo.select({ database }));
 const getIssuesLog = createSelector((state) => state, (_state, database) => createGetHealthcheckInfoSelector(database), (state, selectGetPost) => { var _a; return ((_a = selectGetPost(state).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 = []) => {

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

@@ -1,25 +1,6 @@
-import type { Reducer } from '@reduxjs/toolkit';
-import type { IResponseError } from '../../../types/api/error';
-import type { JsonHotKeysResponse } from '../../../types/api/hotkeys';
-import type { HotKeysAction, HotKeysState } from './types';
-export declare const FETCH_HOT_KEYS: {
-    readonly REQUEST: "hot_keys/FETCH_HOT_KEYS_REQUEST";
-    readonly SUCCESS: "hot_keys/FETCH_HOT_KEYS_SUCCESS";
-    readonly FAILURE: "hot_keys/FETCH_HOT_KEYS_FAILURE";
-};
-declare const hotKeys: Reducer<HotKeysState, HotKeysAction>;
-export declare function setHotKeysDataWasNotLoaded(): {
-    readonly type: "hot_keys/SET_DATA_WAS_NOT_LOADED";
-};
-export declare function setHotKeysLoading(): {
-    readonly type: "hot_keys/FETCH_HOT_KEYS_REQUEST";
-};
-export declare function setHotKeysData(data: JsonHotKeysResponse): {
-    readonly type: "hot_keys/FETCH_HOT_KEYS_SUCCESS";
-    readonly data: JsonHotKeysResponse;
-};
-export declare function setHotKeysError(error: IResponseError): {
-    readonly type: "hot_keys/FETCH_HOT_KEYS_FAILURE";
-    readonly error: IResponseError<unknown>;
-};
-export default hotKeys;
+import type { HotKey } from '../../../types/api/hotkeys';
+export declare const hotKeysApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getHotKeys: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", HotKey[] | null, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/src/store/reducers/hotKeys/hotKeys.js

@@ -1,49 +1,36 @@
-import { createRequestActionTypes } from '../../utils';
-export const FETCH_HOT_KEYS = createRequestActionTypes('hot_keys', 'FETCH_HOT_KEYS');
-const SET_DATA_WAS_NOT_LOADED = 'hot_keys/SET_DATA_WAS_NOT_LOADED';
-const initialState = { loading: true, wasLoaded: false, data: null };
-const hotKeys = (state = initialState, action) => {
-    var _a;
-    switch (action.type) {
-        case FETCH_HOT_KEYS.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_HOT_KEYS.SUCCESS: {
-            return Object.assign(Object.assign({}, state), { data: action.data.hotkeys, loading: false, error: undefined, wasLoaded: true });
-        }
-        case FETCH_HOT_KEYS.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 });
-        }
-        case SET_DATA_WAS_NOT_LOADED: {
-            return Object.assign(Object.assign({}, state), { wasLoaded: false });
-        }
-        default:
-            return state;
-    }
-};
-export function setHotKeysDataWasNotLoaded() {
-    return {
-        type: SET_DATA_WAS_NOT_LOADED,
-    };
-}
-export function setHotKeysLoading() {
-    return {
-        type: FETCH_HOT_KEYS.REQUEST,
-    };
-}
-export function setHotKeysData(data) {
-    return {
-        type: FETCH_HOT_KEYS.SUCCESS,
-        data: data,
-    };
-}
-export function setHotKeysError(error) {
-    return {
-        type: FETCH_HOT_KEYS.FAILURE,
-        error: error,
-    };
-}
-export default hotKeys;
+import { api } from '../api';
+export const hotKeysApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getHotKeys: builder.query({
+            queryFn: async ({ path }, { signal }) => {
+                var _a;
+                try {
+                    // Send request that will trigger hot keys sampling (enable_sampling = true)
+                    const initialResponse = await window.api.getHotKeys(path, true, { signal });
+                    // If there are hotkeys in the initial request (hotkeys was collected before)
+                    // we could just use colleted samples (collected hotkeys are stored only for 30 seconds)
+                    if (Array.isArray(initialResponse.hotkeys)) {
+                        return { data: initialResponse.hotkeys };
+                    }
+                    // Else wait for 5 seconds, while hot keys are being collected
+                    await Promise.race([
+                        new Promise((resolve) => {
+                            setTimeout(resolve, 5000);
+                        }),
+                        new Promise((_, reject) => {
+                            signal.addEventListener('abort', reject);
+                        }),
+                    ]);
+                    // And request these samples (enable_sampling = false)
+                    const response = await window.api.getHotKeys(path, false, { signal });
+                    return { data: (_a = response.hotkeys) !== null && _a !== void 0 ? _a : null };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -6,60 +6,17 @@ export declare const rootReducer: {
     tenant: import("redux").Reducer<import("./tenant/types").TenantState>;
     tooltip: import("redux").Reducer<import("../../types/store/tooltip").ITooltipState, import("../../types/store/tooltip").ITooltipAction>;
     tablets: import("redux").Reducer<import("../../types/store/tablets").TabletsState>;
-    schema: import("redux").Reducer<import("./schema/types").SchemaState, import("./schema/types").SchemaAction>;
-    host: import("redux").Reducer<import("../../types/store/host").IHostState, import("../../types/store/host").IHostAction>;
+    schema: import("redux").Reducer<import("./schema/types").SchemaState, {
+        readonly type: "schema/SET_SHOW_PREVIEW";
+        readonly data: boolean;
+    }>;
     tenants: import("redux").Reducer<import("./tenants/types").TenantsState>;
     partitions: import("redux").Reducer<import("./partitions/types").PartitionsState>;
     executeQuery: import("redux").Reducer<import("../../types/store/executeQuery").ExecuteQueryState, import("../../types/store/executeQuery").ExecuteQueryAction>;
-    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>;
-    settings: import("redux").Reducer<import("./settings/types").SettingsState, import("./settings/types").SettingsAction>;
-    schemaAcl: import("redux").Reducer<import("./schemaAcl/types").SchemaAclState, import("./schemaAcl/types").SchemaAclAction>;
+    settings: import("redux").Reducer<import("./settings/types").SettingsState>;
     executeTopQueries: import("redux").Reducer<import("./executeTopQueries/types").TopQueriesFilters>;
     shardsWorkload: import("redux").Reducer<import("./shardsWorkload/types").ShardsWorkloadFilters>;
-    hotKeys: import("redux").Reducer<import("./hotKeys/types").HotKeysState, import("./hotKeys/types").HotKeysAction>;
     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";
@@ -87,59 +44,35 @@ declare const combinedReducer: import("redux").Reducer<{
     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;
-    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;
-}, any, Partial<{
+}, import("redux").UnknownAction | import("../../types/store/tooltip").ITooltipAction | {
+    readonly type: "schema/SET_SHOW_PREVIEW";
+    readonly data: boolean;
+} | import("../../types/store/executeQuery").ExecuteQueryAction | import("./authentication/types").AuthenticationAction | {
+    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").TabletBreadcrumbsOptions | import("./header/types").NodeBreadcrumbsOptions;
+} | ({
+    readonly type: "SET_QUERY_NAME_TO_EDIT";
+    readonly data: string;
+} | {
+    readonly type: "CLEAR_QUERY_NAME_TO_EDIT";
+}) | {
+    readonly type: "ENABLE_FULLSCREEN_MODE";
+} | {
+    readonly type: "DISABLE_FULLSCREEN_MODE";
+} | import("redux").Action<string>, Partial<{
     api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api"> | undefined;
     singleClusterMode: boolean | undefined;
     cluster: import("./cluster/types").ClusterState | undefined;
@@ -147,23 +80,13 @@ declare const combinedReducer: import("redux").Reducer<{
     tooltip: never;
     tablets: import("../../types/store/tablets").TabletsState | undefined;
     schema: never;
-    host: never;
     tenants: import("./tenants/types").TenantsState | undefined;
     partitions: import("./partitions/types").PartitionsState | undefined;
     executeQuery: never;
-    tabletsFilters: {
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | undefined;
     heatmap: import("../../types/store/heatmap").IHeatmapState | undefined;
-    settings: never;
-    schemaAcl: never;
+    settings: import("./settings/types").SettingsState | undefined;
     executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters | undefined;
     shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters | undefined;
-    hotKeys: never;
     authentication: never;
     header: never;
     saveQuery: never;

package/dist/src/store/reducers/index.js

@@ -8,17 +8,13 @@ import executeTopQueries from './executeTopQueries/executeTopQueries';
 import fullscreen from './fullscreen';
 import header from './header/header';
 import heatmap from './heatmap';
-import host from './host';
-import hotKeys from './hotKeys/hotKeys';
 import partitions from './partitions/partitions';
 import saveQuery from './saveQuery';
 import schema from './schema/schema';
-import schemaAcl from './schemaAcl/schemaAcl';
 import settings from './settings/settings';
 import shardsWorkload from './shardsWorkload/shardsWorkload';
 import singleClusterMode from './singleClusterMode';
 import tablets from './tablets';
-import tabletsFilters from './tabletsFilters';
 import tenant from './tenant/tenant';
 import tenants from './tenants/tenants';
 import tooltip from './tooltip';
@@ -30,17 +26,13 @@ export const rootReducer = {
     tooltip,
     tablets,
     schema,
-    host,
     tenants,
     partitions,
     executeQuery,
-    tabletsFilters,
     heatmap,
     settings,
-    schemaAcl,
     executeTopQueries,
     shardsWorkload,
-    hotKeys,
     authentication,
     header,
     saveQuery,

package/dist/src/store/reducers/node/selectors.d.ts

@@ -8,53 +8,13 @@ export declare const selectNodeStructure: ((state: {
     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;
-    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;

package/dist/src/store/reducers/nodesList.d.ts

@@ -10,53 +10,13 @@ export declare const selectNodesMap: ((state: {
     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;
-    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;

package/dist/src/store/reducers/schema/schema.d.ts

@@ -1,163 +1,27 @@
-import type { Dispatch, Reducer, Selector } from '@reduxjs/toolkit';
-import type { EPathType } from '../../../types/api/schema';
-import type { SchemaAction, SchemaData, SchemaHandledResponse, SchemaState, SchemaStateSlice } from './types';
-export declare const FETCH_SCHEMA: {
-    readonly REQUEST: "schema/FETCH_SCHEMA_REQUEST";
-    readonly SUCCESS: "schema/FETCH_SCHEMA_SUCCESS";
-    readonly FAILURE: "schema/FETCH_SCHEMA_FAILURE";
-};
-export declare const SET_AUTOREFRESH_INTERVAL = "schema/SET_AUTOREFRESH_INTERVAL";
+import type { Reducer, Selector } from '@reduxjs/toolkit';
+import type { EPathType, TEvDescribeSchemeResult } from '../../../types/api/schema';
+import type { RootState } from '../../defaultStore';
+import type { SchemaAction, SchemaState } from './types';
 export declare const initialState: {
     loading: boolean;
-    wasLoaded: boolean;
     data: {};
     currentSchemaPath: undefined;
-    autorefresh: number;
     showPreview: boolean;
 };
 declare const schema: Reducer<SchemaState, SchemaAction>;
-export declare function getSchema({ path }: {
-    path: string;
-}): (dispatch: import("redux-thunk").ThunkDispatch<{
-    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
-    singleClusterMode: boolean;
-    cluster: import("../cluster/types").ClusterState;
-    tenant: import("../tenant/types").TenantState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").TabletsState;
-    schema: SchemaState;
-    host: import("../../../types/store/host").IHostState;
-    tenants: import("../tenants/types").TenantsState;
-    partitions: import("../partitions/types").PartitionsState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    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;
-}, undefined, import("redux").UnknownAction> & Dispatch<any>, getState: () => {
-    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
-    singleClusterMode: boolean;
-    cluster: import("../cluster/types").ClusterState;
-    tenant: import("../tenant/types").TenantState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").TabletsState;
-    schema: SchemaState;
-    host: import("../../../types/store/host").IHostState;
-    tenants: import("../tenants/types").TenantsState;
-    partitions: import("../partitions/types").PartitionsState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    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;
-}) => Promise<SchemaHandledResponse | undefined>;
-export declare function setCurrentSchemaPath(currentSchemaPath: string): {
-    readonly type: "schema/SET_SCHEMA";
-    readonly data: string;
-};
-export declare function setAutorefreshInterval(interval: number): (dispatch: Dispatch) => void;
 export declare function setShowPreview(value: boolean): {
     readonly type: "schema/SET_SHOW_PREVIEW";
     readonly data: boolean;
 };
-export declare function preloadSchemas(data: SchemaData): {
-    readonly type: "schema/PRELOAD_SCHEMAS";
-    readonly data: SchemaData;
-};
-export declare function resetLoadingState(): {
-    readonly type: "schema/RESET_LOADING_STATE";
-};
-export declare const selectSchemaData: (state: SchemaStateSlice, path?: string) => import("../../../types/api/schema").TEvDescribeSchemeResult | undefined;
-export declare const selectSchemaMergedChildrenPaths: Selector<SchemaStateSlice, string[] | undefined, [
+export default schema;
+export declare const schemaApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getSchema: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", TEvDescribeSchemeResult & {
+        partial?: boolean | undefined;
+    }, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export declare const selectSchemaMergedChildrenPaths: Selector<RootState, string[] | undefined, [
     string | undefined,
     EPathType | undefined
 ]>;
-export default schema;