@opengeoweb/store 19.0.0 → 19.1.1

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from './store';

package/dist/src/store/common/auth/index.d.ts

@@ -0,0 +1,3 @@
+export { authReducer, authActions } from './reducer';
+export * as authSelectors from './selectors';
+export type * as authTypes from './types';

package/dist/src/store/common/auth/reducer.d.ts

@@ -0,0 +1,14 @@
+import type { PayloadAction, Draft } from '@reduxjs/toolkit';
+import type { AuthStore, LoginPayload, SetAuthPayload } from './types';
+export declare const initialState: AuthStore;
+export declare const slice: import("@reduxjs/toolkit").Slice<AuthStore, {
+    setCredentials: (draft: Draft<AuthStore>, action: PayloadAction<SetAuthPayload>) => void;
+    login: (draft: Draft<AuthStore>, action: PayloadAction<LoginPayload>) => void;
+    logout: (draft: Draft<AuthStore>) => void;
+}, "auth", "auth", import("@reduxjs/toolkit").SliceSelectors<AuthStore>>;
+export declare const authReducer: import("redux").Reducer<AuthStore>, authActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    setCredentials: (draft: Draft<AuthStore>, action: PayloadAction<SetAuthPayload>) => void;
+    login: (draft: Draft<AuthStore>, action: PayloadAction<LoginPayload>) => void;
+    logout: (draft: Draft<AuthStore>) => void;
+}, "auth">;
+export type AuthActions = ReturnType<typeof authActions.setCredentials> | ReturnType<typeof authActions.login> | ReturnType<typeof authActions.logout>;

package/dist/src/store/common/auth/selectors.d.ts

@@ -0,0 +1,87 @@
+import type { TypedUseSelectorHook } from 'react-redux';
+import type { AuthStore } from './types';
+import type { CoreAppStore } from '../../types';
+import type { CommonModuleState } from '../types';
+export declare const useAppSelector: TypedUseSelectorHook<CommonModuleState>;
+export declare const getAuthStore: (store: CoreAppStore) => AuthStore;
+/**
+ * Gets whether the user is logged in
+ *
+ * @param {object} store store object from which the auth state will be extracted
+ * @returns {boolean} true if user is logged in
+ */
+export declare const getIsLoggedIn: ((state: CoreAppStore) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: AuthStore) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: AuthStore) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: CoreAppStore) => AuthStore];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets the current auth credentials
+ *
+ * @param {object} store store object from which the auth state will be extracted
+ * @returns {Credentials | undefined} the auth credentials or undefined
+ */
+export declare const getCredentials: ((state: CoreAppStore) => import("./types").Credentials | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: AuthStore) => import("./types").Credentials | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: AuthStore) => import("./types").Credentials | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").Credentials | undefined;
+    dependencies: [(store: CoreAppStore) => AuthStore];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+/**
+ * Gets the current role
+ *
+ * @param {object} store store object from which the auth state will be extracted
+ * @returns {Role[] | undefined} the current role
+ */
+export declare const getCurrentRoles: ((state: CoreAppStore) => import("./types").Role[] | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: AuthStore) => import("./types").Role[] | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: AuthStore) => import("./types").Role[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").Role[] | undefined;
+    dependencies: [(store: CoreAppStore) => AuthStore];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/src/store/common/auth/types.d.ts

@@ -0,0 +1,22 @@
+export interface Role {
+    name: string;
+    title: string;
+}
+export interface Credentials {
+    username: string;
+    roles?: Role[];
+    token: string;
+    refresh_token: string;
+    expires_at?: number;
+    has_connection_issue?: boolean;
+}
+export interface AuthStore {
+    isLoggedIn: boolean;
+    credentials?: Credentials;
+}
+export interface SetAuthPayload {
+    credentials: Credentials;
+}
+export interface LoginPayload {
+    isLoggedIn: boolean;
+}

package/dist/src/store/common/index.d.ts

@@ -0,0 +1,81 @@
+import type { AuthActions } from './auth/reducer';
+export type CommonActions = AuthActions;
+export declare const commonActions: {
+    setCredentials: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./auth/types").SetAuthPayload, "auth/setCredentials">;
+    login: import("@reduxjs/toolkit").ActionCreatorWithPayload<import("./auth/types").LoginPayload, "auth/login">;
+    logout: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"auth/logout">;
+};
+export declare const commonSelectors: {
+    useAppSelector: import("react-redux").TypedUseSelectorHook<import("./types").CommonModuleState>;
+    getAuthStore: (store: import("..").CoreAppStore) => import("./auth/types").AuthStore;
+    getIsLoggedIn: ((state: import("..").CoreAppStore) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("./auth/types").AuthStore) => boolean;
+        memoizedResultFunc: ((resultFuncArgs_0: import("./auth/types").AuthStore) => boolean) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => boolean;
+        dependencies: [(store: import("..").CoreAppStore) => import("./auth/types").AuthStore];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    };
+    getCredentials: ((state: import("..").CoreAppStore) => import("./auth/types").Credentials | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("./auth/types").AuthStore) => import("./auth/types").Credentials | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: import("./auth/types").AuthStore) => import("./auth/types").Credentials | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("./auth/types").Credentials | undefined;
+        dependencies: [(store: import("..").CoreAppStore) => import("./auth/types").AuthStore];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    };
+    getCurrentRoles: ((state: import("..").CoreAppStore) => import("./auth/types").Role[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("./auth/types").AuthStore) => import("./auth/types").Role[] | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: import("./auth/types").AuthStore) => import("./auth/types").Role[] | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("./auth/types").Role[] | undefined;
+        dependencies: [(store: import("..").CoreAppStore) => import("./auth/types").AuthStore];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    };
+};
+export declare const commonReducers: import("redux").Reducer<{
+    auth: import("./auth/types").AuthStore;
+}, import("redux").UnknownAction, Partial<{
+    auth: import("./auth/types").AuthStore | undefined;
+}>>;
+export type * as commonTypes from './auth/types';
+export type * from './types';

