ydb-embedded-ui 4.33.0 → 5.1.0

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

@@ -0,0 +1,41 @@
+import { convertBytesObjectToSpeed } from '../../../utils/bytesParsers';
+import { parseLag, parseTimestampToIdleTime } from '../../../utils/timeParsers';
+import { isNumeric } from '../../../utils/utils';
+const prepareGeneralPartitionStats = (partitionStats) => {
+    const { partition_offsets, store_size_bytes = '0', last_write_time: partition_last_write_time, max_write_time_lag: partition_write_lag, bytes_written, partition_node_id = 0, } = partitionStats || {};
+    const { start: start_offset = '0', end: end_offset = '0' } = partition_offsets || {};
+    return {
+        storeSize: store_size_bytes,
+        writeSpeed: convertBytesObjectToSpeed(bytes_written),
+        partitionWriteLag: parseLag(partition_write_lag),
+        partitionWriteIdleTime: parseTimestampToIdleTime(partition_last_write_time),
+        startOffset: start_offset,
+        endOffset: end_offset,
+        partitionNodeId: partition_node_id,
+    };
+};
+export const prepareTopicPartitions = (partitions) => {
+    return partitions === null || partitions === void 0 ? void 0 : partitions.map((partition) => {
+        // describe_topic endpoint doesn't return zero values, so some values will be initialized with 0
+        const { partition_id = '0', partition_stats } = partition;
+        const preparedPartitionStats = prepareGeneralPartitionStats(partition_stats);
+        return Object.assign({ partitionId: partition_id }, preparedPartitionStats);
+    });
+};
+export const prepareConsumerPartitions = (partitions) => {
+    return partitions === null || partitions === void 0 ? void 0 : partitions.map((partition) => {
+        // describe_consumer endpoint doesn't return zero values, so some values will be initialized with 0
+        const { partition_id = '0', partition_stats, partition_consumer_stats } = partition;
+        const preparedPartitionStats = prepareGeneralPartitionStats(partition_stats);
+        const { endOffset } = preparedPartitionStats;
+        const { last_read_offset = '0', committed_offset = '0', read_session_id, last_read_time: consumer_last_read_time, max_read_time_lag: consumer_read_lag, max_write_time_lag: consumer_write_lag, bytes_read, reader_name, connection_node_id = 0, } = partition_consumer_stats || {};
+        const uncommitedMessages = isNumeric(endOffset) && isNumeric(committed_offset)
+            ? Number(endOffset) - Number(committed_offset)
+            : 0;
+        const unreadMessages = isNumeric(endOffset) && isNumeric(last_read_offset)
+            ? Number(endOffset) - Number(last_read_offset)
+            : 0;
+        return Object.assign(Object.assign({}, preparedPartitionStats), { partitionId: partition_id, readSpeed: convertBytesObjectToSpeed(bytes_read), consumerWriteLag: parseLag(consumer_write_lag), consumerReadLag: parseLag(consumer_read_lag), consumerReadIdleTime: parseTimestampToIdleTime(consumer_last_read_time), uncommitedMessages,
+            unreadMessages, commitedOffset: committed_offset, readSessionId: read_session_id, readerName: reader_name, connectionNodeId: connection_node_id });
+    });
+};

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

