@opengeoweb/warnings 19.1.0 → 19.2.0

package/dist/src/lib/store/warningsDrawings/types.d.ts

@@ -0,0 +1,39 @@
+import type { EntityState } from '@reduxjs/toolkit';
+export interface DrawItem {
+    id: string;
+    objectName: string;
+    drawingInstanceId: string;
+    isFormDirty?: boolean;
+}
+export type DrawState = EntityState<DrawItem, string>;
+export type DrawingScope = 'user' | 'global';
+export interface BaseDrawingListItem {
+    id: string;
+    objectName: string;
+    lastUpdatedTime: string;
+}
+export interface DrawingListItem extends BaseDrawingListItem {
+    scope: DrawingScope;
+    geoJSON: GeoJSON.FeatureCollection;
+    keywords?: string;
+}
+export interface AreaListItem extends BaseDrawingListItem {
+    scope: DrawingScope;
+    geoJSON: GeoJSON.FeatureCollection;
+    keywords?: string;
+    aggregationId?: string;
+}
+export interface DrawingFromBE extends DrawingListItem {
+    username: string;
+}
+export interface DrawingDetails extends Omit<DrawingFromBE, 'id' | 'lastUpdatedTime'> {
+    id?: string;
+    lastUpdatedTime?: string;
+}
+export type DrawingFromFE = Omit<DrawingDetails, 'username'>;
+export interface FetchDrawingParams {
+    keywords?: string;
+    search?: string;
+}
+export type SetDrawValuesPayload = DrawItem;
+export type SubmitDrawValuesPayload = DrawingFromFE;

package/dist/src/lib/store/warningsDrawings/utils.d.ts

@@ -0,0 +1,4 @@
+import { uiTypes } from '@opengeoweb/store';
+export declare const objectDialogType = uiTypes.DialogTypes.ObjectManager;
+export declare const drawingDialogType = uiTypes.DialogTypes.DrawingTool;
+export declare const areaObjectLoaderType = uiTypes.DialogTypes.AreaObjectLoader;

package/dist/src/lib/store/warningsFilters/index.d.ts

@@ -0,0 +1 @@
+export { warningsFiltersReducer, warningsFiltersActions } from './reducer';

package/dist/src/lib/store/warningsFilters/reducer.d.ts

@@ -0,0 +1,30 @@
+import type { Draft, PayloadAction } from '@reduxjs/toolkit';
+import type { ExpandedWarningSections, WarningsFiltersState } from './types';
+import type { FilterState } from '../../components/FilterList/filter-hooks';
+export declare const defaultExpandedWarningSections: ExpandedWarningSections;
+export declare const initialWarningFilterPanelState: {
+    expandedSections: ExpandedWarningSections;
+    hoveredWarningIds: never[];
+    source: Record<string, boolean>;
+    domain: Record<import("../../components/FilterList/filter-utils").Domain, boolean>;
+    phenomenon: Record<string, boolean>;
+    level: Record<"unspecified" | import("../../components/FilterList/filter-utils").Level, boolean>;
+    time: import("../../components/FilterList/filter-utils").TimeFilter;
+};
+export declare const initialState: WarningsFiltersState;
+export declare const warningsFiltersReducer: import("redux").Reducer<WarningsFiltersState>, warningsFiltersActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    setWarningFilters: (draft: Draft<WarningsFiltersState>, action: PayloadAction<{
+        filterState: Partial<FilterState>;
+        panelId?: string;
+        systemUpdate: boolean;
+    }>) => void;
+    setExpandedSectionsForPanel: (draft: Draft<WarningsFiltersState>, action: PayloadAction<{
+        panelId: string;
+        expandedSections: ExpandedWarningSections;
+        systemUpdate?: boolean;
+    }>) => void;
+    setHoveredWarningIdsForPanel: (draft: Draft<WarningsFiltersState>, action: PayloadAction<{
+        panelId: string;
+        warningIds?: string[];
+    }>) => void;
+}, "warningsFilters">;

package/dist/src/lib/store/warningsFilters/selectors.d.ts

