@opengeoweb/core 2.9.0 → 2.13.0

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

@@ -1,6 +1,44 @@
-import { LayerActions, LayerState, Layer } from './types';
-import { MapActions } from '../map/reducer';
-import { GenericSyncActions } from '../../generic/synchronizationActions/actions';
+import { PayloadAction } from '@reduxjs/toolkit';
+import { LayerState, Layer, AddLayerPayload, SetLayerDimensionPayload, SetLayerEnabledPayload, SetLayerOpacityPayload, SetLayerStylePayload, SetLayerNamePayload, SetLayerGeojsonPayload, DeleteLayerPayload, ErrorLayerPayload, SetLayersPayload, SetBaseLayersPayload, AddBaseLayerPayload, SetLayerDimensionsPayload, AddAvailableBaseLayerPayload, AddAvailableBaseLayersPayload, UpdateLayerInfoPayload } from './types';
 export declare const createLayer: ({ id, opacity, enabled, layerType, status, ...props }: Layer) => Layer;
 export declare const initialState: LayerState;
-export declare const reducer: (state: LayerState, action: LayerActions | MapActions | GenericSyncActions) => LayerState;
+export declare const slice: import("@reduxjs/toolkit").Slice<LayerState, {
+    addLayer: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddLayerPayload>) => void;
+    layerChangeDimension: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerDimensionPayload>) => void;
+    layerChangeEnabled: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerEnabledPayload>) => void;
+    layerChangeOpacity: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerOpacityPayload>) => void;
+    layerChangeStyle: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerStylePayload>) => void;
+    layerChangeName: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerNamePayload>) => void;
+    layerChangeGeojson: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerGeojsonPayload>) => void;
+    layerDelete: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    layerError: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<ErrorLayerPayload>) => void;
+    baseLayerDelete: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    setLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayersPayload>) => void;
+    setBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetBaseLayersPayload>) => void;
+    addBaseLayer: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddBaseLayerPayload>) => void;
+    layerSetDimensions: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerDimensionsPayload>) => void;
+    addAvailableBaseLayer: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddAvailableBaseLayerPayload>) => void;
+    addAvailableBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddAvailableBaseLayersPayload>) => void;
+    onUpdateLayerInformation: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<UpdateLayerInfoPayload>) => LayerState;
+}, "layerReducer">;
+export declare const reducer: import("@reduxjs/toolkit").Reducer<LayerState, import("@reduxjs/toolkit").AnyAction>;
+export declare const layerActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    addLayer: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddLayerPayload>) => void;
+    layerChangeDimension: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerDimensionPayload>) => void;
+    layerChangeEnabled: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerEnabledPayload>) => void;
+    layerChangeOpacity: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerOpacityPayload>) => void;
+    layerChangeStyle: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerStylePayload>) => void;
+    layerChangeName: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerNamePayload>) => void;
+    layerChangeGeojson: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerGeojsonPayload>) => void;
+    layerDelete: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    layerError: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<ErrorLayerPayload>) => void;
+    baseLayerDelete: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<DeleteLayerPayload>) => void;
+    setLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayersPayload>) => void;
+    setBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetBaseLayersPayload>) => void;
+    addBaseLayer: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddBaseLayerPayload>) => void;
+    layerSetDimensions: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<SetLayerDimensionsPayload>) => void;
+    addAvailableBaseLayer: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddAvailableBaseLayerPayload>) => void;
+    addAvailableBaseLayers: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<AddAvailableBaseLayersPayload>) => void;
+    onUpdateLayerInformation: (draft: import("immer/dist/internal").WritableDraft<LayerState>, action: PayloadAction<UpdateLayerInfoPayload>) => LayerState;
+}>;
+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/lib/store/mapStore/layers/types.d.ts

@@ -1,9 +1,9 @@
-import { Action } from 'redux';
+import { Action } from '@reduxjs/toolkit';
 import { Style } from '@opengeoweb/webmap';
 import { FeatureCollection } from 'geojson';