@@ -0,0 +1,23 @@
+import type { ExecuteActions } from '../../types/api/query';
+import type { IQueryResult, QueryErrorResponse } from '../../types/store/query';
+import { ApiRequestAction } from '../utils';
+declare const SEND_QUERY: {
+    readonly REQUEST: "preview/SEND_QUERY_REQUEST";
+    readonly SUCCESS: "preview/SEND_QUERY_SUCCESS";
+    readonly FAILURE: "preview/SEND_QUERY_FAILURE";
+};
+declare const preview: (state: {
+    loading: boolean;
+    wasLoaded: boolean;
+} | undefined, action: ApiRequestAction<typeof SEND_QUERY, IQueryResult, QueryErrorResponse> | ReturnType<typeof setQueryOptions>) => any;
+interface SendQueryParams {
+    query?: string;
+    database?: string;
+    action?: ExecuteActions;
+}
+export declare const sendQuery: ({ query, database, action }: SendQueryParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<IQueryResult | undefined>;
+export declare function setQueryOptions(options: any): {
+    readonly type: "preview/SET_QUERY_OPTIONS";
+    readonly data: any;
+};
+export default preview;

package/dist/store/reducers/preview.js

@@ -0,0 +1,40 @@
+import { parseQueryAPIExecuteResponse } from '../../utils/query';
+import { createRequestActionTypes, createApiRequest } from '../utils';
+const SEND_QUERY = createRequestActionTypes('preview', 'SEND_QUERY');
+const SET_QUERY_OPTIONS = 'preview/SET_QUERY_OPTIONS';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+const preview = (state = initialState, action) => {
+    switch (action.type) {
+        case SEND_QUERY.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, error: undefined });
+        }
+        case SEND_QUERY.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, error: undefined, wasLoaded: true });
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case SEND_QUERY.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error || 'Unauthorized', loading: false });
+        }
+        case SET_QUERY_OPTIONS:
+            return Object.assign(Object.assign({}, state), action.data);
+        default:
+            return state;
+    }
+};
+export const sendQuery = ({ query, database, action }) => {
+    return createApiRequest({
+        request: window.api.sendQuery({ schema: 'modern', query, database, action }),
+        actions: SEND_QUERY,
+        dataHandler: parseQueryAPIExecuteResponse,
+    });
+};
+export function setQueryOptions(options) {
+    return {
+        type: SET_QUERY_OPTIONS,
+        data: options,
+    };
+}
+export default preview;

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

@@ -0,0 +1,12 @@
+import { Reducer } from 'redux';
+declare type IAction = ReturnType<typeof setQueryNameToEdit> | ReturnType<typeof clearQueryNameToEdit>;
+declare type ISaveQueryState = string | null;
+declare const saveQuery: Reducer<ISaveQueryState, IAction>;
+export declare function setQueryNameToEdit(name: string): {
+    readonly type: "SET_QUERY_NAME_TO_EDIT";
+    readonly data: string;
+};
+export declare function clearQueryNameToEdit(): {
+    readonly type: "CLEAR_QUERY_NAME_TO_EDIT";
+};
+export default saveQuery;

package/dist/store/reducers/saveQuery.js

@@ -0,0 +1,25 @@
+const SET_QUERY_NAME_TO_EDIT = 'SET_QUERY_NAME_TO_EDIT';
+const CLEAR_QUERY_NAME_TO_EDIT = 'CLEAR_QUERY_NAME_TO_EDIT';
+const initialState = null;
+const saveQuery = function (state = initialState, action) {
+    switch (action.type) {
+        case SET_QUERY_NAME_TO_EDIT:
+            return action.data;
+        case CLEAR_QUERY_NAME_TO_EDIT:
+            return null;
+        default:
+            return state;
+    }
+};
+export function setQueryNameToEdit(name) {
+    return {
+        type: SET_QUERY_NAME_TO_EDIT,
+        data: name,
+    };
+}
+export function clearQueryNameToEdit() {
+    return {
+        type: CLEAR_QUERY_NAME_TO_EDIT,
+    };
+}
+export default saveQuery;

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

