@opengeoweb/store 5.2.1 → 6.0.0

package/src/store/mapStore/index.d.ts

@@ -0,0 +1,77 @@
+export declare const mapStoreActions: {
+    serviceSetLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayersForServicePayload, "serviceReducer/serviceSetLayers">;
+    mapStoreRemoveService: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").MapStoreRemoveServicePayload, "serviceReducer/mapStoreRemoveService">;
+    fetchInitialServices: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").FetchInitialServicesPayload, "serviceReducer/fetchInitialServices">;
+    setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapPresetPayload, string>;
+    mapChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapDimensionPayload, string>;
+    registerMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+    }, "mapReducer/registerMap">;
+    unregisterMap: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+    }, "mapReducer/unregisterMap">;
+    setBbox: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetBboxPayload, "mapReducer/setBbox">;
+    mapUpdateAllMapDimensions: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").UpdateAllMapDimensionsPayload, "mapReducer/mapUpdateAllMapDimensions">;
+    mapStartAnimation: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapAnimationStartPayload, "mapReducer/mapStartAnimation">;
+    mapStopAnimation: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetMapAnimationStopPayload, "mapReducer/mapStopAnimation">;
+    setTimeSliderSpan: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetTimeSliderSpanPayload, "mapReducer/setTimeSliderSpan">;
+    setTimeStep: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetTimeStepPayload, "mapReducer/setTimeStep">;
+    setAnimationStartTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetAnimationStartTimePayload, "mapReducer/setAnimationStartTime">;
+    setAnimationEndTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetAnimationEndTimePayload, "mapReducer/setAnimationEndTime">;
+    setAnimationDelay: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetAnimationDelayPayload, "mapReducer/setAnimationDelay">;
+    layerMoveLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").MoveLayerPayload, "mapReducer/layerMoveLayer">;
+    setAutoLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetAutoLayerIdPayload, "mapReducer/setAutoLayerId">;
+    setAutoTimestepLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        autoTimestepLayerId: string | undefined;
+    }, "mapReducer/setAutoTimestepLayerId">;
+    setAutoUpdateLayerId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        mapId: string;
+        autoUpdateLayerId: string | undefined;
+    }, "mapReducer/setAutoUpdateLayerId">;
+    setTimeSliderWidth: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetTimeSliderWidthPayload, "mapReducer/setTimeSliderWidth">;
+    setTimeSliderCenterTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetTimeSliderCenterTimePayload, "mapReducer/setTimeSliderCenterTime">;
+    setTimeSliderUnfilteredSelectedTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetTimeSliderUnfilteredSelectedTimePayload, "mapReducer/setTimeSliderUnfilteredSelectedTime">;
+    setTimeSliderSecondsPerPx: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetTimeSliderSecondsPerPxPayload, "mapReducer/setTimeSliderSecondsPerPx">;
+    toggleAutoUpdate: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ToggleAutoUpdatePayload, "mapReducer/toggleAutoUpdate">;
+    setEndTimeOverriding: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetEndTimeOverriding, "mapReducer/setEndTimeOverriding">;
+    toggleTimestepAuto: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ToggleTimestepAutoPayload, "mapReducer/toggleTimestepAuto">;
+    toggleTimeSpanAuto: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ToggleTimeSpanAutoPayload, "mapReducer/toggleTimeSpanAuto">;
+    toggleTimeSliderHover: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ToggleTimeSliderHoverPayload, "mapReducer/toggleTimeSliderHover">;
+    toggleTimeSliderIsVisible: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ToggleTimeSliderIsVisiblePayload, "mapReducer/toggleTimeSliderIsVisible">;
+    toggleZoomControls: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ToggleZoomControlsPayload, "mapReducer/toggleZoomControls">;
+    setMapPinLocation: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").MapPinLocationPayload, "mapReducer/setMapPinLocation">;
+    setDisableMapPin: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").DisableMapPinPayload, "mapReducer/setDisableMapPin">;
+    toggleMapPinIsVisible: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ToggleMapPinIsVisiblePayload, "mapReducer/toggleMapPinIsVisible">;
+    setDockedLayerManagerSize: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetDockedLayerManagerSize, "mapReducer/setDockedLayerManagerSize">;
+    addLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").AddLayerPayload, "layerReducer/addLayer">;
+    layerChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayerDimensionPayload, "layerReducer/layerChangeDimension">;
+    layerChangeEnabled: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayerEnabledPayload, "layerReducer/layerChangeEnabled">;
+    layerChangeOpacity: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayerOpacityPayload, "layerReducer/layerChangeOpacity">;
+    layerChangeStyle: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayerStylePayload, "layerReducer/layerChangeStyle">;
+    layerChangeAcceptanceTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        layerId: string;
+        acceptanceTime: number | undefined;
+    }, "layerReducer/layerChangeAcceptanceTime">;
+    layerChangeName: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayerNamePayload, "layerReducer/layerChangeName">;
+    layerChangeGeojson: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayerGeojsonPayload, "layerReducer/layerChangeGeojson">;
+    layerDelete: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").DeleteLayerPayload, "layerReducer/layerDelete">;
+    layerError: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").ErrorLayerPayload, "layerReducer/layerError">;
+    baseLayerDelete: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").DeleteLayerPayload, "layerReducer/baseLayerDelete">;
+    setLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayersPayload, "layerReducer/setLayers">;
+    setBaseLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetBaseLayersPayload, "layerReducer/setBaseLayers">;
+    addBaseLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").AddBaseLayerPayload, "layerReducer/addBaseLayer">;
+    layerSetDimensions: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetLayerDimensionsPayload, "layerReducer/layerSetDimensions">;
+    addAvailableBaseLayer: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").AddAvailableBaseLayerPayload, "layerReducer/addAvailableBaseLayer">;
+    addAvailableBaseLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").AddAvailableBaseLayersPayload, "layerReducer/addAvailableBaseLayers">;
+    setAvailableBaseLayers: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetAvailableBaseLayersPayload, "layerReducer/setAvailableBaseLayers">;
+    onUpdateLayerInformation: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").UpdateLayerInfoPayload, "layerReducer/onUpdateLayerInformation">;
+    setSelectedFeature: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./types").SetSelectedFeaturePayload, "layerReducer/setSelectedFeature">;
+};
+export * from './service';
+export * from './map';
+export * from './layers';
+export type { WebMapStateModuleState } from './types';
+export * from './utils';
+export * as storeTestSettings from './storeTestSettings';
+export * from './config';