package/dist/src/store/common/listener.d.ts

@@ -0,0 +1,2 @@
+import type { CommonModuleState } from '.';
+export declare const commonListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<CommonModuleState, import("redux-thunk").ThunkDispatch<CommonModuleState, unknown, import("redux").UnknownAction>, unknown>;

package/dist/src/store/common/types.d.ts

@@ -0,0 +1,6 @@
+import type { AuthStore } from './auth/types';
+export interface CommonModuleState {
+    common?: {
+        auth: AuthStore;
+    };
+}

package/dist/src/store/drawingTool/index.d.ts

@@ -0,0 +1,4 @@
+export { drawingToolActions, drawingToolReducer } from './reducer';
+export * as drawingToolSelectors from './selectors';
+export type { DrawToolItem, DrawtoolModuleStore } from './reducer';
+export * from './utils';

package/dist/src/store/drawingTool/listener.d.ts

@@ -0,0 +1,3 @@
+import type { DrawtoolModuleStore } from './reducer';
+import type { WebMapStateModuleState } from '../map';
+export declare const drawingToolListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<DrawtoolModuleStore & WebMapStateModuleState, import("redux-thunk").ThunkDispatch<DrawtoolModuleStore & WebMapStateModuleState, unknown, import("redux").UnknownAction>, unknown>;

package/dist/src/store/drawingTool/reducer.d.ts

@@ -0,0 +1,45 @@
+import type { PayloadAction, Draft, EntityState } from '@reduxjs/toolkit';
+import type { DrawMode, MapDrawToolOptions } from '@opengeoweb/webmap-react';
+export interface DrawToolItem {
+    drawToolId: string;
+    geoJSONLayerId: string;
+    activeDrawModeId: string;
+    drawModes: DrawMode[];
+    shouldAllowMultipleShapes: boolean;
+    geoJSONIntersectionLayerId?: string;
+    geoJSONIntersectionBoundsLayerId?: string;
+}
+export type DrawingToolState = EntityState<DrawToolItem, string>;
+export interface DrawtoolModuleStore {
+    drawingtools?: DrawingToolState;
+}
+export declare const drawAdapter: import("@reduxjs/toolkit").EntityAdapter<DrawToolItem, string>;
+export declare const initialState: DrawingToolState;
+export declare const drawingToolReducer: import("redux").Reducer<DrawingToolState>, drawingToolActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    registerDrawTool: (draft: Draft<DrawingToolState>, action: PayloadAction<MapDrawToolOptions & {
+        drawToolId: string;
+        mapId?: string;
+    }>) => void;
+    unregisterDrawTool: (draft: Draft<DrawingToolState>, action: PayloadAction<{
+        drawToolId: string;
+    }>) => void;
+    changeDrawToolMode: (draft: Draft<DrawingToolState>, action: PayloadAction<{
+        drawToolId: string;
+        drawModeId: string;
+        shouldUpdateShape?: boolean;
+    }>) => void;
+    updateGeoJSONLayerId: (draft: Draft<DrawingToolState>, action: PayloadAction<{
+        drawToolId: string;
+        geoJSONLayerId: string;
+    }>) => void;
+    updateDrawToolMode: (draft: Draft<DrawingToolState>, action: PayloadAction<{
+        drawToolId: string;
+        drawModeId: string;
+        shape: GeoJSON.FeatureCollection;
+        title?: string;
+    }>) => void;
+    changeIntersectionBounds: (_draft: Draft<DrawingToolState>, _action: PayloadAction<{
+        drawToolId: string;
+        geoJSON: GeoJSON.FeatureCollection;
+    }>) => void;
+}, "draw">;