@@ -0,0 +1,48 @@
+import type { Reducer } from 'redux';
+import type { Selector } from 'reselect';
+import type { EPathType } from '../../../types/api/schema';
+import type { SchemaAction, SchemaData, SchemaHandledResponse, SchemaStateSlice, SchemaState } 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 initialState: {
+    loading: boolean;
+    wasLoaded: boolean;
+    data: {};
+    currentSchemaPath: undefined;
+    autorefresh: boolean;
+    showPreview: boolean;
+};
+declare const schema: Reducer<SchemaState, SchemaAction>;
+export declare function getSchema({ path }: {
+    path: string;
+}): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<SchemaHandledResponse | undefined>;
+export declare function setCurrentSchemaPath(currentSchemaPath: string): {
+    readonly type: "schema/SET_SCHEMA";
+    readonly data: string;
+};
+export declare function enableAutorefresh(): {
+    readonly type: "schema/ENABLE_AUTOREFRESH";
+};
+export declare function disableAutorefresh(): {
+    readonly type: "schema/DISABLE_AUTOREFRESH";
+};
+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 | undefined) => import("../../../types/api/schema").TEvDescribeSchemeResult | undefined;
+export declare const selectSchemaMergedChildrenPaths: Selector<SchemaStateSlice, string[] | undefined, [
+    string | undefined,
+    EPathType | undefined
+]>;
+export default schema;

package/dist/store/reducers/schema/schema.js

@@ -0,0 +1,125 @@
+import { createSelector } from 'reselect';
+import { isEntityWithMergedImplementation } from '../../../containers/Tenant/utils/schema';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+export const FETCH_SCHEMA = createRequestActionTypes('schema', 'FETCH_SCHEMA');
+const PRELOAD_SCHEMAS = 'schema/PRELOAD_SCHEMAS';
+const SET_SCHEMA = 'schema/SET_SCHEMA';
+const SET_SHOW_PREVIEW = 'schema/SET_SHOW_PREVIEW';
+const ENABLE_AUTOREFRESH = 'schema/ENABLE_AUTOREFRESH';
+const DISABLE_AUTOREFRESH = 'schema/DISABLE_AUTOREFRESH';
+const RESET_LOADING_STATE = 'schema/RESET_LOADING_STATE';
+export const initialState = {
+    loading: true,
+    wasLoaded: false,
+    data: {},
+    currentSchemaPath: undefined,
+    autorefresh: false,
+    showPreview: false,
+};
+const schema = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_SCHEMA.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_SCHEMA.SUCCESS: {
+            const isCurrentSchema = !state.currentSchemaPath || state.currentSchemaPath === action.data.path;
+            const newData = Object.assign(Object.assign({}, state.data), action.data.data);
+            if (!isCurrentSchema) {
+                return Object.assign(Object.assign({}, state), { data: newData });
+            }
+            return Object.assign(Object.assign({}, state), { error: undefined, data: newData, currentSchema: action.data.currentSchema, currentSchemaPath: action.data.path, loading: false, wasLoaded: true });
+        }
+        case FETCH_SCHEMA.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 PRELOAD_SCHEMAS: {
+            return Object.assign(Object.assign({}, state), { data: Object.assign(Object.assign({}, action.data), state.data) });
+        }
+        case SET_SCHEMA: {
+            return Object.assign(Object.assign({}, state), { currentSchemaPath: action.data });
+        }
+        case ENABLE_AUTOREFRESH: {
+            return Object.assign(Object.assign({}, state), { autorefresh: true });
+        }
+        case DISABLE_AUTOREFRESH: {
+            return Object.assign(Object.assign({}, state), { autorefresh: false });
+        }
+        case SET_SHOW_PREVIEW: {
+            return Object.assign(Object.assign({}, state), { showPreview: action.data });
+        }
+        case RESET_LOADING_STATE: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: initialState.wasLoaded });
+        }
+        default:
+            return state;
+    }
+};
+export function getSchema({ path }) {
+    const request = window.api.getSchema({ path });
+    return createApiRequest({
+        request,
+        actions: FETCH_SCHEMA,
+        dataHandler: (data) => {
+            const newData = {};
+            if (data.Path) {
+                newData[data.Path] = data;
+            }
+            return {
+                path: data.Path,
+                currentSchema: data,
+                data: newData,
+            };
+        },
+    });
+}
+export function setCurrentSchemaPath(currentSchemaPath) {
+    return {
+        type: SET_SCHEMA,
+        data: currentSchemaPath,
+    };
+}
+export function enableAutorefresh() {
+    return {
+        type: ENABLE_AUTOREFRESH,
+    };
+}
+export function disableAutorefresh() {
+    return {
+        type: DISABLE_AUTOREFRESH,
+    };
+}
+export function setShowPreview(value) {
+    return {
+        type: SET_SHOW_PREVIEW,
+        data: value,
+    };
+}
+// only stores data for paths that are not in the store yet
+// existing paths are ignored
+export function preloadSchemas(data) {
+    return {
+        type: PRELOAD_SCHEMAS,
+        data,
+    };
+}
+export function resetLoadingState() {
+    return {
+        type: RESET_LOADING_STATE,
+    };
+}
+const selectSchemaChildren = (state, path) => { var _a, _b; return path ? (_b = (_a = state.schema.data[path]) === null || _a === void 0 ? void 0 : _a.PathDescription) === null || _b === void 0 ? void 0 : _b.Children : undefined; };
+export const selectSchemaData = (state, path) => path ? state.schema.data[path] : undefined;
+export const selectSchemaMergedChildrenPaths = createSelector([
+    (_, path) => path,
+    (_, _path, type) => type,
+    selectSchemaChildren,
+], (path, type, children) => {
+    return isEntityWithMergedImplementation(type)
+        ? children === null || children === void 0 ? void 0 : children.map(({ Name }) => path + '/' + Name)
+        : undefined;
+});
+export default schema;

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

