@opengeoweb/store 5.2.1 → 6.0.1

package/src/store/layerSelect/localStorage.d.ts

@@ -0,0 +1,3 @@
+import { UserAddedServices } from './types';
+export declare const getUserAddedServices: () => UserAddedServices;
+export declare const setUserAddedServices: (services: UserAddedServices) => void;

package/src/store/layerSelect/localStorage.spec.d.ts

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

package/src/store/layerSelect/reducer.d.ts

@@ -0,0 +1,21 @@
+import { PayloadAction, Draft } from '@reduxjs/toolkit';
+import { uiTypes } from '../ui';
+import { DisableActiveServicePayload, EnableActiveServicePayload, EnableOnlyOneKeywordPayload, LayerSelectRemoveServicePayload, LayerSelectStoreType, SetAllServicesEnabledPayload, SetActiveLayerInfoPayload, SetSearchFilterPayload, ToggleKeywordsPayload, Filter, ActiveServiceObject, ToggleServicePopupPayload, ServicePopupObject } from './types';
+export declare const layerSelectFilterAdapter: import("@reduxjs/toolkit").EntityAdapter<Filter>;
+export declare const layerSelectActiveServicesAdapter: import("@reduxjs/toolkit").EntityAdapter<ActiveServiceObject>;
+export declare const initialServicePopupState: ServicePopupObject;
+export declare const initialState: LayerSelectStoreType;
+export declare const reducer: import("redux").Reducer<LayerSelectStoreType, import("redux").AnyAction>;
+export declare const layerSelectActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    setSearchFilter: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<SetSearchFilterPayload>) => void;
+    setAllServicesEnabled: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<SetAllServicesEnabledPayload>) => void;
+    closeServicePopupOpen: (draft: Draft<LayerSelectStoreType>) => void;
+    toggleServicePopup: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<ToggleServicePopupPayload>) => void;
+    layerSelectRemoveService: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<LayerSelectRemoveServicePayload>) => void;
+    enableActiveService: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<EnableActiveServicePayload>) => void;
+    disableActiveService: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<DisableActiveServicePayload>) => void;
+    toggleFilter: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<ToggleKeywordsPayload>) => void;
+    enableOnlyOneFilter: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<EnableOnlyOneKeywordPayload>) => void;
+    setActiveLayerInfo: (draft: Draft<LayerSelectStoreType>, action: PayloadAction<SetActiveLayerInfoPayload>) => void;
+}, uiTypes.DialogTypes.LayerSelect>;
+export declare type LayerSelectActions = ReturnType<typeof layerSelectActions.setSearchFilter> | ReturnType<typeof layerSelectActions.layerSelectRemoveService> | ReturnType<typeof layerSelectActions.enableActiveService> | ReturnType<typeof layerSelectActions.disableActiveService> | ReturnType<typeof layerSelectActions.toggleFilter> | ReturnType<typeof layerSelectActions.enableOnlyOneFilter> | ReturnType<typeof layerSelectActions.setActiveLayerInfo>;

package/src/store/layerSelect/reducer.spec.d.ts

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

package/src/store/layerSelect/sagas.d.ts

@@ -0,0 +1,10 @@
+import { SagaIterator } from 'redux-saga';
+import { serviceActions } from '../mapStore/service/reducer';
+import { layerSelectActions, LayerSelectActions } from './reducer';
+import { uiActions } from '../ui';
+export declare function layerSelectCloseInfoDialogSaga({ type, payload, }: ReturnType<typeof uiActions.setToggleOpenDialog | typeof uiActions.setActiveMapIdForDialog | typeof layerSelectActions.disableActiveService | typeof layerSelectActions.toggleFilter | typeof layerSelectActions.setSearchFilter>): SagaIterator;
+export declare function layerSelectRemoveServiceSaga(capturedAction: LayerSelectActions): SagaIterator;
+export declare function addServiceToLocalStorageSaga({ payload, }: ReturnType<typeof serviceActions.serviceSetLayers>): void;
+export declare function removeServiceFromLocalStorageSaga({ payload, }: ReturnType<typeof serviceActions.mapStoreRemoveService>): void;
+export declare function rootSaga(): SagaIterator;
+export default rootSaga;

package/src/store/layerSelect/sagas.spec.d.ts

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

package/src/store/layerSelect/selectors.d.ts