package/dist/src/store/drawingTool/selectors.d.ts

@@ -0,0 +1,347 @@
+import type { DrawingToolState, DrawtoolModuleStore } from './reducer';
+export declare const getDrawingtoolStore: (store: DrawtoolModuleStore) => DrawingToolState;
+export declare const selectDrawToolById: (state: DrawtoolModuleStore, id: string) => {
+    drawToolId: string;
+    geoJSONLayerId: string;
+    activeDrawModeId: string;
+    drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+    shouldAllowMultipleShapes: boolean;
+    geoJSONIntersectionLayerId?: string | undefined;
+    geoJSONIntersectionBoundsLayerId?: string | undefined;
+}, selectAllDrawingTools: (state: DrawtoolModuleStore) => import("./reducer").DrawToolItem[];
+export declare const getActiveDrawToolId: ((state: DrawtoolModuleStore) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./reducer").DrawToolItem[]) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./reducer").DrawToolItem[]) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: DrawtoolModuleStore) => import("./reducer").DrawToolItem[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getDrawModeById: ((state: DrawtoolModuleStore, _drawToolId: string, drawModeId: string) => import("@opengeoweb/webmap-react").DrawMode | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }, resultFuncArgs_1: string) => import("@opengeoweb/webmap-react").DrawMode | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }, resultFuncArgs_1: string) => import("@opengeoweb/webmap-react").DrawMode | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("@opengeoweb/webmap-react").DrawMode | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }, (_store: DrawtoolModuleStore, _drawToolId: string, drawModeId: string) => string];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getActiveDrawModeId: ((state: DrawtoolModuleStore, id: string) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getDrawToolGeoJSONLayerId: ((state: DrawtoolModuleStore, id: string) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getGeoJSONIntersectionLayerId: ((state: DrawtoolModuleStore, id: string) => string | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getGeoJSONIntersectionBoundsLayerId: ((state: DrawtoolModuleStore, id: string) => string | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getShouldAllowMultipleShapes: ((state: DrawtoolModuleStore, id: string) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getActiveDrawMode: ((state: DrawtoolModuleStore, id: string) => import("@opengeoweb/webmap-react").DrawMode | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => import("@opengeoweb/webmap-react").DrawMode | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }) => import("@opengeoweb/webmap-react").DrawMode | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("@opengeoweb/webmap-react").DrawMode | undefined;
+    dependencies: [(state: DrawtoolModuleStore, id: string) => {
+        drawToolId: string;
+        geoJSONLayerId: string;
+        activeDrawModeId: string;
+        drawModes: import("@opengeoweb/webmap-react").DrawMode[];
+        shouldAllowMultipleShapes: boolean;
+        geoJSONIntersectionLayerId?: string | undefined;
+        geoJSONIntersectionBoundsLayerId?: string | undefined;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/src/store/drawingTool/testUtils.d.ts

@@ -0,0 +1 @@
+export declare const testGeoJSON: GeoJSON.FeatureCollection;

package/dist/src/store/drawingTool/utils.d.ts

@@ -0,0 +1 @@
+export declare const getSingularDrawtoolDrawLayerId: (mapId: string) => string;

package/dist/src/store/generic/actions.d.ts

@@ -0,0 +1,28 @@
+import type { SetTimePayload, SetBboxPayload } from './types';
+/**
+ * Generic action to set the time.
+ *
+ * @param payload: SetTimePayload;
+ *   {
+ *     sourceId: string; // Source where the new time value originates from
+ *     value: string;    // ISO 8601 string time value like "2010-10-01T00:00:00Z"
+ *   }
+ */
+export declare const setTime: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetTimePayload, string>;
+/**
+ * Generic action to set the bounding box.
+ *
+ * @param payload: SetBboxPayload;
+ *
+ * {
+ *   sourceId: string;  // Source where the new time value originates from
+ *   bbox: {            // Bbbox object
+ *     left: number;
+ *     bottom: number;
+ *     right: number;
+ *     top: number;
+ *   };
+ *   srs: string;       // Projection string according to EPSG, e.g. (EPSG:3857 ==  Mercator)
+ * }
+ */
+export declare const setBbox: import("@reduxjs/toolkit").ActionCreatorWithPayload<SetBboxPayload, string>;