@@ -0,0 +1,26 @@
+import type { ApiRequestAction } from '../../utils';
+import type { IResponseError } from '../../../types/api/error';
+import type { TEvDescribeSchemeResult } from '../../../types/api/schema';
+import { disableAutorefresh, enableAutorefresh, FETCH_SCHEMA, preloadSchemas, resetLoadingState, setCurrentSchemaPath, setShowPreview } from './schema';
+export declare type SchemaData = Record<string, TEvDescribeSchemeResult>;
+export interface SchemaState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data: SchemaData;
+    currentSchema?: TEvDescribeSchemeResult;
+    currentSchemaPath?: string;
+    autorefresh: boolean;
+    showPreview: boolean;
+    error?: IResponseError;
+}
+export interface SchemaHandledResponse {
+    path?: string;
+    currentSchema?: TEvDescribeSchemeResult;
+    data?: SchemaData;
+}
+declare type SchemaApiRequestAction = ApiRequestAction<typeof FETCH_SCHEMA, SchemaHandledResponse, IResponseError>;
+export declare type SchemaAction = SchemaApiRequestAction | (ReturnType<typeof setCurrentSchemaPath> | ReturnType<typeof enableAutorefresh> | ReturnType<typeof disableAutorefresh> | ReturnType<typeof setShowPreview> | ReturnType<typeof preloadSchemas> | ReturnType<typeof resetLoadingState>);
+export interface SchemaStateSlice {
+    schema: SchemaState;
+}
+export {};

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

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

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

@@ -0,0 +1,15 @@
+import type { Reducer } from 'redux';
+import type { SchemaAclAction, SchemaAclState } from './types';
+export declare const FETCH_SCHEMA_ACL: {
+    readonly REQUEST: "schemaAcl/FETCH_SCHEMA_ACL_REQUEST";
+    readonly SUCCESS: "schemaAcl/FETCH_SCHEMA_ACL_SUCCESS";
+    readonly FAILURE: "schemaAcl/FETCH_SCHEMA_ACL_FAILURE";
+};
+declare const schemaAcl: Reducer<SchemaAclState, SchemaAclAction>;
+export declare function getSchemaAcl({ path }: {
+    path: string;
+}): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export declare const setAclWasNotLoaded: () => {
+    readonly type: "schemaAcl/SET_DATA_WAS_NOT_LOADED";
+};
+export default schemaAcl;

package/dist/store/reducers/schemaAcl/schemaAcl.js