@@ -0,0 +1,157 @@
+import type { CoreAppStore } from '../types';
+import { LayerSelectStoreType, ActiveLayerObject, ActiveServiceObjectEntities, ServicePopupObject } from './types';
+/**
+ * Returns search filter string
+ *
+ * Example getSearchFilter(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: string
+ */
+export declare const getSearchFilter: ((state: {
+    syncronizationGroupStore?: import("../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../ui/types").UIStoreType | undefined;
+    webmap?: import("../mapStore/types").WebMapState | undefined;
+    services?: import("../mapStore/types").ServiceState | undefined;
+    layers?: import("../mapStore/types").LayerState | undefined;
+    layerSelect?: LayerSelectStoreType | undefined;
+}) => string) & import("reselect").OutputSelectorFields<(args_0: LayerSelectStoreType) => string, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Returns active services array
+ *
+ * Example getActiveServices(store);
+ * @param {object} store store: object - store object
+ * @returns {ActiveServiceObjectEntities} returnType: ActiveServiceObjectEntitiesobject of active services
+ */
+export declare const getActiveServices: (store: CoreAppStore) => ActiveServiceObjectEntities;
+export declare const getActiveServicesDictionary: (state: CoreAppStore) => import("@reduxjs/toolkit").Dictionary<import("./types").ActiveServiceObject>, getActiveServiceById: (state: CoreAppStore, id: import("@reduxjs/toolkit").EntityId) => import("./types").ActiveServiceObject | undefined;
+/**
+ * Returns all ids of enabled services
+ *
+ * Example getEnabledServiceIds(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: array of service ids that are enabled
+ */
+export declare const getEnabledServiceIds: ((state: {
+    syncronizationGroupStore?: import("../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../ui/types").UIStoreType | undefined;
+    webmap?: import("../mapStore/types").WebMapState | undefined;
+    services?: import("../mapStore/types").ServiceState | undefined;
+    layers?: import("../mapStore/types").LayerState | undefined;
+    layerSelect?: LayerSelectStoreType | undefined;
+}) => string[]) & import("reselect").OutputSelectorFields<(args_0: LayerSelectStoreType) => string[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Returns all ids of checked keywords
+ *
+ * Example getCheckedKeywordIds(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: array of keyword ids that are checked
+ */
+export declare const getCheckedFilterIds: ((state: {
+    syncronizationGroupStore?: import("../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../ui/types").UIStoreType | undefined;
+    webmap?: import("../mapStore/types").WebMapState | undefined;
+    services?: import("../mapStore/types").ServiceState | undefined;
+    layers?: import("../mapStore/types").LayerState | undefined;
+    layerSelect?: LayerSelectStoreType | undefined;
+}) => string[]) & import("reselect").OutputSelectorFields<(args_0: LayerSelectStoreType) => string[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Returns ids of all keywords
+ *
+ * Example getAllKeywordIds(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: array of all keyword ids
+ */
+export declare const getAllFilterIds: (store: CoreAppStore) => string[];
+/**
+ * Returns all filters
+ *
+ * Example getAllFilters(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: array of all filters
+ */
+export declare const getAllFilters: (state: CoreAppStore) => import("./types").Filter[];
+/**
+ * Returns if all keywords are checked
+ *
+ * Example isAllKeywordsChecked(store);
+ * @param {object} store store: object - store object
+ * @returns {array} returnType: boolean if all keywords are checked
+ */
+export declare const isAllFiltersChecked: ((state: {
+    syncronizationGroupStore?: import("../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../ui/types").UIStoreType | undefined;
+    webmap?: import("../mapStore/types").WebMapState | undefined;
+    services?: import("../mapStore/types").ServiceState | undefined;
+    layers?: import("../mapStore/types").LayerState | undefined;
+    layerSelect?: LayerSelectStoreType | undefined;
+}) => boolean) & import("reselect").OutputSelectorFields<(args_0: LayerSelectStoreType) => boolean, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Gets a KeywordObject by its id
+ *
+ * Example: keywordObject = getKeywordObjectById(store, 'keywordId')
+ * @param {object} store object from which the keyword state will be extracted
+ * @param {string} filterId Id of the keyword
+ * @returns {object} object containing keyword information (id, amount, amountVisible, checked)
+ */
+export declare const getFilterById: (state: CoreAppStore, id: import("@reduxjs/toolkit").EntityId) => import("./types").Filter | undefined;
+/**
+ * Returns the active layer info
+ *
+ * Example getActiveLayerInfo(store);
+ * @param {object} store store: object - store object
+ * @returns {object} returnType: ActiveLayerObject
+ */
+export declare const getActiveLayerInfo: ((state: {
+    syncronizationGroupStore?: import("../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../ui/types").UIStoreType | undefined;
+    webmap?: import("../mapStore/types").WebMapState | undefined;
+    services?: import("../mapStore/types").ServiceState | undefined;
+    layers?: import("../mapStore/types").LayerState | undefined;
+    layerSelect?: LayerSelectStoreType | undefined;
+}) => ActiveLayerObject) & import("reselect").OutputSelectorFields<(args_0: LayerSelectStoreType) => ActiveLayerObject, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Returns a filtered active layer object based on the given filter settings
+ * Example: layerSelectSelectors.getFilteredLayers(store, filteredSettings);
+ * @param {object} store store: object - object from which the service state will be extracted
+ * @returns {array} returnType: ActiveLayerObject - an array of all filtered activelayers
+ */
+export declare const getFilteredLayers: ((state: {
+    syncronizationGroupStore?: import("../generic/synchronizationGroups/types").SynchronizationGroupState | undefined;
+    ui?: import("../ui/types").UIStoreType | undefined;
+    webmap?: import("../mapStore/types").WebMapState | undefined;
+    services?: import("../mapStore/types").ServiceState | undefined;
+    layers?: import("../mapStore/types").LayerState | undefined;
+    layerSelect?: LayerSelectStoreType | undefined;
+}) => ActiveLayerObject[]) & import("reselect").OutputSelectorFields<(args_0: string[], args_1: import("../mapStore/types").Services, args_2: string[], args_3: boolean, args_4: string) => ActiveLayerObject[], {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+/**
+ * Returns service popup details
+ *
+ * Example getActiveServices(store, 'server-id');
+ * @param {object} store store: object - store object
+ * @returns {object} returnType: object of active service
+ */
+export declare const getServicePopupDetails: (store: CoreAppStore) => ServicePopupObject;

package/src/store/layerSelect/selectors.spec.d.ts

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

package/src/store/layerSelect/types.d.ts

@@ -0,0 +1,95 @@
+import { EntityState } from '@reduxjs/toolkit';
+import type { ServiceLayer, ServiceScope } from '../mapStore/types';
+export declare type NoIdService = Omit<LayerSelectService, 'id'>;
+export interface UserAddedServices {
+    [url: string]: NoIdService;
+}
+export interface LayerSelectService {
+    name: string;
+    url: string;
+    id: string;
+    scope?: ServiceScope;
+    abstract?: string;
+}
+export interface ActiveLayerObject extends ServiceLayer {
+    serviceName: string;
+}
+export interface ActiveServiceObject {
+    serviceId?: string;
+    serviceName?: string;
+    serviceUrl?: string;
+    abstract?: string;
+    enabled?: boolean;
+    filterIds?: string[];
+    scope?: ServiceScope;
+    isLoading?: boolean;
+}
+export declare enum FilterType {
+    Keyword = "keywords",
+    Group = "groups"
+}
+export interface Filter {
+    id: string;
+    name: string;
+    amount?: number;
+    amountVisible?: number;
+    checked?: boolean;
+    type: FilterType;
+}
+export declare type ActiveServiceObjectEntities = Record<string, ActiveServiceObject>;
+export declare type Filters = EntityState<Filter>;
+export declare type ActiveServiceType = EntityState<ActiveServiceObject>;
+export interface FiltersType {
+    searchFilter: string;
+    activeServices: ActiveServiceType;
+    filters: Filters;
+}
+export declare type PopupVariant = 'edit' | 'add' | 'save' | 'show';
+export interface ServicePopupObject {
+    isOpen: boolean;
+    variant: PopupVariant;
+    url?: string;
+    serviceId?: string;
+}
+export interface LayerSelectStoreType {
+    filters: FiltersType;
+    allServicesEnabled: boolean;
+    activeLayerInfo: ActiveLayerObject;
+    servicePopup: ServicePopupObject;
+}
+export interface LayerSelectModuleState {
+    layerSelect?: LayerSelectStoreType;
+}
+export interface SetSearchFilterPayload {
+    filterText: string;
+}
+export interface SetAllServicesEnabledPayload {
+    allServicesEnabled: boolean;
+}
+export interface ToggleServicePopupPayload {
+    url?: string;
+    variant: PopupVariant;
+    serviceId?: string;
+    isOpen: boolean;
+}
+export interface EnableActiveServicePayload {
+    serviceId: string;
+    filters: string[];
+}
+export interface DisableActiveServicePayload {
+    serviceId: string;
+    filters: string[];
+}
+export interface LayerSelectRemoveServicePayload {
+    serviceId: string;
+    serviceUrl?: string;
+}
+export interface ToggleKeywordsPayload {
+    filterIds: string[];
+}
+export interface EnableOnlyOneKeywordPayload {
+    filterId: string;
+}
+export interface SetActiveLayerInfoPayload {
+    layer: ActiveLayerObject;
+}

package/src/store/layerSelect/utils.d.ts

@@ -0,0 +1,6 @@
+import { EntityAdapter, Draft } from '@reduxjs/toolkit';
+import { Filter, FilterType, LayerSelectStoreType } from './types';
+import { serviceTypes } from '../mapStore';
+export declare const getFilterId: (filterType: FilterType, filterName: string) => string;
+export declare const produceFilters: (filterNames: string[], filterType: FilterType, draft: Draft<LayerSelectStoreType>, layerSelectFilterAdapter: EntityAdapter<Filter>) => void;
+export declare const filterLayersFromService: (serviceId: string, services: serviceTypes.Services, filterIds: string[], allFiltersActive: boolean, searchString: string) => serviceTypes.ServiceLayer[];

package/src/store/layerSelect/utils.spec.d.ts

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

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

@@ -0,0 +1,4 @@
+import { Egg } from '@redux-eggs/core';
+import { Store } from '@reduxjs/toolkit';
+import { WebMapStateModuleState } from './types';
+export declare const mapStoreModuleConfig: Egg<Store<WebMapStateModuleState>>;

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

@@ -0,0 +1,76 @@
+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 * as storeTestSettings from './storeTestSettings';
+export * from './config';

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

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

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