@opengeoweb/store 5.2.1 → 6.0.1

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 {};

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

@@ -0,0 +1,149 @@
+import { Action } from '@reduxjs/toolkit';
+import { FeatureCollection } from 'geojson';
+import type { Dimension, UpdateAllMapDimensionsPayload } from '../map/types';
+import type { SyncGroupActionOrigin } from '../../generic/synchronizationGroups/types';
+export declare enum LayerType {
+    mapLayer = "mapLayer",
+    baseLayer = "baseLayer",
+    overLayer = "overLayer"
+}
+export declare enum LayerStatus {
+    default = "default",
+    error = "error"
+}
+export declare enum LayerActionOrigin {
+    layerManager = "layerManager",
+    wmsLoader = "WMSLayerTreeConnect",
+    ReactMapViewParseLayer = "ReactMapViewParseLayer",
+    setLayerDimensionSaga = "setLayerDimensionSaga",
+    toggleAutoUpdateSaga = "toggleAutoUpdateSaga",
+    unregisterMapSaga = "unregisterMapSaga"
+}
+/**
+ * ReduxLayer is used to reflect the shape of the layer in the redux layers store.
+ * It is a subset of Layer since some properties like the styles list now come from the service store.
+ */
+export interface ReduxLayer {
+    id?: string;
+    mapId?: string;
+    service?: string;
+    name?: string;
+    title?: string;
+    enabled?: boolean;
+    style?: string;
+    dimensions?: Dimension[];
+    opacity?: number;
+    type?: string;
+    layerType?: LayerType;
+    status?: LayerStatus;
+    format?: string;
+    geojson?: FeatureCollection;
+    selectedFeatureIndex?: number;
+    acceptanceTimeInMinutes?: number;
+}
+/**
+ * Layer is used to define a layer with all its possible properties.
+ */
+export interface Layer extends ReduxLayer {
+    headers?: Headers[];
+}
+export interface AvailableBaseLayersType {
+    byId: Record<string, ReduxLayer>;
+    allIds: string[];
+}
+export interface LayerState {
+    byId: Record<string, ReduxLayer>;
+    allIds: string[];
+    availableBaseLayers: AvailableBaseLayersType;
+}
+export interface LayerPayload {
+    layerId: string;
+    origin?: string;
+}
+export interface SetLayersPayload {
+    mapId: string;
+    layers: ReduxLayer[];
+    origin?: string;
+}
+export interface SetBaseLayersPayload {
+    mapId: string;
+    layers: ReduxLayer[];
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.layerActions;
+}
+export interface SetLayerDimensionsPayload extends LayerPayload {
+    origin: string;
+    dimensions: Dimension[];
+}
+export interface SetLayerOpacityPayload extends LayerPayload {
+    opacity: number;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerNamePayload extends LayerPayload {
+    name: string;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerEnabledPayload extends LayerPayload {
+    enabled: boolean;
+    mapId?: string;
+    origin?: LayerActionOrigin;
+}
+export interface SetLayerDimensionPayload extends LayerPayload {
+    dimension: Dimension;
+    service?: string;
+    origin?: LayerActionOrigin;
+    mapId?: string;
+}
+export interface SetLayerStylePayload extends LayerPayload {
+    style: string;
+    mapId?: string;
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.layerActions;
+}
+export interface SetLayerGeojsonPayload extends LayerPayload {
+    geojson: FeatureCollection;
+}
+export interface DeleteLayerPayload extends LayerPayload {
+    mapId: string;
+    layerIndex: number;
+    origin?: LayerActionOrigin | SyncGroupActionOrigin.delete;
+}
+export interface AddLayerPayload {
+    mapId: string;
+    layerId: string;
+    layer: Layer;
+    origin: string;
+}
+export interface AddBaseLayerPayload {
+    mapId: string;
+    layerId: string;
+    layer: Layer;
+    origin?: string;
+}
+export interface AddAvailableBaseLayerPayload {
+    layer: Layer;
+    origin?: string;
+}
+export interface AddAvailableBaseLayersPayload {
+    layers: ReduxLayer[];
+    origin?: string;
+}
+export interface SetAvailableBaseLayersPayload extends AddAvailableBaseLayersPayload {
+    mapId: string;
+}
+export interface ErrorLayerPayload extends LayerPayload {
+    error: Error;
+}
+export interface UpdateLayerInfoPayload {
+    origin: string;
+    mapDimensions?: UpdateAllMapDimensionsPayload;
+    layerStyle?: SetLayerStylePayload;
+    layerDimensions?: SetLayerDimensionsPayload;
+}
+export interface UpdateLayerInfo extends Action {
+    type: `layerReducer/onUpdateLayerInformation`;
+    payload: UpdateLayerInfoPayload;
+}
+export interface SetSelectedFeaturePayload extends LayerPayload {
+    selectedFeatureIndex: number;
+}

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

@@ -0,0 +1,18 @@
+import { Draft } from '@reduxjs/toolkit';
+import { WMJSDimension } from '@opengeoweb/webmap';
+import type { Dimension } from '../types';
+import type { LayerState } from './types';
+export declare const isActionLayerSynced: (state: LayerState, layerIdFromAction: string, dimension: Dimension) => boolean;
+export declare const produceDimensionActionForMapLayer: (layerDim: Dimension, wmjsDimension: WMJSDimension, newDimension: Dimension) => Dimension;
+/**
+ * For the given dimension, it creates a new draft state for all other (linked or synced) layers inside the map.
+ * @param draft
+ * @param dimension
+ * @param mapId
+ */
+export declare const produceDraftStateForAllLayersForDimensionWithinMap: (draft: Draft<LayerState>, dimension: Dimension, mapId: string, layerIdFromAction: string) => void;
+/**
+ * Returns the list of dimensions without the time dimension
+ * @param dimensions Dimension[]
+ */
+export declare const filterNonTimeDimensions: (dimensions: Dimension[]) => Dimension[];

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

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

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

@@ -0,0 +1,8 @@
+import type { 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").ActionCreatorWithPayload<SetMapDimensionPayload, string>;
+export declare const setMapPreset: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetMapPresetPayload, string>;

package/src/store/mapStore/map/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultAnimationDelayAtStart = 250;
+export declare const defaultDelay = 1000;
+export declare const defaultTimeStep = 60;
+export declare const defaultSecondsPerPx = 80;
+export declare const defaultTimeSpan: number;
+export declare const IS_LEGEND_OPEN_BY_DEFAULT = false;

package/src/store/mapStore/map/defaultLayers.d.ts

@@ -0,0 +1,15 @@
+import { LayerType } from '../types';
+export declare const baseLayerGrey: {
+    id: string;
+    name: string;
+    type: string;
+    layerType: LayerType;
+};
+export declare const overLayer: {
+    service: string;
+    name: string;
+    format: string;
+    enabled: boolean;
+    id: string;
+    layerType: LayerType;
+};

package/src/store/mapStore/map/enums.d.ts

@@ -0,0 +1,23 @@
+export declare enum Scale {
+    Minutes5 = 0,
+    Hour = 1,
+    Hours3 = 2,
+    Hours6 = 3,
+    Day = 4,
+    Week = 5,
+    Month = 6,
+    Year = 7
+}
+export declare enum AnimationLength {
+    Minutes15 = 15,
+    Minutes30 = 30,
+    Hours1 = 60,
+    Hours2 = 120,
+    Hours3 = 180,
+    Hours6 = 360,
+    Hours12 = 720,
+    Hours24 = 1440
+}
+export declare enum MapActionOrigin {
+    map = "map"
+}