package/src/store/mapStore/layers/index.d.ts

@@ -0,0 +1,4 @@
+export { layerActions, reducer as layerReducer } from './reducer';
+export type { LayerActions } from './reducer';
+export * as layerSelectors from './selectors';
+export * as layerTypes from './types';

package/src/store/mapStore/layers/reducer.d.ts

@@ -0,0 +1,56 @@
+import { Draft, PayloadAction } from '@reduxjs/toolkit';
+import { LayerState, Layer, AddLayerPayload, SetLayerDimensionPayload, SetLayerEnabledPayload, SetLayerOpacityPayload, SetLayerStylePayload, SetLayerNamePayload, SetLayerGeojsonPayload, DeleteLayerPayload, ErrorLayerPayload, SetLayersPayload, SetBaseLayersPayload, AddBaseLayerPayload, SetLayerDimensionsPayload, AddAvailableBaseLayerPayload, AddAvailableBaseLayersPayload, UpdateLayerInfoPayload, SetAvailableBaseLayersPayload, SetSelectedFeaturePayload } from './types';
+export declare const createLayer: ({ id, opacity, acceptanceTimeInMinutes, enabled, layerType, status, ...props }: Layer) => Layer;
+export declare const initialState: LayerState;
+export declare const slice: import("@reduxjs/toolkit").Slice<LayerState, {
+    addLayer: (draft: Draft<LayerState>, action: PayloadAction<AddLayerPayload>) => void;
+    layerChangeDimension: (draft: Draft<LayerState>, action: PayloadAction<SetLayerDimensionPayload>) => void;
+    layerChangeEnabled: (draft: Draft<LayerState>, action: PayloadAction<SetLayerEnabledPayload>) => void;
+    layerChangeOpacity: (draft: Draft<LayerState>, action: PayloadAction<SetLayerOpacityPayload>) => void;
+    layerChangeStyle: (draft: Draft<LayerState>, action: PayloadAction<SetLayerStylePayload>) => void;
+    layerChangeAcceptanceTime: (draft: Draft<LayerState>, action: PayloadAction<{
+        layerId: string;
+        acceptanceTime: number | undefined;
+    }>) => void;
+    layerChangeName: (draft: Draft<LayerState>, action: PayloadAction<SetLayerNamePayload>) => void;
+    layerChangeGeojson: (draft: Draft<LayerState>, action: PayloadAction<SetLayerGeojsonPayload>) => void;
+    layerDelete: (draft: Draft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    layerError: (draft: Draft<LayerState>, action: PayloadAction<ErrorLayerPayload>) => void;
+    baseLayerDelete: (draft: Draft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    setLayers: (draft: Draft<LayerState>, action: PayloadAction<SetLayersPayload>) => void;
+    setBaseLayers: (draft: Draft<LayerState>, action: PayloadAction<SetBaseLayersPayload>) => void;
+    addBaseLayer: (draft: Draft<LayerState>, action: PayloadAction<AddBaseLayerPayload>) => void;
+    layerSetDimensions: (draft: Draft<LayerState>, action: PayloadAction<SetLayerDimensionsPayload>) => void;
+    addAvailableBaseLayer: (draft: Draft<LayerState>, action: PayloadAction<AddAvailableBaseLayerPayload>) => void;
+    addAvailableBaseLayers: (draft: Draft<LayerState>, action: PayloadAction<AddAvailableBaseLayersPayload>) => void;
+    setAvailableBaseLayers: (draft: Draft<LayerState>, action: PayloadAction<SetAvailableBaseLayersPayload>) => void;
+    onUpdateLayerInformation: (draft: Draft<LayerState>, action: PayloadAction<UpdateLayerInfoPayload>) => void;
+    setSelectedFeature: (draft: Draft<LayerState>, action: PayloadAction<SetSelectedFeaturePayload>) => void;
+}, "layerReducer">;
+export declare const reducer: import("redux").Reducer<LayerState, import("redux").AnyAction>;
+export declare const layerActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    addLayer: (draft: Draft<LayerState>, action: PayloadAction<AddLayerPayload>) => void;
+    layerChangeDimension: (draft: Draft<LayerState>, action: PayloadAction<SetLayerDimensionPayload>) => void;
+    layerChangeEnabled: (draft: Draft<LayerState>, action: PayloadAction<SetLayerEnabledPayload>) => void;
+    layerChangeOpacity: (draft: Draft<LayerState>, action: PayloadAction<SetLayerOpacityPayload>) => void;
+    layerChangeStyle: (draft: Draft<LayerState>, action: PayloadAction<SetLayerStylePayload>) => void;
+    layerChangeAcceptanceTime: (draft: Draft<LayerState>, action: PayloadAction<{
+        layerId: string;
+        acceptanceTime: number | undefined;
+    }>) => void;
+    layerChangeName: (draft: Draft<LayerState>, action: PayloadAction<SetLayerNamePayload>) => void;
+    layerChangeGeojson: (draft: Draft<LayerState>, action: PayloadAction<SetLayerGeojsonPayload>) => void;
+    layerDelete: (draft: Draft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    layerError: (draft: Draft<LayerState>, action: PayloadAction<ErrorLayerPayload>) => void;
+    baseLayerDelete: (draft: Draft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    setLayers: (draft: Draft<LayerState>, action: PayloadAction<SetLayersPayload>) => void;
+    setBaseLayers: (draft: Draft<LayerState>, action: PayloadAction<SetBaseLayersPayload>) => void;
+    addBaseLayer: (draft: Draft<LayerState>, action: PayloadAction<AddBaseLayerPayload>) => void;
+    layerSetDimensions: (draft: Draft<LayerState>, action: PayloadAction<SetLayerDimensionsPayload>) => void;
+    addAvailableBaseLayer: (draft: Draft<LayerState>, action: PayloadAction<AddAvailableBaseLayerPayload>) => void;
+    addAvailableBaseLayers: (draft: Draft<LayerState>, action: PayloadAction<AddAvailableBaseLayersPayload>) => void;
+    setAvailableBaseLayers: (draft: Draft<LayerState>, action: PayloadAction<SetAvailableBaseLayersPayload>) => void;
+    onUpdateLayerInformation: (draft: Draft<LayerState>, action: PayloadAction<UpdateLayerInfoPayload>) => void;
+    setSelectedFeature: (draft: Draft<LayerState>, action: PayloadAction<SetSelectedFeaturePayload>) => void;
+}, "layerReducer">;
+export declare type LayerActions = ReturnType<typeof layerActions.layerSetDimensions> | ReturnType<typeof layerActions.layerChangeStyle> | ReturnType<typeof layerActions.addAvailableBaseLayer> | ReturnType<typeof layerActions.addAvailableBaseLayers> | ReturnType<typeof layerActions.addBaseLayer> | ReturnType<typeof layerActions.addLayer> | ReturnType<typeof layerActions.baseLayerDelete> | ReturnType<typeof layerActions.onUpdateLayerInformation> | ReturnType<typeof layerActions.layerChangeDimension> | ReturnType<typeof layerActions.layerChangeEnabled> | ReturnType<typeof layerActions.layerChangeGeojson> | ReturnType<typeof layerActions.layerChangeName> | ReturnType<typeof layerActions.layerChangeOpacity> | ReturnType<typeof layerActions.layerDelete> | ReturnType<typeof layerActions.layerError> | ReturnType<typeof layerActions.setBaseLayers> | ReturnType<typeof layerActions.setLayers>;

package/src/store/mapStore/layers/reducer.spec.d.ts

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

package/src/store/mapStore/layers/selectors.d.ts

@@ -0,0 +1,443 @@
+import type { CoreAppStore } from '../../types';
+import type { Dimension, ReduxLayer } from '../types';
+import { LayerState, Layer, LayerStatus } from './types';
+/**
+ * Gets a layer from the layers part of the store by its Id
+ *
+ * Example: layer = getLayerById(store, 'layerId')
+ * @param {object} store object from which the layer state will be extracted
+ * @param {string} layerId Id of the layer
+ * @returns {object} object containing layer information (service, name, style, enabled etc.)
+ */
+export declare const getLayerById: (store: CoreAppStore, layerId?: string | undefined) => Layer | undefined;
+/**
+ * Retrieves all layers indexed by layerId
+ *
+ * Example: layers = getLayersById(store)
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @returns {object} returnType: object - an object of all layers containing layer information (service, name, style, enabled etc.) indexed by layerId
+ */
+export declare const getLayersById: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}) => Record<string, ReduxLayer> | null) & import("reselect").OutputSelectorFields<(args_0: LayerState | undefined) => Record<string, ReduxLayer> | null, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Retrieves all layerIds
+ *
+ * Example: layerIds = getLayersIds(store)
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @returns {array} returnType: array - an array of all layerIds
+ */
+export declare const getLayersIds: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}) => string[]) & import("reselect").OutputSelectorFields<(args_0: LayerState | undefined) => string[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Retrieves all layers (including base layers and overlayers)
+ *
+ * Example: layers = getAllLayers(store)
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @returns {array} returnType: array - an array of all layers containing layer information (service, name, style, enabled etc.)
+ */
+export declare const getAllLayers: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}) => ReduxLayer[]) & import("reselect").OutputSelectorFields<(args_0: string[], args_1: Record<string, ReduxLayer> | null) => ReduxLayer[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Retrieves all layers (including base layers and overlayers) for the given mapId
+ *
+ * Example: layers = getLayersByMapId(store, mapId)
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} mapId mapId: string - mapId
+ * @returns {array} returnType: ReduxLayer[] - an array of all layers containing layer information (service, name, style, enabled etc.)
+ */
+export declare const getLayersByMapId: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string) => ReduxLayer[]) & import("reselect").OutputSelectorFields<(args_0: ReduxLayer[], args_1: string) => ReduxLayer[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Retrieves all layers that aren't base layers and aren't overlayers
+ *
+ * Example: layers = getLayers(store)
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @returns {array} returnType: array - an array of all non-baselayers containing layer information (service, name, style, enabled etc.)
+ */
+export declare const getLayers: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}) => ReduxLayer[]) & import("reselect").OutputSelectorFields<(args_0: ReduxLayer[]) => ReduxLayer[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Retrieves all baselayers
+ *
+ * Example: layers = getBaseLayers(store)
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @returns {array} returnType: array - an array of all baselayers containing layer information (service, name, style, enabled etc.)
+ */
+export declare const getBaseLayers: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}) => ReduxLayer[]) & import("reselect").OutputSelectorFields<(args_0: ReduxLayer[]) => ReduxLayer[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Retrieves all overLayers
+ *
+ * Example: layers = getOverLayers(store)
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @returns {array} returnType: array - an array of all overLayers containing layer information (service, name, style, enabled etc.)
+ */
+export declare const getOverLayers: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}) => ReduxLayer[]) & import("reselect").OutputSelectorFields<(args_0: ReduxLayer[]) => ReduxLayer[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets dimensions of the passed layer
+ *
+ * Example: layerDimensions = getLayerDimensions(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {array} returnType: Dimension[] - array containing layer dimensions
+ */
+export declare const getLayerDimensions: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => Dimension[]) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => Dimension[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets dimensions of the passed layer, excluding the time dimension
+ *
+ * Example: layerNonTimeDimensions = getLayerNonTimeDimensions(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {array} returnType: Dimension[] - array containing layer dimensions, excluding the time dimension
+ */
+export declare const getLayerNonTimeDimensions: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => Dimension[]) & import("reselect").OutputSelectorFields<(args_0: Dimension[]) => Dimension[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets time dimension of the passed layer
+ *
+ * Example: timeDimension = getLayerTimeDimension(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {object} returnType: object - object of layer time dimension
+ */
+export declare const getLayerTimeDimension: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => Dimension | undefined) & import("reselect").OutputSelectorFields<(args_0: Dimension[]) => Dimension | undefined, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const getLayerCurrentTime: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => string | undefined) & import("reselect").OutputSelectorFields<(args_0: Dimension | undefined) => string | undefined, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets specified dimension of the passed layer
+ *
+ * Example: dimension = getLayerDimension(store, 'layerId_1', 'elevation')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @param {string} dimensionName dimensionName: string - name of dimension you want to retrieve the dimension data for
+ * @returns {object} returnType: object - object of layer dimension
+ */
+export declare const getLayerDimension: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string, params_1: string) => Dimension) & import("reselect").OutputSelectorFields<(args_0: Dimension[], args_1: string) => Dimension, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets opacity of the passed layer
+ *
+ * Example: layerOpacity = getLayerOpacity(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {number} returnType: number - opacity as a number (between 0 and 1)
+ */
+export declare const getLayerOpacity: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => number) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => number, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets whether a layer is enabled or disabled
+ *
+ * Example: isLayerEnabled = getLayerEnabled(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {boolean} returnType: boolean -  true if enabled, false if disabled
+ */
+export declare const getLayerEnabled: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => boolean) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => boolean, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets layer name
+ *
+ * Example: layerName = getLayerName(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {string} returnType: string -  layer name
+ */
+export declare const getLayerName: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => string) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => string, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets layer service
+ *
+ * Example: layerService = getLayerService(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {string} returnType: string -  layer service
+ */
+export declare const getLayerService: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => string) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => string, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets selected style of the passed layer
+ *
+ * Example: layerStyle = getLayerStyle(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {string} returnType: string - style that is currently selected
+ */
+export declare const getLayerStyle: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => string) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => string, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets layer status
+ *
+ * Example: layerService = getLayerStatus(store, 'layerId_1')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} layerId layerId: string - Id of the layer
+ * @returns {string} returnType: LayerStatus
+ */
+export declare const getLayerStatus: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => LayerStatus) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => LayerStatus, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets all available base layers for a map
+ *
+ * Example: availableBaseLayers = getAvailableBaseLayersForMap(store)
+ * @param {object} store store: object - object from which the layer state will be extracted
+ * @param {string} mapId mapId: string - Id of the map we want to retrieve the available baselayers for
+ * @returns {array} returnType: array - array containing all available base layers
+ */
+export declare const getAvailableBaseLayersForMap: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string) => Layer[]) & import("reselect").OutputSelectorFields<(args_0: LayerState | undefined, args_1: string) => Layer[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Returns the selected geojson feature for the given layer
+ *
+ * Example const selectedFeature = getSelectedFeature(store, 'layerId1')
+ * @param {object} store store: object - store object
+ * @param {string} mapId layerId: string - Id of the layer
+ * @returns {number} selectedFeatureIndex: the index of the selected geojson feature
+ */
+export declare const getSelectedFeatureIndex: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => number | undefined) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => number | undefined, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets layerIds that contain passed dimension
+ *
+ * Example: dimension = getDimensionLayerIds(store, 'elevation')
+ * @param {object} store store: object - object from which the layers state will be extracted
+ * @param {string} dimensionName dimensionName: string - name of dimension you want to retrieve the dimension data for
+ * @returns {string[]} returnType: string[] - layerIds
+ */
+export declare const getDimensionLayerIds: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string) => string[]) & import("reselect").OutputSelectorFields<(args_0: string[], args_1: Record<string, ReduxLayer> | null, args_2: string) => string[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const getAcceptanceTimeInMinutes: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0?: string | undefined) => number | undefined) & import("reselect").OutputSelectorFields<(args_0: Layer | undefined) => number | undefined, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export declare const getLayerIsInsideAcceptanceTime: ((state: {
+    syncronizationGroupStore?: import("../../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../../ui/types").UIStoreType | undefined;
+    webmap?: import("../types").WebMapState | undefined;
+    services?: import("../types").ServiceState | undefined;
+    layers?: LayerState | undefined;
+    layerSelect?: import("../../layerSelect/types").LayerSelectStoreType | undefined;
+}, params_0: string | undefined, params_1: string) => "equal" | "outside" | "inside") & import("reselect").OutputSelectorFields<(args_0: number | undefined, args_1: string | undefined, args_2: string | undefined) => "equal" | "outside" | "inside", {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};

package/src/store/mapStore/layers/selectors.spec.d.ts

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