@opengeoweb/workspace 19.0.0 → 19.1.1

package/dist/src/lib/store/viewPresets/types.d.ts

@@ -0,0 +1,184 @@
+import type { EntityState } from '@reduxjs/toolkit';
+import type { InitialProps, SupportedComponentTypes } from '@opengeoweb/core';
+import type { PluginComponentType, PluginMeta } from '@opengeoweb/plugins';
+import type { SystemScope } from '@opengeoweb/shared';
+import type { SoundingsComponentType } from '@opengeoweb/soundings';
+import type { SupportedComponentTypes as SupportedTimeSeriesComponentTypes } from '@opengeoweb/time-series';
+import type { WarningListComponentType } from '@opengeoweb/warnings';
+import type { ViewPresetListItem, WorkspaceLabelsConfigResponse, WorkspacePresetLabels, WorkspaceViewPresetComponentsLookupType } from '../workspace/types';
+import type { PresetFilterType } from '../workspaceList/types';
+export declare const AVIATION_COMPONENT_TYPES: readonly ["AirmetModule", "SigmetModule"];
+export type AviationComponentType = (typeof AVIATION_COMPONENT_TYPES)[number];
+export declare const CAP_COMPONENT_TYPES: readonly ["CapWarningList", "CapWarningMap"];
+export type CapComponentType = (typeof CAP_COMPONENT_TYPES)[number];
+export declare const SUPPORTED_COMPONENT_TYPES: readonly ["Map", "MultiMap", "ModelRunInterval", "HarmonieTempAndPrecipPreset", "TimeSlider"];
+export type SupportedMapComponentTypes = 'Map' | 'MultiMap' | 'ModelRunInterval' | 'HarmonieTempAndPrecipPreset' | 'TimeSlider';
+export declare const SUPPORTED_TIMESERIES_COMPONENT_TYPES: readonly ["TimeSeries"];
+export type SupportedTSComponentTypes = (typeof SUPPORTED_TIMESERIES_COMPONENT_TYPES)[number];
+export declare const WARNING_LIST_COMPONENT_TYPES: readonly ["WarningList", "MaritimeWarnings", "WarningsTimeline"];
+export type WarningsComponentType = (typeof WARNING_LIST_COMPONENT_TYPES)[number];
+export type WorkspaceSupportedComponentTypes = SupportedComponentTypes | SupportedTimeSeriesComponentTypes | SoundingsComponentType | WarningListComponentType | WorkspaceViewPresetComponentsLookupType | PluginComponentType;
+export type LabelSupportedComponentTypes = SupportedComponentTypes | SupportedTimeSeriesComponentTypes | SoundingsComponentType | WarningListComponentType | AviationComponentType | CapComponentType | 'TafModule' | 'TrajksModule' | 'SpaceweatherModule' | 'Plugin' | WorkspaceViewPresetComponentsLookupType;
+export declare const ALL_COMPONENT_TYPES: readonly LabelSupportedComponentTypes[];
+export interface ViewPreset {
+    id?: string;
+    title: string;
+    description?: string;
+    abstract?: string;
+    keywords: string;
+    componentType: WorkspaceSupportedComponentTypes;
+    initialProps?: InitialProps;
+    scope?: SystemScope;
+    is_shared?: boolean;
+    username?: string;
+    labels?: WorkspacePresetLabels;
+}
+export declare enum ViewPresetErrorComponent {
+    PRESET_DETAIL = "PRESET_DETAIL",
+    PRESET_LIST = "PRESET_LIST"
+}
+export declare enum ViewPresetErrorType {
+    AUTH = "AUTH",// Errors related to authentication and authorization
+    GENERIC = "GENERIC"
+}
+export type ViewPresetError = {
+    component: ViewPresetErrorComponent;
+    errorType: ViewPresetErrorType;
+    message: string;
+} | undefined;
+export interface ViewPresetsListFilter {
+    label: string;
+    id: PresetFilterType | 'all';
+    isSelected?: boolean;
+    isDisabled?: boolean;
+}
+export interface ViewPresetEntity {
+    panelId: string;
+    activeViewPresetId: string;
+    hasChanges: boolean;
+    isFetching: boolean;
+    error: ViewPresetError;
+    isViewPresetListDialogOpen: boolean;
+    filters: ViewPresetsListFilter[];
+    searchQuery: string;
+    filterResults: EntityState<ViewPresetListItem, string>;
+    labelFilters?: WorkspacePresetLabels;
+    username?: string;
+}
+export interface ViewPresetFormValues {
+    title?: string;
+    description?: string;
+    abstract?: string;
+    initialProps?: InitialProps;
+    labels?: WorkspaceLabelsConfigResponse;
+    componentType?: WorkspaceSupportedComponentTypes;
+    updated?: string;
+    updatedBy?: string;
+    username?: string;
+}
+export interface ViewPresetDialog {
+    title: string;
+    action: PresetAction;
+    viewPresetId: string;
+    panelId: string;
+    formValues: ViewPresetFormValues;
+    shouldSetActiveViewPreset?: boolean;
+}
+export interface ViewPresetState extends EntityState<ViewPresetEntity, string> {
+    viewPresetDialog?: ViewPresetDialog;
+}
+export declare enum PresetAction {
+    OPEN = "Open",
+    DELETE = "Delete",
+    SAVE = "Save",
+    SAVE_AS = "Save as",
+    SHARE = "Share",
+    EDIT = "Edit",
+    RESET = "Reset"
+}
+interface ViewPresetAction {
+    panelId: string;
+}
+export type FetchViewPresetsPayload = ViewPresetAction;
+export interface FetchedViewPresetsPayload extends ViewPresetAction {
+    viewPresets: ViewPresetListItem[];
+}
+export interface FetchViewPresetPayload extends ViewPresetAction {
+    viewPresetId: string;
+}
+export interface FetchedViewPresetPayload extends ViewPresetAction {
+    viewPresetId: string;
+    viewPreset: ViewPreset;
+}
+export interface SaveViewPresetPayload extends ViewPresetAction {
+    viewPresetId: string;
+    viewPreset: ViewPreset;
+}
+export interface SavedViewPresetPayload extends ViewPresetAction {
+    viewPresetId: string;
+}
+export interface ErrorViewPresetPayload extends ViewPresetAction {
+    viewPresetId?: string;
+    error: ViewPresetError;
+}
+export interface SetViewPresetHasChangePayload extends ViewPresetAction {
+    hasChanges: boolean;
+}
+export interface SetActiveViewPresetIdPayload extends ViewPresetAction {
+    viewPresetId: string;
+}
+export interface SetViewPresetInlineOverridePayload extends ViewPresetAction {
+    isInline: boolean;
+}
+export interface OnSuccesViewPresetActionPayload extends ViewPresetAction {
+    viewPresetId: string;
+    activeViewPresetId?: string;
+    shouldSetActiveViewPreset?: boolean;
+    action: PresetAction;
+    title: string;
+    description?: string;
+    componentType?: string;
+    scope?: SystemScope;
+    abstract?: string;
+    is_shared?: boolean;
+    labels?: WorkspacePresetLabels;
+    username?: string;
+}
+export interface SelectViewPresetPayload extends ViewPresetAction {
+    viewPresetId: string;
+    shouldReset?: boolean;
+}
+export interface SelectPluginPayload extends ViewPresetAction {
+    pluginMetaData?: PluginMeta;
+}
+export interface RegisterViewPresetPayload extends ViewPresetAction {
+    viewPresetId: string;
+    filters?: ViewPresetsListFilter[];
+}
+export interface ToggleViewPresetListDialogPayload extends ViewPresetAction {
+    isViewPresetListDialogOpen: boolean;
+}
+export interface ToggleSelectFilterChip extends ViewPresetAction {
+    id: PresetFilterType;
+    isSelected: boolean;
+    isAdmin?: boolean;
+}
+export interface SetFilterChipsPayload extends ViewPresetAction {
+    filters: {
+        id: PresetFilterType;
+        isSelected: boolean;
+    }[];
+}
+export type SetSelectAllFilterChip = ViewPresetAction;
+export interface SearchWorkspaceFilter extends ViewPresetAction {
+    searchQuery: string;
+}
+export type UnregisterViewPresetPayload = ViewPresetAction;
+export interface OpenViewPresetDialogPayload {
+    viewPresetDialog: ViewPresetDialog;
+}
+export interface SetViewPresetLabelFiltersPayload extends ViewPresetAction {
+    labels: WorkspacePresetLabels;
+}
+export type ClearViewPresetLabelFiltersPayload = ViewPresetAction;
+export {};

