@opengeoweb/warnings 12.1.2 → 12.3.0

package/src/lib/components/PublicWarningsFormDialog/PublicWarningsFormDialog.stories.d.ts

@@ -1,57 +1,18 @@
-import * as React from 'react';
+import type { StoryObj } from '@storybook/react';
+import { PublicWarningsFormDialog } from './PublicWarningsFormDialog';
 declare const _default: {
     title: string;
-};
-export default _default;
-export declare const PublicWarningsFormDialogLight: {
-    (): React.ReactElement;
-    parameters: {
-        zeplinLink: {
-            name: string;
-            link: string;
-        }[];
-    };
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogDark: {
-    (): React.ReactElement;
-    parameters: {
-        zeplinLink: {
-            name: string;
-            link: string;
-        }[];
-    };
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogBigLight: {
-    (): React.ReactElement;
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogBigDark: {
-    (): React.ReactElement;
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogBigErrorLight: {
-    (): React.ReactElement;
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogBigErrorDark: {
-    (): React.ReactElement;
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogReadOnlyLight: {
-    (): React.ReactElement;
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogReadOnlyDark: {
-    (): React.ReactElement;
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogTakeoverWarningLight: {
-    (): React.ReactElement;
-    tags: string[];
-};
-export declare const PublicWarningsFormDialogTakeoverWarningDark: {
-    (): React.ReactElement;
     tags: string[];
 };
+export default _default;
+type Story = StoryObj<typeof PublicWarningsFormDialog>;
+export declare const PublicWarningsFormDialogLight: Story;
+export declare const PublicWarningsFormDialogDark: Story;
+export declare const PublicWarningsFormDialogBigLight: Story;
+export declare const PublicWarningsFormDialogBigDark: Story;
+export declare const PublicWarningsFormDialogBigErrorLight: Story;
+export declare const PublicWarningsFormDialogBigErrorDark: Story;
+export declare const PublicWarningsFormDialogReadOnlyLight: Story;
+export declare const PublicWarningsFormDialogReadOnlyDark: Story;
+export declare const PublicWarningsFormDialogTakeoverWarningLight: Story;
+export declare const PublicWarningsFormDialogTakeoverWarningDark: Story;

package/src/lib/components/PublicWarningsFormDialog/PublicWarningsFormDialogConnect.stories.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 declare const _default: {
     title: string;
+    tags: string[];
 };
 export default _default;
 export declare const PublicWarningsFormDialogConnectMap: () => React.ReactElement;

package/src/lib/components/WarningsMapView/WarningsMapView.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 import { FeatureCollection } from 'geojson';
 import { MapPreset } from '@opengeoweb/store';
 interface WarningsMapViewProps {
-    geojsonFeature: FeatureCollection | undefined;
+    geojsonFeature?: FeatureCollection | undefined;
     defaultMapPreset?: MapPreset;
     isSnapshot?: boolean;
 }

package/src/lib/store/publicWarningForm/listener.d.ts

@@ -1,2 +1,2 @@
 import { WarningModuleStore } from '../types';
-export declare const publicWarningFormListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WarningModuleStore, import("@reduxjs/toolkit").ThunkDispatch<WarningModuleStore, unknown, import("redux").AnyAction>, unknown>;
+export declare const publicWarningFormListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WarningModuleStore, import("redux-thunk").ThunkDispatch<WarningModuleStore, unknown, import("redux").UnknownAction>, unknown>;

package/src/lib/store/publicWarningForm/reducer.d.ts

@@ -1,8 +1,8 @@
-import { PayloadAction, Draft } from '@reduxjs/toolkit';
 import { AlertColor } from '@mui/material';
+import { Draft, PayloadAction } from '@reduxjs/toolkit';
 import { DrawingListItem } from '../warningsDrawings/types';
 import { Area, Warning, WarningType } from './types';
-export type FormAction = '' | 'saving' | 'publishing' | 'readonly' | 'edit';
+export type FormAction = '' | 'saving' | 'publishing' | 'readonly' | 'edit' | 'cancel';
 export interface FormError {
     severity?: AlertColor;
     message: string;

package/src/lib/store/publicWarningForm/selectors.d.ts

@@ -1,58 +1,234 @@
 import { WarningModuleStore } from '../types';
 import { WarningFormState } from './reducer';
 export declare const getPublicWarningStore: (store: WarningModuleStore) => WarningFormState;
-export declare const selectPublicWarningState: ((state: WarningModuleStore) => WarningFormState) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => WarningFormState, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const selectPublicWarningState: ((state: WarningModuleStore) => WarningFormState) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => WarningFormState;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => WarningFormState) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => WarningFormState;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningObject: ((state: WarningModuleStore) => import("../warningsDrawings/types").DrawingListItem | undefined) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => import("../warningsDrawings/types").DrawingListItem | undefined, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getPublicWarningObject: ((state: WarningModuleStore) => import("../warningsDrawings/types").DrawingListItem | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => import("../warningsDrawings/types").DrawingListItem | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => import("../warningsDrawings/types").DrawingListItem | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../warningsDrawings/types").DrawingListItem | undefined;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarning: ((state: WarningModuleStore) => import("./types").Warning | undefined) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => import("./types").Warning | undefined, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getPublicWarning: ((state: WarningModuleStore) => import("./types").Warning | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => import("./types").Warning | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => import("./types").Warning | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").Warning | undefined;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningStatus: ((state: WarningModuleStore) => import("./types").PublicWarningStatus | undefined) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => import("./types").PublicWarningStatus | undefined, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getPublicWarningStatus: ((state: WarningModuleStore) => import("./types").PublicWarningStatus | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => import("./types").PublicWarningStatus | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => import("./types").PublicWarningStatus | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").PublicWarningStatus | undefined;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningId: ((state: WarningModuleStore) => string | undefined) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => string | undefined, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getPublicWarningId: ((state: WarningModuleStore) => string | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => string | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => string | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string | undefined;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningAreas: ((state: WarningModuleStore) => import("./types").Area[]) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => import("./types").Area[], {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getPublicWarningAreas: ((state: WarningModuleStore) => import("./types").Area[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => import("./types").Area[];
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => import("./types").Area[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").Area[];
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningFormState: ((state: WarningModuleStore) => "" | "saving" | "publishing" | "readonly" | "edit") & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => "" | "saving" | "publishing" | "readonly" | "edit", {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getPublicWarningFormState: ((state: WarningModuleStore) => "" | "saving" | "publishing" | "readonly" | "edit" | "cancel") & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => "" | "saving" | "publishing" | "readonly" | "edit" | "cancel";
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => "" | "saving" | "publishing" | "readonly" | "edit" | "cancel") & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => "" | "saving" | "publishing" | "readonly" | "edit" | "cancel";
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningFormError: ((state: WarningModuleStore) => import("./reducer").FormError | undefined) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => import("./reducer").FormError | undefined, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getPublicWarningFormError: ((state: WarningModuleStore) => import("./reducer").FormError | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => import("./reducer").FormError | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => import("./reducer").FormError | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./reducer").FormError | undefined;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getSelectedWarningId: ((state: WarningModuleStore) => string) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => string, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getSelectedWarningId: ((state: WarningModuleStore) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getSelectedPublicIsFormDirty: ((state: WarningModuleStore) => boolean) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => boolean, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getSelectedPublicIsFormDirty: ((state: WarningModuleStore) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getWarningType: ((state: WarningModuleStore) => import("./types").WarningType | undefined) & import("reselect").OutputSelectorFields<(args_0: WarningFormState) => import("./types").WarningType | undefined, {
-    clearCache: () => void;
-}> & {
-    clearCache: () => void;
+export declare const getWarningType: ((state: WarningModuleStore) => import("./types").WarningType | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => import("./types").WarningType | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => import("./types").WarningType | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").WarningType | undefined;
+    dependencies: [(store: WarningModuleStore) => WarningFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };

package/src/lib/store/publicWarnings/listener.d.ts

@@ -1,3 +1,3 @@
 import { WarningModuleStore } from '../types';
 export declare const getLastUpdatedTimeFormatted: () => string;
-export declare const publicWarningsListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WarningModuleStore, import("@reduxjs/toolkit").ThunkDispatch<WarningModuleStore, unknown, import("redux").AnyAction>, unknown>;
+export declare const publicWarningsListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WarningModuleStore, import("redux-thunk").ThunkDispatch<WarningModuleStore, unknown, import("redux").UnknownAction>, unknown>;

package/src/lib/store/publicWarnings/reducer.d.ts

@@ -2,7 +2,7 @@ import { Draft, PayloadAction } from '@reduxjs/toolkit';
 import { Warning } from '../publicWarningForm/types';
 import { PublicWarningsState } from './types';
 import { FilterState } from '../../components/FilterList/filter-hooks';
-export declare const publicWarningsAdapter: import("@reduxjs/toolkit").EntityAdapter<Warning>;
+export declare const publicWarningsAdapter: import("@reduxjs/toolkit").EntityAdapter<Warning, string>;
 export declare const initialState: PublicWarningsState;
 export declare const publicWarningsReducer: import("redux").Reducer<PublicWarningsState>, publicWarningActions: import("@reduxjs/toolkit").CaseReducerActions<{
     setWarningFilters: (draft: Draft<PublicWarningsState>, action: PayloadAction<{

package/src/lib/store/publicWarnings/selectors.d.ts

@@ -3,36 +3,164 @@ import { WarningModuleStore } from '../types';
 import { FilterState } from '../../components/FilterList/filter-hooks';
 export declare const getPublicWarningsStore: (store: WarningModuleStore) => PublicWarningsState;
 export declare const selectAllPublicWarnings: (state: WarningModuleStore) => import("../publicWarningForm/types").Warning[];
-export declare const isPublicWarningsLoading: ((state: WarningModuleStore) => boolean) & import("reselect").OutputSelectorFields<(args_0: PublicWarningsState) => boolean, {
-    clearCache: () => void;
-}> & {
+export declare const isPublicWarningsLoading: ((state: WarningModuleStore) => boolean) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: PublicWarningsState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: PublicWarningsState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: WarningModuleStore) => PublicWarningsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningsError: ((state: WarningModuleStore) => import("./types").PublicWarningError | undefined) & import("reselect").OutputSelectorFields<(args_0: PublicWarningsState) => import("./types").PublicWarningError | undefined, {
-    clearCache: () => void;
-}> & {
+export declare const getPublicWarningsError: ((state: WarningModuleStore) => import("./types").PublicWarningError | undefined) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: PublicWarningsState) => import("./types").PublicWarningError | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: PublicWarningsState) => import("./types").PublicWarningError | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").PublicWarningError | undefined;
+    dependencies: [(store: WarningModuleStore) => PublicWarningsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getPublicWarningsLastUpdatedTime: ((state: WarningModuleStore) => string) & import("reselect").OutputSelectorFields<(args_0: PublicWarningsState) => string, {
-    clearCache: () => void;
-}> & {
+export declare const getPublicWarningsLastUpdatedTime: ((state: WarningModuleStore) => string) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: PublicWarningsState) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: PublicWarningsState) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: WarningModuleStore) => PublicWarningsState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
-export declare const getWarningsFilterById: ((state: WarningModuleStore, panelId?: string | undefined) => FilterState) & import("reselect").OutputSelectorFields<(args_0: Record<string, FilterState>, args_1: string | undefined) => FilterState, {
-    clearCache: () => void;
-}> & {
+export declare const getWarningsFilterById: ((state: WarningModuleStore, panelId?: string | undefined) => FilterState) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, FilterState>, resultFuncArgs_1: string | undefined) => FilterState;
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, FilterState>, resultFuncArgs_1: string | undefined) => FilterState) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => FilterState;
+    dependencies: [((state: WarningModuleStore) => Record<string, FilterState>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: PublicWarningsState) => Record<string, FilterState>;
+        memoizedResultFunc: ((resultFuncArgs_0: PublicWarningsState) => Record<string, FilterState>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => Record<string, FilterState>;
+        dependencies: [(store: WarningModuleStore) => PublicWarningsState];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, (_store: WarningModuleStore, panelId?: string) => string | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };
 export declare const getWarningsPresetById: ((state: WarningModuleStore, panelId?: string | undefined) => {
     filterState: null;
 } | {
     filterState: FilterState;
-}) & import("reselect").OutputSelectorFields<(args_0: Record<string, FilterState>, args_1: string | undefined) => {
-    filterState: null;
-} | {
-    filterState: FilterState;
-}, {
-    clearCache: () => void;
-}> & {
+}) & {
     clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, FilterState>, resultFuncArgs_1: string | undefined) => {
+        filterState: null;
+    } | {
+        filterState: FilterState;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, FilterState>, resultFuncArgs_1: string | undefined) => {
+        filterState: null;
+    } | {
+        filterState: FilterState;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        filterState: null;
+    } | {
+        filterState: FilterState;
+    };
+    dependencies: [((state: WarningModuleStore) => Record<string, FilterState>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: PublicWarningsState) => Record<string, FilterState>;
+        memoizedResultFunc: ((resultFuncArgs_0: PublicWarningsState) => Record<string, FilterState>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => Record<string, FilterState>;
+        dependencies: [(store: WarningModuleStore) => PublicWarningsState];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, (_store: WarningModuleStore, panelId?: string) => string | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
 };

package/src/lib/store/publicWarnings/types.d.ts

@@ -11,7 +11,7 @@ export interface PublicWarningError {
     message: string;
 }
 export interface PublicWarningsState {
-    warnings: EntityState<Warning>;
+    warnings: EntityState<Warning, string>;
     isLoading: boolean;
     lastUpdatedTime: string;
     error?: PublicWarningError;

package/src/lib/store/store.d.ts

@@ -1,17 +1,17 @@
 import { SnackbarModuleStore } from '@opengeoweb/snackbar';
 import { DrawtoolModuleStore, UIModuleState, WebMapStateModuleState } from '@opengeoweb/store';
-import { ToolkitStore } from '@reduxjs/toolkit/dist/configureStore';
+import { Store } from '@reduxjs/toolkit';
 import { WarningModuleStore } from './types';
 export declare const warningsReducersMap: {
-    webmap: import("redux").Reducer<import("dist/libs/store/src/store/map/types").WebMapState, import("redux").AnyAction>;
-    layers: import("redux").Reducer<import("dist/libs/store/src/store/map/types").LayerState, import("redux").AnyAction>;
-    ui: import("redux").Reducer<import("dist/libs/store/src/store/ui/types").UIStoreType, import("redux").AnyAction>;
-    drawingtools: import("redux").Reducer<import("dist/libs/store/src/store/drawingTool/reducer").DrawingToolState, import("redux").AnyAction>;
+    webmap: import("redux").Reducer<import("dist/libs/store/src/store/map/types").WebMapState, import("redux").UnknownAction, import("dist/libs/store/src/store/map/types").WebMapState>;
+    layers: import("redux").Reducer<import("dist/libs/store/src/store/map/types").LayerState, import("redux").UnknownAction, import("dist/libs/store/src/store/map/types").LayerState>;
+    ui: import("redux").Reducer<import("dist/libs/store/src/store/ui/types").UIStoreType, import("redux").UnknownAction, import("dist/libs/store/src/store/ui/types").UIStoreType>;
+    drawingtools: import("redux").Reducer<import("dist/libs/store/src/store/drawingTool/reducer").DrawingToolState, import("redux").UnknownAction, import("dist/libs/store/src/store/drawingTool/reducer").DrawingToolState>;
     drawings: import("redux").Reducer<import("./warningsDrawings/types").DrawState>;
     publicWarningForm: import("redux").Reducer<import("./publicWarningForm/reducer").WarningFormState>;
     publicWarnings: import("redux").Reducer<import("./publicWarnings/types").PublicWarningsState>;
-    snackbar: import("redux").Reducer<import("dist/libs/snackbar/src/lib/store/types").SnackbarState, import("redux").AnyAction>;
-    syncGroups: import("redux").Reducer<import("dist/libs/store/src/store/generic/syncGroups/types").SynchronizationGroupState, import("redux").AnyAction>;
+    snackbar: import("redux").Reducer<import("dist/libs/snackbar/src/lib/store/types").SnackbarState, import("redux").UnknownAction, import("dist/libs/snackbar/src/lib/store/types").SnackbarState>;
+    syncGroups: import("redux").Reducer<import("dist/libs/store/src/store/generic/syncGroups/types").SynchronizationGroupState, import("redux").UnknownAction, import("dist/libs/store/src/store/generic/syncGroups/types").SynchronizationGroupState>;
 };
-export declare const warningsMiddlewares: (import("@reduxjs/toolkit").ListenerMiddleware<WarningModuleStore, import("@reduxjs/toolkit").ThunkDispatch<WarningModuleStore, unknown, import("redux").AnyAction>, unknown> | import("@reduxjs/toolkit").ListenerMiddleware<SnackbarModuleStore, import("@reduxjs/toolkit").ThunkDispatch<SnackbarModuleStore, unknown, import("redux").AnyAction>, unknown>)[];
-export declare const createMockStore: (mockState?: WebMapStateModuleState | DrawtoolModuleStore | UIModuleState | WarningModuleStore | SnackbarModuleStore) => ToolkitStore;
+export declare const warningsMiddlewares: (import("@reduxjs/toolkit").ListenerMiddleware<WarningModuleStore, import("redux-thunk").ThunkDispatch<WarningModuleStore, unknown, import("redux").UnknownAction>, unknown> | import("@reduxjs/toolkit").ListenerMiddleware<SnackbarModuleStore, import("redux-thunk").ThunkDispatch<SnackbarModuleStore, unknown, import("redux").UnknownAction>, unknown>)[];
+export declare const createMockStore: (mockState?: WebMapStateModuleState | DrawtoolModuleStore | UIModuleState | WarningModuleStore | SnackbarModuleStore) => Store;

package/src/lib/store/warningsDrawings/listener.d.ts

@@ -1,2 +1,2 @@
 import { WarningModuleStore } from '../types';
-export declare const warningsDrawingsListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WarningModuleStore, import("@reduxjs/toolkit").ThunkDispatch<WarningModuleStore, unknown, import("redux").AnyAction>, unknown>;
+export declare const warningsDrawingsListener: import("@reduxjs/toolkit").ListenerMiddlewareInstance<WarningModuleStore, import("redux-thunk").ThunkDispatch<WarningModuleStore, unknown, import("redux").UnknownAction>, unknown>;

package/src/lib/store/warningsDrawings/reducer.d.ts

@@ -1,6 +1,6 @@
 import { PayloadAction, Draft } from '@reduxjs/toolkit';
 import { DrawItem, DrawState, SetDrawValuesPayload, SubmitDrawValuesPayload } from './types';
-export declare const drawAdapter: import("@reduxjs/toolkit").EntityAdapter<DrawItem>;
+export declare const drawAdapter: import("@reduxjs/toolkit").EntityAdapter<DrawItem, string>;
 export declare const initialState: DrawState;
 export declare const warningsDrawingsReducer: import("redux").Reducer<DrawState>, warningsDrawingsActions: import("@reduxjs/toolkit").CaseReducerActions<{
     setDrawValues: (draft: Draft<DrawState>, action: PayloadAction<SetDrawValuesPayload>) => void;