@opengeoweb/warnings 12.2.0 → 12.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeoweb/warnings",
-  "version": "12.2.0",
+  "version": "12.3.0",
   "description": "GeoWeb warinings library for the opengeoweb project",
   "license": "Apache-2.0",
   "repository": {
@@ -8,28 +8,28 @@
     "url": "git@gitlab.com:opengeoweb/opengeoweb.git"
   },
   "dependencies": {
-    "@opengeoweb/api": "12.2.0",
-    "@opengeoweb/shared": "12.2.0",
-    "@opengeoweb/store": "12.2.0",
-    "@opengeoweb/webmap-react": "12.2.0",
+    "@opengeoweb/api": "12.3.0",
+    "@opengeoweb/shared": "12.3.0",
+    "@opengeoweb/store": "12.3.0",
+    "@opengeoweb/webmap-react": "12.3.0",
     "@tanstack/react-query": "^5.69.2",
-    "react-redux": "^8.1.3",
-    "@opengeoweb/theme": "12.2.0",
-    "@opengeoweb/form-fields": "12.2.0",
+    "react-redux": "^9.2.0",
+    "@opengeoweb/theme": "12.3.0",
+    "@opengeoweb/form-fields": "12.3.0",
     "react-hook-form": "^7.50.1",
     "lodash": "^4.17.21",
-    "@reduxjs/toolkit": "^1.9.7",
-    "@opengeoweb/snackbar": "12.2.0",
+    "@reduxjs/toolkit": "^2.6.1",
+    "@opengeoweb/snackbar": "12.3.0",
     "react-window": "^1.8.10",
     "react-virtualized-auto-sizer": "^1.0.20",
     "axios": "^1.7.7",
-    "@opengeoweb/core": "12.2.0",
-    "@opengeoweb/webmap": "12.2.0",
-    "@opengeoweb/authentication": "12.2.0",
-    "@opengeoweb/sigmet-airmet": "12.2.0",
+    "@opengeoweb/core": "12.3.0",
+    "@opengeoweb/webmap": "12.3.0",
+    "@opengeoweb/authentication": "12.3.0",
+    "@opengeoweb/sigmet-airmet": "12.3.0",
     "react-i18next": "^15.1.1",
     "i18next": "^23.11.5",
-    "@mui/material": "^6.1.1",
+    "@mui/material": "^7.0.1",
     "ol": "^10.4.0",
     "msw": "^2.7.3"
   },

package/src/lib/api/warning-api/api.d.ts

@@ -4,3 +4,4 @@ export declare const getPublicWarningList: (auth: Credentials) => Promise<Public
 export declare const updatePublicWarningEditor: (warningId: string, isEditor: boolean, auth: Credentials) => Promise<Headers | null>;
 export declare const updatePublicWarning: (warningId: string, auth: Credentials, data: PublicWarning) => Promise<Headers | null>;
 export declare const postPublicWarning: (auth: Credentials, data: PublicWarning) => Promise<Headers | null>;
+export declare const deleteWarning: (warningId: string, auth: Credentials) => Promise<null>;

package/src/lib/api/warning-api/hooks.d.ts

@@ -19,6 +19,9 @@ interface UpdateWarningProps {
     panelId?: string;
 }
 export declare const useMutateWarning: (snackBarMessage: string) => MutationReturnType<UpdateWarningProps>;
+export declare const useMutateDeleteWarning: () => MutationReturnType<{
+    id: string;
+}>;
 export declare const usePublishWarning: () => MutationReturnType<UpdateWarningProps>;
 export declare const useSaveWarning: () => MutationReturnType<UpdateWarningProps>;
 export {};

package/src/lib/components/PublicWarningList/ConfirmWarningDialog.d.ts

@@ -2,9 +2,9 @@ import React from 'react';
 export interface ConfirmDialogProps {
     title: string;
     description: string;
-    request: () => Promise<void>;
+    request: () => Promise<void> | Promise<Headers | null>;
     confirmLabel: string;
-    callback: (data?: unknown) => void;
+    callback?: (data?: unknown) => void;
     isLocked?: boolean;
 }
 export declare const ConfirmDeleteWarningDialog: React.FC<{

package/src/lib/components/PublicWarningList/PublicWarningListConnect.stories.d.ts

@@ -29,7 +29,15 @@ export declare const EditorChanged: {
         };
     };
 };
-export declare const PublicWarningListErrorDeleteWarning: () => React.ReactElement;
+export declare const PublicWarningListErrorDeleteWarning: {
+    parameters: {
+        msw: {
+            handlers: {
+                warnings: import("msw").HttpHandler[];
+            };
+        };
+    };
+};
 export declare const ExtraLongList: {
     args: {
         description: string;

package/src/lib/components/PublicWarningList/WarningListColumnContent.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
-import { Grid2Props } from '@mui/material';
+import { GridProps } from '@mui/material';
 import { PublicWarningStatus } from '../../store/publicWarningForm/types';
-export declare const WarningListColumnContent: React.FC<Grid2Props & {
+export declare const WarningListColumnContent: React.FC<GridProps & {
     title?: string;
     status: PublicWarningStatus;
     children?: React.ReactNode;

package/src/lib/components/PublicWarningList/WarningListHeaderContent.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { Grid2Props } from '@mui/material';
-declare const WarningListHeaderContent: React.FC<Grid2Props & {
+import { GridProps } from '@mui/material';
+declare const WarningListHeaderContent: React.FC<GridProps & {
     title: string;
     width?: number;
     onClick?: () => void;

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

@@ -33,6 +33,7 @@ export interface FormProps {
     selectedAviationProduct?: AviationProduct;
     warningType?: WarningType;
     mode?: FormMode;
+    formState?: string;
     onSetViewModeResetArea?: (area: Area[]) => void;
     storedStartGeoJSON?: FeatureCollection<Geometry, GeoJsonProperties>;
     storedEndGeoJSON?: FeatureCollection<Geometry, GeoJsonProperties>;

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;