package/dist/src/lib/store/viewPresets/utils.d.ts

@@ -0,0 +1,5 @@
+import { snackbarTypes } from '@opengeoweb/snackbar';
+import type { ViewPreset, WorkspaceSupportedComponentTypes } from './types';
+import { PresetAction } from './types';
+export declare const getSnackbarMessage: (action: PresetAction, title: string, is_shared?: boolean) => snackbarTypes.TranslatableMessage;
+export declare const emptyViewPreset: (componentType?: WorkspaceSupportedComponentTypes | undefined) => ViewPreset;

package/dist/src/lib/store/workspace/index.d.ts

@@ -0,0 +1 @@
+export { workspaceActions, workspaceReducer } from './reducer';

package/dist/src/lib/store/workspace/listener.d.ts

@@ -0,0 +1,5 @@
+import type { UnknownAction, ThunkDispatch } from '@reduxjs/toolkit';
+import type { Credentials } from '@opengeoweb/api';
+import type { AppStore, WorkspaceModuleStore } from '../types';
+export declare const workspaceListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<AppStore, ThunkDispatch<AppStore, unknown, UnknownAction>, unknown>;
+export declare const fetchWorkspaceViewPreset: (dispatch: ThunkDispatch<WorkspaceModuleStore, unknown, UnknownAction>, viewPresetId: string, mosaicNodeId: string, credentials?: Credentials) => Promise<void>;