@@ -0,0 +1,192 @@
+import type { FilterState } from '../../components/FilterList/filter-hooks';
+import type { WarningModuleStore } from '../types';
+import type { ExpandedWarningSections, WarningsFilterPanelState, WarningsFiltersState } from './types';
+export declare const getWarningsFilters: (store: WarningModuleStore) => WarningsFiltersState;
+export declare const getWarningsFilterById: ((state: WarningModuleStore, panelId?: string | undefined) => FilterState) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningsFilterPanelState | undefined) => FilterState;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningsFilterPanelState | undefined) => FilterState) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => FilterState;
+    dependencies: [((state: WarningModuleStore, panelId?: string | undefined) => WarningsFilterPanelState | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => WarningsFilterPanelState | undefined;
+        dependencies: [(store: WarningModuleStore) => WarningsFiltersState, (_store: WarningModuleStore, panelId?: string) => string | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getExpandedSectionsByPanelId: ((state: WarningModuleStore, panelId?: string | undefined) => ExpandedWarningSections) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningsFilterPanelState | undefined) => ExpandedWarningSections;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningsFilterPanelState | undefined) => ExpandedWarningSections) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => ExpandedWarningSections;
+    dependencies: [((state: WarningModuleStore, panelId?: string | undefined) => WarningsFilterPanelState | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => WarningsFilterPanelState | undefined;
+        dependencies: [(store: WarningModuleStore) => WarningsFiltersState, (_store: WarningModuleStore, panelId?: string) => string | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getHoveredWarningIdsByPanelId: ((state: WarningModuleStore, panelId?: string | undefined) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningsFilterPanelState | undefined) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: WarningsFilterPanelState | undefined) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [((state: WarningModuleStore, panelId?: string | undefined) => WarningsFilterPanelState | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => WarningsFilterPanelState | undefined;
+        dependencies: [(store: WarningModuleStore) => WarningsFiltersState, (_store: WarningModuleStore, panelId?: string) => string | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    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;
+    expandedSections: null;
+} | {
+    filterState: FilterState;
+    expandedSections: ExpandedWarningSections;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningsFilterPanelState | undefined) => {
+        filterState: null;
+        expandedSections: null;
+    } | {
+        filterState: FilterState;
+        expandedSections: ExpandedWarningSections;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: WarningsFilterPanelState | undefined) => {
+        filterState: null;
+        expandedSections: null;
+    } | {
+        filterState: FilterState;
+        expandedSections: ExpandedWarningSections;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        filterState: null;
+        expandedSections: null;
+    } | {
+        filterState: FilterState;
+        expandedSections: ExpandedWarningSections;
+    };
+    dependencies: [((state: WarningModuleStore, panelId?: string | undefined) => WarningsFilterPanelState | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined;
+        memoizedResultFunc: ((resultFuncArgs_0: WarningsFiltersState, resultFuncArgs_1: string | undefined) => WarningsFilterPanelState | undefined) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => WarningsFilterPanelState | undefined;
+        dependencies: [(store: WarningModuleStore) => WarningsFiltersState, (_store: WarningModuleStore, panelId?: string) => string | undefined];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/src/lib/store/warningsFilters/types.d.ts

@@ -0,0 +1,17 @@
+import type { FilterState } from '../../components/FilterList/filter-hooks';
+export interface FilterTranslation {
+    translationKey: string;
+    key: string;
+    isAviation?: boolean;
+}
+export interface ExpandedWarningSections extends Record<string, boolean> {
+    TODO: boolean;
+    DRAFT: boolean;
+    PUBLISHED: boolean;
+    EXPIRED: boolean;
+}
+export interface WarningsFilterPanelState extends FilterState {
+    expandedSections: ExpandedWarningSections;
+    hoveredWarningIds: string[];
+}
+export type WarningsFiltersState = Record<string, WarningsFilterPanelState>;

package/dist/src/lib/store/warningsForm/index.d.ts

@@ -0,0 +1,2 @@
+export { warningsFormReducer, warningsFormActions } from './reducer';
+export { warningsFormListener } from './listener';

package/dist/src/lib/store/warningsForm/listener.d.ts

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

package/dist/src/lib/store/warningsForm/reducer.d.ts

@@ -0,0 +1,53 @@
+import type { AlertColor } from '@mui/material';
+import type { Draft, PayloadAction } from '@reduxjs/toolkit';
+import type { Area, Warning, WarningType } from './types';
+import type { WarningLevel } from '../../components/PublicWarningsForm/LevelField';
+import type { DrawingListItem } from '../warningsDrawings/types';
+export type FormAction = '' | 'saving' | 'publishing' | 'readonly' | 'edit' | 'amending' | 'cancel';
+export interface FormError {
+    severity?: AlertColor;
+    message: string;
+}
+export interface WarningFormState {
+    object?: DrawingListItem;
+    warning?: Warning;
+    formState?: FormAction;
+    error?: FormError;
+    selectedWarningId?: string;
+    isFormDirty?: boolean;
+    warningType?: WarningType;
+    panelId?: string;
+}
+export declare const TAKEOVER_MESSAGE = "You are no longer the editor of this warning";
+export declare const initialState: WarningFormState;
+export declare const warningsFormReducer: import("redux").Reducer<WarningFormState>, warningsFormActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    setFormValues: (draft: Draft<WarningFormState>, action: PayloadAction<{
+        object?: DrawingListItem;
+        warning?: Warning;
+        formState?: FormAction;
+    }>) => void;
+    addArea: (draft: Draft<WarningFormState>, action: PayloadAction<{
+        area: Area;
+    }>) => void;
+    removeArea: (draft: Draft<WarningFormState>, action: PayloadAction<{
+        area: Area;
+    }>) => void;
+    removeAllAreas: (draft: Draft<WarningFormState>) => void;
+    openPublicWarningFormDialog: (draft: Draft<WarningFormState>, action: PayloadAction<{
+        object?: DrawingListItem;
+        formState?: FormAction;
+        warning?: Warning;
+        warningType?: WarningType;
+        panelId?: string;
+    }>) => void;
+    setFormError: (draft: Draft<WarningFormState>, action: PayloadAction<FormError>) => void;
+    removeFormError: (draft: Draft<WarningFormState>) => void;
+    setFormDirty: (draft: Draft<WarningFormState>, action: PayloadAction<{
+        isFormDirty: boolean;
+    }>) => void;
+    setEditMode: (draft: Draft<WarningFormState>, action: PayloadAction<{
+        warningId: string;
+    }>) => void;
+    setSelectedWarningId: (draft: Draft<WarningFormState>, action: PayloadAction<string>) => void;
+    setWarningLevel: (draft: Draft<WarningFormState>, action: PayloadAction<WarningLevel | "">) => void;
+}, "warningsForm">;

package/dist/src/lib/store/warningsForm/selectors.d.ts

@@ -0,0 +1,192 @@
+import type { WarningModuleStore } from '../types';
+import type { WarningFormState } from './reducer';
+export declare const selectWarningsFormState: (store: WarningModuleStore) => WarningFormState;
+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) & {
+    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) & {
+    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[]) & {
+    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) => "" | "cancel" | "saving" | "publishing" | "readonly" | "edit" | "amending") & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningFormState) => "" | "cancel" | "saving" | "publishing" | "readonly" | "edit" | "amending";
+    memoizedResultFunc: ((resultFuncArgs_0: WarningFormState) => "" | "cancel" | "saving" | "publishing" | "readonly" | "edit" | "amending") & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => "" | "cancel" | "saving" | "publishing" | "readonly" | "edit" | "amending";
+    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) & {
+    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) & {
+    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) & {
+    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;
+};
+export declare const getPublicWarningPanelId: ((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;
+};

package/dist/src/lib/store/warningsForm/types.d.ts

@@ -0,0 +1,73 @@
+import type { Airmet, CancelAirmet, CancelSigmet, ProductStatus, Sigmet } from '@opengeoweb/api';
+export interface Area {
+    objectName: string;
+    geoJSON: GeoJSON.FeatureCollection;
+    areaId?: string;
+    published_warning_uuid?: string;
+}
+export interface PublicWarningDetail {
+    id?: string;
+    phenomenon: string;
+    areas?: Area[];
+    validFrom: string;
+    validUntil: string;
+    level: string;
+    probability: number;
+    descriptionOriginal: string;
+    descriptionTranslation: string;
+    domain?: string;
+    warningProposalSource?: string;
+    authority?: string;
+    type?: number;
+    warning_handle_uuid?: string;
+    proposal_id?: string;
+    linked_to_id?: string;
+    incident?: string;
+}
+export type AviationWarningDetails = Airmet | CancelAirmet | Sigmet | CancelSigmet;
+export declare enum PublicWarningStatus {
+    DRAFT = "DRAFT",
+    DRAFT_PUBLISHED = "DRAFT_PUBLISHED",
+    PUBLISHED = "PUBLISHED",
+    TODO = "TODO",
+    EXPIRED = "EXPIRED",
+    IGNORED = "IGNORED",
+    WITHDRAWN = "WITHDRAWN"
+}
+export declare enum MaritimeWarningAction {
+    SELECT = "SELECT",
+    UPDATE = "UPDATE",
+    EXTEND = "EXTEND"
+}
+export type MaritimeWarningsType = 'maritimeWarningCoastal' | 'maritimeWarningNorthSea';
+export type WarningType = 'public' | 'airmet' | 'sigmet' | MaritimeWarningsType;
+interface BaseWarning {
+    status?: PublicWarningStatus;
+    productStatus?: ProductStatus;
+    editor?: string;
+    warningDetail: PublicWarningDetail;
+    id?: string;
+    lastUpdatedTime?: string;
+}
+export interface PublicWarning extends BaseWarning {
+    type: 'public';
+}
+export interface AirmetWarning extends BaseWarning {
+    type: 'airmet';
+    sigmetAirmetDetails: Airmet | CancelAirmet;
+}
+export interface SigmetWarning extends BaseWarning {
+    type: 'sigmet';
+    sigmetAirmetDetails: Sigmet | CancelSigmet;
+}
+export interface MaritimeWarning extends BaseWarning {
+    type: MaritimeWarningsType;
+    warningDetail: PublicWarningDetail & {
+        windDirectionFrom?: string;
+        windForce?: string;
+        changeType?: string;
+        windDirectionTo?: string;
+    };
+}
+export type Warning = PublicWarning | AirmetWarning | SigmetWarning | MaritimeWarning;
+export {};

package/dist/src/lib/store/warningsForm/utils.d.ts

@@ -0,0 +1,2 @@
+import { uiTypes } from '@opengeoweb/store';
+export declare const publicWarningDialogType = uiTypes.DialogTypes.PublicWarnings;

package/dist/src/lib/storybookUtils/SimpleLinkMenu.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface SimpleLinkMenuProps {
+    panelId: string;
+}
+export declare const SimpleLinkMenu: React.FC<SimpleLinkMenuProps>;
+export {};

package/dist/src/lib/storybookUtils/defaultStorySettings.d.ts

@@ -0,0 +1,18 @@
+import type { layerTypes, mapTypes } from '@opengeoweb/store';
+export declare const initialBbox: {
+    srs: "EPSG:3857";
+    bbox: {
+        left: number;
+        bottom: number;
+        right: number;
+        top: number;
+    };
+};
+interface UseDefaultMapSettingsProps {
+    mapId?: string;
+    baseLayers?: layerTypes.Layer[];
+    bbox?: mapTypes.Bbox;
+    srs?: string;
+}
+export declare const useDefaultMapSettings: (props?: UseDefaultMapSettingsProps) => void;
+export {};

package/dist/src/lib/storybookUtils/storyComponents.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare const AppHamburgerMenu: React.FC;
+export declare const MapWithWarnings: React.FC<{
+    mapId: string;
+}>;

package/dist/src/lib/storybookUtils/testUtils.d.ts

@@ -0,0 +1,11 @@
+import type { Airmet, CancelAirmet, CancelSigmet, Sigmet } from '@opengeoweb/sigmet-airmet';
+import type { PublicWarning } from '../store/warningsForm/types';
+export declare const testGeoJSON: GeoJSON.FeatureCollection;
+export declare function fakeErrorRequest<ReturnType>(error: string): Promise<ReturnType>;
+export declare const fakePostError = "2 validation errors for Request\nbody -> warningDetail -> phenomenon\n  value is not a valid enumeration member; permitted: 'wind', 'fog', 'thunderstorm', 'snowIce', 'rain', 'highTemp', 'funnelCloud', 'lowTemp', 'coastalEvent' (type=type_error.enum; enum_values=[<PhenomenonEnum.WIND: 'wind'>, <PhenomenonEnum.FOG: 'fog'>, <PhenomenonEnum.THUNDERSTORM: 'thunderstorm'>, <PhenomenonEnum.SNOW_ICE: 'snowIce'>, <PhenomenonEnum.RAIN: 'rain'>, <PhenomenonEnum.HIGH_TEMP: 'highTemp'>, <PhenomenonEnum.FUNNEL_CLD: 'funnelCloud'>, <PhenomenonEnum.LOW_TEMP: 'lowTemp'>, <PhenomenonEnum.COASTAL_EVENT: 'coastalEvent'>])\nbody -> warningDetail -> level\n  value is not a valid enumeration member; permitted: 'moderate', 'severe', 'extreme' (type=type_error.enum; enum_values=[<LevelEnum.MODERATE: 'moderate'>, <LevelEnum.SEVERE: 'severe'>, <LevelEnum.EXTREME: 'extreme'>])";
+export declare const testPublicWarning: PublicWarning;
+export declare const testDraftAirmet: Airmet | CancelAirmet;
+export declare const testPublishedAirmet: Airmet | CancelAirmet;
+export declare const testDraftAirmet2: Sigmet | CancelSigmet;
+export declare const testDraftSigmet: Sigmet | CancelSigmet;
+export declare const testPublishedSigmet: Sigmet | CancelSigmet;