-import { Dimension, UpdateAllMapDimensionsPayload } from '../map/types';
-import { WEBMAP_LAYER_CHANGE_OPACITY, WEBMAP_LAYER_CHANGE_NAME, WEBMAP_LAYER_CHANGE_STYLE, WEBMAP_LAYER_CHANGE_DIMENSION, WEBMAP_LAYER_CHANGE_ENABLED, WEBMAP_LAYER_DELETE, WEBMAP_ADD_LAYER, WEBMAP_SET_LAYERS, WEBMAP_SET_BASELAYERS, WEBMAP_ADD_BASELAYER, WEBMAP_BASELAYER_DELETE, WEBMAP_LAYER_ERROR, WEBMAP_ADD_AVAILABLE_BASELAYER, WEBMAP_ADD_AVAILABLE_BASELAYERS, WEBMAP_LAYER_SET_DIMENSIONS, WEBMAP_UPDATE_LAYER_INFO, WEBMAP_LAYER_CHANGE_GEOJSON } from './constants';
+import type { Dimension, UpdateAllMapDimensionsPayload } from '../map/types';
 import type { SetLayersForServicePayload } from '../types';
+import type { SyncGroupActionOrigin } from '../../generic/synchronizationGroups/types';
 export interface WMJSDimension {
     getFirstValue(): string;
     getLastValue(): string;
@@ -64,6 +64,13 @@ export interface LayerState {
     allIds: string[];
     availableBaseLayers: AvailableBaseLayersType;
 }
+export declare enum LayerActionOrigin {
+    layerManager = "layerManager",
+    wmsLoader = "WMSLayerTreeConnect",
+    ReactMapViewParseLayer = "ReactMapViewParseLayer",
+    setLayerDimensionSaga = "setLayerDimensionSaga",
+    toggleAutoUpdateSaga = "toggleAutoUpdateSaga"
+}
 export interface LayerPayload {
     layerId: string;
     origin?: string;
@@ -73,67 +80,40 @@ export interface SetLayersPayload {
     layers: ReduxLayer[];
     origin?: string;
 }
-export interface SetLayers extends Action {
-    type: typeof WEBMAP_SET_LAYERS;
-    payload: SetLayersPayload;
-}
 export interface SetBaseLayersPayload {
     mapId: string;
     layers: ReduxLayer[];
-    origin?: string;
-}
-export interface SetBaseLayers extends Action {
-    type: typeof WEBMAP_SET_BASELAYERS;
-    payload: SetBaseLayersPayload;
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.layerActions;
 }
 export interface SetLayerDimensionsPayload extends LayerPayload {
     origin: string;
     dimensions: Dimension[];
 }
-export interface SetLayerDimensions extends Action {
-    type: typeof WEBMAP_LAYER_SET_DIMENSIONS;
-    payload: SetLayerDimensionsPayload;
-}
 export interface SetLayerOpacityPayload extends LayerPayload {
     opacity: number;
-}
-export interface SetLayerOpacity extends Action {
-    type: typeof WEBMAP_LAYER_CHANGE_OPACITY;
-    payload: SetLayerOpacityPayload;
+    mapId?: string;
+    origin?: LayerActionOrigin;
 }
 export interface SetLayerNamePayload extends LayerPayload {
     name: string;
-}
-export interface SetLayerName extends Action {
-    type: typeof WEBMAP_LAYER_CHANGE_NAME;
-    payload: SetLayerNamePayload;
+    mapId?: string;
+    origin?: LayerActionOrigin;
 }
 export interface SetLayerEnabledPayload extends LayerPayload {
     enabled: boolean;
-}
-export interface SetLayerEnabled extends Action {
-    type: typeof WEBMAP_LAYER_CHANGE_ENABLED;
-    payload: SetLayerEnabledPayload;
+    mapId?: string;
+    origin?: LayerActionOrigin;
 }
 export interface SetLayerDimensionPayload extends LayerPayload {
-    origin: string;
     dimension: Dimension;
     service?: string;
-}
-export interface SetLayerDimension extends Action {
-    type: typeof WEBMAP_LAYER_CHANGE_DIMENSION;
-    payload: SetLayerDimensionPayload;
+    origin?: LayerActionOrigin;
+    mapId?: string;
 }
 export interface SetLayerStylePayload extends LayerPayload {
     style: string;
-}
-export interface SetLayerStyle extends Action {
-    type: typeof WEBMAP_LAYER_CHANGE_STYLE;
-    payload: SetLayerStylePayload;
-}
-export interface SetLayerGeojson extends Action {
-    type: typeof WEBMAP_LAYER_CHANGE_GEOJSON;
-    payload: SetLayerGeojsonPayload;
+    mapId?: string;
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.layerActions;
 }
 export interface SetLayerGeojsonPayload extends LayerPayload {
     geojson: FeatureCollection;
@@ -141,14 +121,7 @@ export interface SetLayerGeojsonPayload extends LayerPayload {
 export interface DeleteLayerPayload extends LayerPayload {
     mapId: string;
     layerIndex: number;
-}
-export interface DeleteLayer extends Action {
-    type: typeof WEBMAP_LAYER_DELETE;
-    payload: DeleteLayerPayload;
-}
-export interface DeleteBaseLayer extends Action {
-    type: typeof WEBMAP_BASELAYER_DELETE;
-    payload: DeleteLayerPayload;
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.delete;
 }
 export interface AddLayerPayload {
     mapId: string;
@@ -156,32 +129,16 @@ export interface AddLayerPayload {
     layer: Layer;
     origin: string;
 }
-export interface AddLayer extends Action {
-    type: typeof WEBMAP_ADD_LAYER;
-    payload: AddLayerPayload;
-}
-export interface AddBaseLayer extends Action {
-    type: typeof WEBMAP_ADD_BASELAYER;
-    payload: AddBaseLayerPayload;
-}
 export interface AddBaseLayerPayload {
     mapId: string;
     layerId: string;
     layer: Layer;
     origin?: string;
 }
-export interface AddAvailableBaseLayer extends Action {
-    type: typeof WEBMAP_ADD_AVAILABLE_BASELAYER;
-    payload: AddAvailableBaseLayerPayload;
-}
 export interface AddAvailableBaseLayerPayload {
     layer: Layer;
     origin?: string;
 }
-export interface AddAvailableBaseLayers extends Action {
-    type: typeof WEBMAP_ADD_AVAILABLE_BASELAYERS;
-    payload: AddAvailableBaseLayersPayload;
-}
 export interface AddAvailableBaseLayersPayload {
     layers: ReduxLayer[];
     origin?: string;
@@ -189,19 +146,14 @@ export interface AddAvailableBaseLayersPayload {
 export interface ErrorLayerPayload extends LayerPayload {
     error: Error;
 }
-export interface ErrorLayer extends Action {
-    type: typeof WEBMAP_LAYER_ERROR;
-    payload: ErrorLayerPayload;
-}
 export interface UpdateLayerInfoPayload {
-    origin?: string;
+    origin: string;
     mapDimensions?: UpdateAllMapDimensionsPayload;
     layerStyle?: SetLayerStylePayload;
     layerDimensions?: SetLayerDimensionsPayload;
     serviceLayers?: SetLayersForServicePayload;
 }
 export interface UpdateLayerInfo extends Action {
-    type: typeof WEBMAP_UPDATE_LAYER_INFO;
+    type: `layerReducer/onUpdateLayerInformation`;
     payload: UpdateLayerInfoPayload;
 }
-export declare type LayerActions = SetLayerDimensions | SetLayerOpacity | SetLayerEnabled | SetLayerDimension | SetLayerStyle | SetLayerName | SetLayerGeojson | DeleteLayer | DeleteBaseLayer | AddLayer | SetLayers | SetBaseLayers | AddBaseLayer | ErrorLayer | AddAvailableBaseLayer | AddAvailableBaseLayers | UpdateLayerInfo;

package/lib/store/mapStore/map/actions.d.ts

@@ -0,0 +1,8 @@
+import { SetMapDimensionPayload, SetMapPresetPayload } from './types';
+/**
+ * These actions causes circular dependency if they are defined in the reducer.ts file.
+ * Therefor they are instead added to this file
+ * https://redux-toolkit.js.org/usage/usage-guide#exporting-and-using-slices
+ */
+export declare const mapChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetMapDimensionPayload, string>;
+export declare const setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetMapPresetPayload, string>;

package/lib/store/mapStore/map/index.d.ts

@@ -0,0 +1,2 @@
+export { mapActions } from './reducer';
+export * as mapSelectors from './selectors';

package/lib/store/mapStore/map/reducer.d.ts

@@ -1,4 +1,6 @@
-import { WebMapState, SetMapDimensionPayload, SetMapPresetPayload } from './types';
+import { PayloadAction } from '@reduxjs/toolkit';
+import { WebMapState, SetActiveLayerIdPayload, SetBboxPayload, SetMapAnimationStartPayload, SetMapAnimationStopPayload, SetTimeSliderScalePayload, SetTimeStepPayload, SetAnimationStartTimePayload, SetAnimationEndTimePayload, SetSelectedFeaturePayload, SetAnimationDelayPayload, MoveLayerPayload, SetTimeSliderCenterTimePayload, SetTimeSliderDataScaleToSecondsPerPxPayload, ToggleAutoUpdatePayload, ToggleTimestepAutoPayload, ToggleTimeSliderHoverPayload, MapPinLocationPayload, DisableMapPinPayload, SetActiveMapPresetPayload, SetTimeSliderSecondsPerPxPayload, UpdateAllMapDimensionsPayload, SetIsMapPresetLoadingPayload, SetIsMapPresetHasChangesPayload, SetMapPresetErrorPayload, ToggleTimeSliderIsVisiblePayload, SetAnimationIntervalPayload } from './types';
+import { ToggleMapPinIsVisiblePayload, ToggleZoomControlsPayload } from '../types';
 /**
  * Checks if the layer id is already taken in one of the maps.
  * @param state The WebMapState
@@ -7,14 +9,84 @@ import { WebMapState, SetMapDimensionPayload, SetMapPresetPayload } from './type
  */
 export declare const checkIfMapLayerIdIsAlreadyTaken: (state: WebMapState, layerId: string) => boolean;
 export declare const initialState: WebMapState;
-export declare const slice: any;
-export declare const actions: any, reducer: any;
-export declare type MapActions = SetMapDimension | SetMapPreset;
-export interface SetMapPreset {
-    type: `mapReducer/setMapPreset`;
-    payload: SetMapPresetPayload;
-}
-export interface SetMapDimension {
-    type: `mapReducer/mapChangeDimension`;
-    payload: SetMapDimensionPayload;
-}
+export declare const slice: import("@reduxjs/toolkit").Slice<WebMapState, {
+    registerMap: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: {
+        payload: {
+            mapId: string;
+        };
+        type: string;
+    }) => void;
+    unregisterMap: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: {
+        payload: {
+            mapId: string;
+        };
+        type: string;
+    }) => void;
+    setBbox: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetBboxPayload>) => void;
+    mapUpdateAllMapDimensions: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<UpdateAllMapDimensionsPayload>) => void;
+    mapStartAnimation: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetMapAnimationStartPayload>) => void;
+    mapStopAnimation: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetMapAnimationStopPayload>) => void;
+    setTimeSliderScale: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetTimeSliderScalePayload>) => void;
+    setTimeStep: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetTimeStepPayload>) => void;
+    setAnimationStartTime: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetAnimationStartTimePayload>) => void;
+    setAnimationEndTime: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetAnimationEndTimePayload>) => void;
+    setSelectedFeature: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetSelectedFeaturePayload>) => void;
+    setAnimationDelay: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetAnimationDelayPayload>) => void;
+    setAnimationInterval: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetAnimationIntervalPayload>) => void;
+    layerMoveLayer: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<MoveLayerPayload>) => void;
+    setActiveLayerId: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetActiveLayerIdPayload>) => void;
+    setTimeSliderCenterTime: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetTimeSliderCenterTimePayload>) => void;
+    setTimeSliderSecondsPerPx: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetTimeSliderSecondsPerPxPayload>) => void;
+    setTimeSliderDataScaleToSecondsPerPx: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetTimeSliderDataScaleToSecondsPerPxPayload>) => void;
+    toggleAutoUpdate: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleAutoUpdatePayload>) => void;
+    toggleTimestepAuto: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleTimestepAutoPayload>) => void;
+    toggleTimeSliderHover: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleTimeSliderHoverPayload>) => void;
+    toggleTimeSliderIsVisible: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleTimeSliderIsVisiblePayload>) => void;
+    toggleZoomControls: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleZoomControlsPayload>) => void;
+    setMapPinLocation: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<MapPinLocationPayload>) => void;
+    setDisableMapPin: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<DisableMapPinPayload>) => void;
+    toggleMapPinIsVisible: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<ToggleMapPinIsVisiblePayload>) => void;
+    setActiveMapPresetId: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetActiveMapPresetPayload>) => void;
+    setIsMapPresetLoading: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetIsMapPresetLoadingPayload>) => void;
+    setHasMapPresetChanges: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetIsMapPresetHasChangesPayload>) => void;
+    setMapPresetError: (draft: import("immer/dist/internal").WritableDraft<WebMapState>, action: PayloadAction<SetMapPresetErrorPayload>) => void;
+}, "mapReducer">;
+export declare const mapActions: {
+    setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<import("./types").SetMapPresetPayload, string>;
+    mapChangeDimension: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<import("./types").SetMapDimensionPayload, string>;
+    registerMap: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+        mapId: string;
+    }, string>;
+    unregisterMap: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+        mapId: string;
+    }, string>;
+    setBbox: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetBboxPayload, string>;
+    mapUpdateAllMapDimensions: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<UpdateAllMapDimensionsPayload, string>;
+    mapStartAnimation: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetMapAnimationStartPayload, string>;
+    mapStopAnimation: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetMapAnimationStopPayload, string>;
+    setTimeSliderScale: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetTimeSliderScalePayload, string>;
+    setTimeStep: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetTimeStepPayload, string>;
+    setAnimationStartTime: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetAnimationStartTimePayload, string>;
+    setAnimationEndTime: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetAnimationEndTimePayload, string>;
+    setSelectedFeature: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetSelectedFeaturePayload, string>;
+    setAnimationDelay: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetAnimationDelayPayload, string>;
+    setAnimationInterval: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetAnimationIntervalPayload, string>;
+    layerMoveLayer: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<MoveLayerPayload, string>;
+    setActiveLayerId: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetActiveLayerIdPayload, string>;
+    setTimeSliderCenterTime: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetTimeSliderCenterTimePayload, string>;
+    setTimeSliderSecondsPerPx: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetTimeSliderSecondsPerPxPayload, string>;
+    setTimeSliderDataScaleToSecondsPerPx: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetTimeSliderDataScaleToSecondsPerPxPayload, string>;
+    toggleAutoUpdate: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ToggleAutoUpdatePayload, string>;
+    toggleTimestepAuto: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ToggleTimestepAutoPayload, string>;
+    toggleTimeSliderHover: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ToggleTimeSliderHoverPayload, string>;
+    toggleTimeSliderIsVisible: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ToggleTimeSliderIsVisiblePayload, string>;
+    toggleZoomControls: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ToggleZoomControlsPayload, string>;
+    setMapPinLocation: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<MapPinLocationPayload, string>;
+    setDisableMapPin: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<DisableMapPinPayload, string>;
+    toggleMapPinIsVisible: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ToggleMapPinIsVisiblePayload, string>;
+    setActiveMapPresetId: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetActiveMapPresetPayload, string>;
+    setIsMapPresetLoading: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetIsMapPresetLoadingPayload, string>;
+    setHasMapPresetChanges: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetIsMapPresetHasChangesPayload, string>;
+    setMapPresetError: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<SetMapPresetErrorPayload, string>;
+};
+export declare const reducer: import("@reduxjs/toolkit").Reducer<WebMapState, import("@reduxjs/toolkit").AnyAction>;