package/dist/src/lib/store/workspace/reducer.d.ts

@@ -0,0 +1,22 @@
+import type { Reducer } from '@reduxjs/toolkit';
+import type { WorkspaceAddViewPayload, WorkspaceDeleteViewPayload, WorkspaceState, WorkspaceSetPresetPayload, WorkspaceSetPreventCloseViewPayload, WorkspaceUpdateViewPayload, WorkspaceUpdateViewsPayload, WorkspaceErrorWorkspacePayload, WorkspaceFetchWorkspacePayload, WorkspaceFetchWorkspaceViewPresetPayload, WorkspaceSaveWorkspacePresetPayload, WorkspaceSetNewViewPayload, WorkspaceChangeToEmptyMapWorkspacePayload } from './types';
+export declare const initialState: WorkspaceState;
+export declare const workspaceReducer: Reducer<WorkspaceState>;
+export declare const workspaceActions: {
+    addWorkspaceView: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceAddViewPayload, "workspace/addWorkspaceView">;
+    setNewWorkspaceView: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceSetNewViewPayload, "workspace/setNewWorkspaceView">;
+    teardownComplete: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"workspace/teardownComplete">;
+    deleteWorkspaceView: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceDeleteViewPayload, "workspace/deleteWorkspaceView">;
+    updateWorkspaceViews: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceUpdateViewsPayload, "workspace/updateWorkspaceViews">;
+    updateWorkspaceView: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceUpdateViewPayload, "workspace/updateWorkspaceView">;
+    changePreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceSetPresetPayload, "workspace/changePreset">;
+    changeToEmptyMapWorkspace: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceChangeToEmptyMapWorkspacePayload, "workspace/changeToEmptyMapWorkspace">;
+    setPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceSetPresetPayload, "workspace/setPreset">;
+    setPreventCloseView: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceSetPreventCloseViewPayload, "workspace/setPreventCloseView">;
+    fetchWorkspace: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceFetchWorkspacePayload, "workspace/fetchWorkspace">;
+    loadedWorkspace: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "workspace/loadedWorkspace">;
+    errorWorkspace: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceErrorWorkspacePayload, "workspace/errorWorkspace">;
+    fetchWorkspaceViewPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceFetchWorkspaceViewPresetPayload, "workspace/fetchWorkspaceViewPreset">;
+    saveWorkspacePreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<WorkspaceSaveWorkspacePresetPayload, "workspace/saveWorkspacePreset">;
+    markWorkspaceChanged: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"workspace/markWorkspaceChanged">;
+};

package/dist/src/lib/store/workspace/selectors.d.ts