@@ -0,0 +1,44 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+export const FETCH_SCHEMA_ACL = createRequestActionTypes('schemaAcl', 'FETCH_SCHEMA_ACL');
+const SET_ACL_WAS_NOT_LOADED = 'schemaAcl/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+const schemaAcl = (state = initialState, action) => {
+    var _a, _b, _c;
+    switch (action.type) {
+        case FETCH_SCHEMA_ACL.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_SCHEMA_ACL.SUCCESS: {
+            const acl = (_a = action.data.Common) === null || _a === void 0 ? void 0 : _a.ACL;
+            const owner = (_b = action.data.Common) === null || _b === void 0 ? void 0 : _b.Owner;
+            return Object.assign(Object.assign({}, state), { acl,
+                owner, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_SCHEMA_ACL.FAILURE: {
+            if ((_c = action.error) === null || _c === void 0 ? void 0 : _c.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_ACL_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export function getSchemaAcl({ path }) {
+    return createApiRequest({
+        request: window.api.getSchemaAcl({ path }),
+        actions: FETCH_SCHEMA_ACL,
+    });
+}
+export const setAclWasNotLoaded = () => {
+    return {
+        type: SET_ACL_WAS_NOT_LOADED,
+    };
+};
+export default schemaAcl;

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

@@ -0,0 +1,12 @@
+import type { TACE, TMetaInfo } from '../../../types/api/acl';
+import type { IResponseError } from '../../../types/api/error';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_SCHEMA_ACL, setAclWasNotLoaded } from './schemaAcl';
+export interface SchemaAclState {
+    loading: boolean;
+    wasLoaded: boolean;
+    acl?: TACE[];
+    owner?: string;
+    error?: IResponseError;
+}
+export declare type SchemaAclAction = ApiRequestAction<typeof FETCH_SCHEMA_ACL, TMetaInfo, IResponseError> | ReturnType<typeof setAclWasNotLoaded>;

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

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

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

@@ -0,0 +1,29 @@
+import type { Reducer } from 'redux';
+import type { ThunkAction } from 'redux-thunk';
+import { SettingsObject } from '../../../services/settings';
+import type { RootState } from '..';
+import type { ProblemFilterValue, SetSettingValueAction, SettingsAction, SettingsRootStateSlice, SettingsState } from './types';
+export declare const SET_SETTING_VALUE = "settings/SET_VALUE";
+export declare const SET_USER_SETTINGS = "settings/SET_USER_SETTINGS";
+export declare const ProblemFilterValues: {
+    readonly ALL: "All";
+    readonly PROBLEMS: "With problems";
+};
+export declare const initialState: {
+    problemFilter: "All";
+    userSettings: SettingsObject;
+    systemSettings: SettingsObject;
+};
+declare const settings: Reducer<SettingsState, SettingsAction>;
+export declare const setSettingValue: (name: string, value: unknown) => ThunkAction<void, RootState, unknown, SetSettingValueAction>;
+export declare const setUserSettings: (data: SettingsObject) => {
+    readonly type: "settings/SET_USER_SETTINGS";
+    readonly data: SettingsObject;
+};
+export declare const getSettingValue: (state: SettingsRootStateSlice, name: string) => unknown;
+export declare const changeFilter: (filter: ProblemFilterValue) => {
+    readonly type: "settings/CHANGE_PROBLEM_FILTER";
+    readonly data: ProblemFilterValue;
+};
+export declare const selectProblemFilter: (state: SettingsRootStateSlice) => ProblemFilterValue;
+export default settings;

package/dist/store/reducers/settings/settings.js

@@ -0,0 +1,50 @@
+import { DEFAULT_USER_SETTINGS, settingsManager } from '../../../services/settings';
+const CHANGE_PROBLEM_FILTER = 'settings/CHANGE_PROBLEM_FILTER';
+export const SET_SETTING_VALUE = 'settings/SET_VALUE';
+export const SET_USER_SETTINGS = 'settings/SET_USER_SETTINGS';
+export const ProblemFilterValues = {
+    ALL: 'All',
+    PROBLEMS: 'With problems',
+};
+const userSettings = settingsManager.extractSettingsFromLS(DEFAULT_USER_SETTINGS);
+const systemSettings = window.systemSettings || {};
+export const initialState = {
+    problemFilter: ProblemFilterValues.ALL,
+    userSettings,
+    systemSettings,
+};
+const settings = (state = initialState, action) => {
+    switch (action.type) {
+        case CHANGE_PROBLEM_FILTER:
+            return Object.assign(Object.assign({}, state), { problemFilter: action.data });
+        case SET_SETTING_VALUE: {
+            const newSettings = Object.assign(Object.assign({}, state.userSettings), { [action.data.name]: action.data.value });
+            return Object.assign(Object.assign({}, state), { userSettings: newSettings });
+        }
+        case SET_USER_SETTINGS: {
+            return Object.assign(Object.assign({}, state), { userSettings: Object.assign(Object.assign({}, state.userSettings), action.data) });
+        }
+        default:
+            return state;
+    }
+};
+export const setSettingValue = (name, value) => {
+    return (dispatch) => {
+        dispatch({ type: SET_SETTING_VALUE, data: { name, value } });
+        settingsManager.setUserSettingsValue(name, value);
+    };
+};
+export const setUserSettings = (data) => {
+    return { type: SET_USER_SETTINGS, data };
+};
+export const getSettingValue = (state, name) => {
+    return state.settings.userSettings[name];
+};
+export const changeFilter = (filter) => {
+    return {
+        type: CHANGE_PROBLEM_FILTER,
+        data: filter,
+    };
+};
+export const selectProblemFilter = (state) => state.settings.problemFilter;
+export default settings;

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

@@ -0,0 +1,20 @@
+import type { ValueOf } from '../../../types/common';
+import type { SettingsObject } from '../../../services/settings';
+import { changeFilter, setUserSettings, ProblemFilterValues, SET_SETTING_VALUE } from './settings';
+export declare type ProblemFilterValue = ValueOf<typeof ProblemFilterValues>;
+export interface SettingsState {
+    problemFilter: ProblemFilterValue;
+    userSettings: SettingsObject;
+    systemSettings: SettingsObject;
+}
+export declare type SetSettingValueAction = {
+    type: typeof SET_SETTING_VALUE;
+    data: {
+        name: string;
+        value: unknown;
+    };
+};
+export declare type SettingsAction = ReturnType<typeof changeFilter> | ReturnType<typeof setUserSettings> | SetSettingValueAction;
+export interface SettingsRootStateSlice {
+    settings: SettingsState;
+}

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

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

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

@@ -0,0 +1,31 @@
+import type { Reducer } from 'redux';
+import type { IShardsWorkloadAction, IShardsWorkloadFilters, IShardsWorkloadState } from './types';
+export declare const SEND_SHARD_QUERY: {
+    readonly REQUEST: "query/SEND_SHARD_QUERY_REQUEST";
+    readonly SUCCESS: "query/SEND_SHARD_QUERY_SUCCESS";
+    readonly FAILURE: "query/SEND_SHARD_QUERY_FAILURE";
+};
+export interface SortOrder {
+    columnId: string;
+    order: string;
+}
+declare const shardsWorkload: Reducer<IShardsWorkloadState, IShardsWorkloadAction>;
+interface SendShardQueryParams {
+    database?: string;
+    path?: string;
+    sortOrder?: SortOrder[];
+    filters?: IShardsWorkloadFilters;
+}
+export declare const sendShardQuery: ({ database, path, sortOrder, filters }: SendShardQueryParams) => ((dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("../../../types/store/query").IQueryResult | undefined>) | {
+    type: "query/SEND_SHARD_QUERY_FAILURE";
+    error: unknown;
+};
+export declare function setShardsState(options: Partial<IShardsWorkloadState>): {
+    readonly type: "query/SET_SHARD_STATE";
+    readonly data: Partial<IShardsWorkloadState>;
+};
+export declare function setShardsQueryFilters(filters: Partial<IShardsWorkloadFilters>): {
+    readonly type: "shardsWorkload/SET_SHARD_QUERY_FILTERS";
+    readonly filters: Partial<IShardsWorkloadFilters>;
+};
+export default shardsWorkload;