package/lib/store/mapStore/map/sagas.d.ts

@@ -1,7 +1,10 @@
 import { SagaIterator } from 'redux-saga';
 import { Moment } from 'moment';
-import { actions as mapActions } from './reducer';
-import { DeleteLayer, Layer, UpdateLayerInfo } from '../layers/types';
+import { mapActions } from '.';
+import { layerActions } from '../layers';
+import { Layer } from '../layers/types';
+import { genericActions } from '../../generic';
+import { uiActions } from '../../ui';
 export declare const generateTimeList: (start: Moment, end: Moment, interval: number) => {
     name: string;
     value: string;
@@ -9,11 +12,14 @@ export declare const generateTimeList: (start: Moment, end: Moment, interval: nu
 export declare function updateMapDraw(mapId: string, draw: unknown): void;
 export declare function startAnimationSaga({ payload, }: ReturnType<typeof mapActions.mapStartAnimation>): Generator;
 export declare function stopAnimationSaga({ payload, }: ReturnType<typeof mapActions.mapStopAnimation>): Generator;
-export declare function deleteLayerSaga({ payload }: DeleteLayer): SagaIterator;
+export declare function deleteLayerSaga({ payload, }: ReturnType<typeof layerActions.layerDelete>): SagaIterator;
 export declare function updateAnimation(mapId: string, maxValue: string): SagaIterator;
-export declare function setLayerDimensionsSaga({ payload, }: UpdateLayerInfo): SagaIterator;
+export declare function setLayerDimensionsSaga({ payload, }: ReturnType<typeof layerActions.onUpdateLayerInformation>): SagaIterator;
 export declare function toggleAutoUpdateSaga({ payload, }: ReturnType<typeof mapActions.toggleAutoUpdate>): SagaIterator;
 export declare function handleBaseLayersSaga(mapId: string, baseLayers: Layer[]): SagaIterator;
 export declare function setMapPresetSaga({ payload, }: ReturnType<typeof mapActions.setMapPreset>): SagaIterator;
+export declare type SupportedMapPresetChangeActions = ReturnType<typeof layerActions.setBaseLayers> | ReturnType<typeof layerActions.layerDelete> | ReturnType<typeof layerActions.addLayer> | ReturnType<typeof layerActions.layerChangeEnabled> | ReturnType<typeof layerActions.layerChangeName> | ReturnType<typeof layerActions.layerChangeStyle> | ReturnType<typeof layerActions.layerChangeOpacity> | ReturnType<typeof layerActions.layerChangeDimension> | ReturnType<typeof mapActions.layerMoveLayer> | ReturnType<typeof mapActions.setActiveLayerId> | ReturnType<typeof mapActions.toggleAutoUpdate> | ReturnType<typeof mapActions.mapStartAnimation> | ReturnType<typeof mapActions.mapStopAnimation> | ReturnType<typeof mapActions.toggleTimeSliderIsVisible> | ReturnType<typeof mapActions.setTimeStep> | ReturnType<typeof mapActions.setAnimationDelay> | ReturnType<typeof mapActions.toggleTimestepAuto> | ReturnType<typeof uiActions.setActiveMapIdForDialog> | ReturnType<typeof uiActions.setToggleOpenDialog> | ReturnType<typeof genericActions.setBbox>;
+export declare const mapPresetChangeActions: (string | import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<import("./types").SetMapAnimationStopPayload, string> | import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<import("../../ui/types").UIToggleDialogPayload, string>)[];
+export declare function checkMapPresetForChangesSaga(action: SupportedMapPresetChangeActions): SagaIterator;
 export declare function rootSaga(): SagaIterator;
 export default rootSaga;