@@ -0,0 +1,406 @@
+import type { AppStore } from '../types';
+import type { WorkspaceState, WorkspacePreset, WorkspacePresetForBE } from './types';
+import type { WorkspaceSupportedComponentTypes, ViewPreset } from '../viewPresets/types';
+export declare const getWorkspaceState: (store: AppStore) => WorkspaceState;
+/**
+ * Gets component types from the views used in the workspace
+ *
+ * @param {object} store store: object - Store object
+ * @returns {WorkspaceViewType.componentType[]} returnType: WorkspaceViewType.componentType[]
+ */
+export declare const getComponentTypesFromActiveViews: ((state: AppStore) => string[] | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState | undefined) => string[] | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState | undefined) => string[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[] | undefined;
+    dependencies: [(state: AppStore) => WorkspaceState | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets mosaicNode from workspace state
+ *
+ * @param {object} store store: object - Store object
+ * @returns {MosaicNode<string>} returnType: MosaicNode<string>
+ */
+export declare const getMosaicNode: ((state: AppStore) => import("react-mosaic-component").MosaicNode<string>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => import("react-mosaic-component").MosaicNode<string>;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => import("react-mosaic-component").MosaicNode<string>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("react-mosaic-component").MosaicNode<string>;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getWorkspaceId: (store: AppStore) => string | undefined;
+/**
+ * Gets view from workspace state
+ *
+ * @param {object} store store: object - Store object
+ * @param {string} viewId viewId: string - view id
+ * @returns {object} returnType: WorkspaceViewType
+ */
+export declare const getViewById: ((state: AppStore, viewId: string) => import("./types").WorkspaceViewType) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState, resultFuncArgs_1: string) => import("./types").WorkspaceViewType;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState, resultFuncArgs_1: string) => import("./types").WorkspaceViewType) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").WorkspaceViewType;
+    dependencies: [(store: AppStore) => WorkspaceState, (store: AppStore, viewId: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getViewsById: ((state: AppStore) => Record<string, import("./types").WorkspaceViewType>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => Record<string, import("./types").WorkspaceViewType>;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => Record<string, import("./types").WorkspaceViewType>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, import("./types").WorkspaceViewType>;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets all view ids
+ *
+ * @param {object} store store: object - Store object
+ * @returns {object} returnType: string[]
+ */
+export declare const getViewIds: ((state: AppStore) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets getShouldPreventClose from workspace state
+ *
+ * @param {object} store store: object - Store object
+ * @param {string} viewId viewId: string - view id
+ * @returns {boolean} returnType: boolean
+ */
+export declare const getShouldPreventClose: ((state: AppStore, viewId: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./types").WorkspaceViewType) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./types").WorkspaceViewType) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [((state: AppStore, viewId: string) => import("./types").WorkspaceViewType) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: WorkspaceState, resultFuncArgs_1: string) => import("./types").WorkspaceViewType;
+        memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState, resultFuncArgs_1: string) => import("./types").WorkspaceViewType) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("./types").WorkspaceViewType;
+        dependencies: [(store: AppStore) => WorkspaceState, (store: AppStore, viewId: string) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const isWorkspaceLoading: ((state: AppStore) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getWorkspaceError: ((state: AppStore) => import("./types").WorkspaceError) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => import("./types").WorkspaceError;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => import("./types").WorkspaceError) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").WorkspaceError;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets selected workspace title
+ *
+ * @param {object} store store: object - Store object
+ * @returns {string} returnType: string
+ */
+export declare const getSelectedWorkspaceTitle: ((state: AppStore) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const hasWorkspaceChanges: ((state: AppStore) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets selected viewType
+ *
+ * @param {object} store store: object - Store object
+ * @returns {string} returnType: string
+ */
+export declare const getViewType: ((state: AppStore) => "" | import("./types").ViewType) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => "" | import("./types").ViewType;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => "" | import("./types").ViewType) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => "" | import("./types").ViewType;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets selected workspace scope
+ *
+ * @param {object} store store: object - Store object
+ * @returns {string} returnType: string
+ */
+export declare const getSelectedWorkspaceScope: ((state: AppStore) => import("@opengeoweb/shared").SystemScope) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WorkspaceState) => import("@opengeoweb/shared").SystemScope;
+    memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState) => import("@opengeoweb/shared").SystemScope) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("@opengeoweb/shared").SystemScope;
+    dependencies: [(store: AppStore) => WorkspaceState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+type WorkspaceData = WorkspacePresetForBE & Pick<WorkspacePreset, 'isTimeScrollingEnabled'>;
+/**
+ * Gets workspace data to send to the backend
+ *
+ * @param {object} store store: object - Store object
+ * @returns {object} returnType: object - WorkspacePresetFromBE
+ */
+export declare const getWorkspaceData: (store: AppStore) => WorkspaceData;
+export declare const getViewComponentType: ((state: AppStore, viewId: string) => WorkspaceSupportedComponentTypes) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./types").WorkspaceViewType) => WorkspaceSupportedComponentTypes;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./types").WorkspaceViewType) => WorkspaceSupportedComponentTypes) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => WorkspaceSupportedComponentTypes;
+    dependencies: [((state: AppStore, viewId: string) => import("./types").WorkspaceViewType) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: WorkspaceState, resultFuncArgs_1: string) => import("./types").WorkspaceViewType;
+        memoizedResultFunc: ((resultFuncArgs_0: WorkspaceState, resultFuncArgs_1: string) => import("./types").WorkspaceViewType) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("./types").WorkspaceViewType;
+        dependencies: [(store: AppStore) => WorkspaceState, (store: AppStore, viewId: string) => string];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getViewPresetToSendToBackend: ((state: any, ...params: any[]) => Omit<ViewPreset, "title"> & {
+    title?: string;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (...resultFuncArgs: readonly any[]) => Omit<ViewPreset, "title"> & {
+        title?: string;
+    };
+    memoizedResultFunc: ((...resultFuncArgs: readonly any[]) => Omit<ViewPreset, "title"> & {
+        title?: string;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Omit<ViewPreset, "title"> & {
+        title?: string;
+    };
+    dependencies: import("reselect").SelectorArray<any>;
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export {};