@opengeoweb/warnings 19.3.0 → 19.4.0

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

@@ -1,15 +1,15 @@
-import type { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+import type { QueryKey, UseMutationResult, UseQueryResult } from '@tanstack/react-query';
 import type { TimeFilter } from '../../components/FilterList/filter-utils';
 import type { MaritimeWarningsConfig } from '../../components/MaritimeWarningsForm/types';
 import type { DrawingFromBE, DrawingFromFE, DrawingListItem, FetchDrawingParams } from '../../store/warningsDrawings/types';
-import type { MaritimeWarning, MaritimeWarningsType, PublicWarning } from '../../store/warningsForm/types';
+import type { MaritimeWarning, MaritimeWarningsType, PublicWarning, WarningEvent } from '../../store/warningsForm/types';
 /**
  * @param disabled - Disables fetching, but still returns cached values.
  * https://tanstack.com/query/v4/docs/framework/react/guides/disabling-queries
  */
 export declare const usePublicWarnings: (disabled?: boolean, timeFilter?: TimeFilter) => UseQueryResult<(PublicWarning | MaritimeWarning)[]>;
 type MutationReturnType<T> = UseMutationResult<Headers | null, Error, T, {
-    oldData: PublicWarning[] | undefined;
+    previousData: [QueryKey, PublicWarning[] | undefined][];
 }>;
 type DrawingMutationReturnType<T> = UseMutationResult<{
     id: string;
@@ -55,4 +55,25 @@ interface MutateMaritimeEditorParams {
 }
 export declare const useMutateMaritimeWarningsEditor: () => MutationReturnType<MutateMaritimeEditorParams>;
 export declare const useMaritimeWarningsConfig: (disabled?: boolean) => UseQueryResult<MaritimeWarningsConfig>;
+export declare const useWarningEventsList: (disabled?: boolean, timeFilter?: TimeFilter) => UseQueryResult<WarningEvent[]>;
+type EventMutationReturnType<T> = UseMutationResult<Headers | null, Error, T, {
+    previousData: [QueryKey, WarningEvent[] | undefined][];
+}>;
+interface UpdateWarningEventProps {
+    eventId?: string;
+    data: WarningEvent;
+    panelId?: string;
+}
+export declare const usePublishWarningEvent: () => EventMutationReturnType<UpdateWarningEventProps>;
+export declare const useSaveWarningEvent: () => EventMutationReturnType<UpdateWarningEventProps>;
+export declare const useMutateWarningEvent: (snackBarMessage: string) => EventMutationReturnType<UpdateWarningEventProps>;
+export declare const useMutateDeleteWarningEvent: () => EventMutationReturnType<{
+    eventId: string;
+}>;
+interface MutateEventEditorProps {
+    eventId: string;
+    isEditor: boolean;
+    force?: boolean;
+}
+export declare const useMutateEventEditor: () => EventMutationReturnType<MutateEventEditorProps>;
 export {};

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

@@ -8,6 +8,7 @@ export interface PublicWarningListProps extends WarningListItemActions {
     isLoading?: boolean;
     error?: Error;
     selectedWarningId?: string;
+    selectedEventId?: string;
     lastUpdatedTime?: string;
     onCreateWarning?: () => void;
     onRefetchWarnings?: () => void;

package/dist/src/lib/components/PublicWarningList/WarningListItem.d.ts

@@ -6,6 +6,7 @@ export interface WarningListItemProps extends ListItemProps, WarningListItemActi
     warning: Warning;
     highlightedItem?: boolean;
     activeWarningId: string;
+    activeEventId: string;
     onHoverWarning?: (warningId?: string) => void;
     onSelectWarning?: (warning: Warning) => void;
     shouldDisableAviationAmendOption?: boolean;

package/dist/src/lib/components/PublicWarningList/WarningListItemMenu.d.ts

@@ -5,7 +5,7 @@ import type { MaritimeWarning, Warning } from '../../store/warningsForm/types';
 import { MaritimeWarningAction } from '../../store/warningsForm/types';
 export interface WarningListItemActions {
     onEditWarning?: (warning: Warning) => void;
-    onDeleteWarning?: (warningId: string, warningEditor?: string) => void;
+    onDeleteWarning?: (warning: Warning) => void;
     onDeleteReviewWarning?: (warning: Warning) => void;
     onExpireWarning?: (warning: Warning) => void;
     onWithdrawWarning?: (warning: Warning) => void;

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

@@ -8,7 +8,6 @@ import type { BaseDrawingListItem, DrawingListItem } from '../../store/warningsD
 import type { FormError } from '../../store/warningsForm/reducer';
 import type { Area, PublicWarningDetail, WarningType } from '../../store/warningsForm/types';
 import { PublicWarningStatus } from '../../store/warningsForm/types';
-export declare const useScrollTopOnError: (error: FormError) => React.RefObject<HTMLDivElement | null>;
 export declare const getEmptyPublicWarning: () => PublicWarningDetail;
 export declare const getFormData: (publicWarningsDetails: PublicWarningDetail | undefined, object?: DrawingListItem) => FormData;
 interface FormData extends PublicWarningDetail {

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

@@ -4,7 +4,6 @@ import type { ConfirmationOptions, Position } from '@opengeoweb/shared';
 import { uiTypes } from '@opengeoweb/store';
 import type { MapPreset } from '@opengeoweb/store';
 export declare const warningFormConfirmationOptions: (t: TFunction) => ConfirmationOptions;
-export declare const isAlreadyEdited: (publicWarningEditor: string | undefined, username: string | undefined) => boolean;
 export declare const PublicWarningsFormDialogConnect: React.FC<{
     bounds?: string;
     source?: uiTypes.Source;

package/dist/src/lib/components/WarningEvents/WarningEventDialog/WarningEventDialogConnect.d.ts

@@ -1,11 +1,12 @@
 import React from 'react';
-import type { Position } from '@opengeoweb/shared';
+import type { DraggableSize, Position } from '@opengeoweb/shared';
 import type { uiTypes } from '@opengeoweb/store';
-import type { WarningEvent } from '../../../store/warningsForm/types';
 export interface WarningEventDialogConnectProps {
     bounds?: string;
     source?: uiTypes.Source;
+    size?: DraggableSize;
     startPosition?: Position;
-    initialValues?: Partial<WarningEvent>;
+    startPositionSummary?: Position;
+    isDefaultCollapsed?: boolean;
 }
 export declare const WarningEventDialogConnect: React.FC<WarningEventDialogConnectProps>;

package/dist/src/lib/components/WarningEvents/WarningEventDialog/WarningEventFormDialog.d.ts

@@ -0,0 +1,36 @@
+import type { TFunction } from 'i18next';
+import React from 'react';
+import type { ConfirmationOptions, DraggableSize, Position } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+import type { FormError } from '../../../store/warningsEventForm/reducer';
+import type { WarningEvent } from '../../../store/warningsForm/types';
+export declare const warningFormConfirmationOptions: (t: TFunction) => ConfirmationOptions;
+export interface WarningEventFormDialogProps {
+    bounds?: string;
+    currentEventEditor?: string;
+    shouldHideFormToggleMode?: boolean;
+    selectedEvent?: WarningEvent;
+    error?: FormError;
+    isOpen: boolean;
+    isReadOnly?: boolean;
+    order?: number;
+    size?: DraggableSize;
+    source?: uiTypes.Source;
+    startPosition?: Position;
+    onClose: () => void;
+    onChangeFormMode?: (isReadOnly: boolean) => void;
+    onMouseDown?: () => void;
+    onDelete?: () => void;
+    onFormDirty?: (isFormDirty: boolean) => void;
+    onSaveDraft?: (formValues: WarningEvent) => Promise<Headers | null>;
+    onPublish?: (formValues: WarningEvent) => Promise<Headers | null>;
+    isSummaryOpen: boolean;
+    summaryOrder?: number;
+    summarySource?: uiTypes.Source;
+    startPositionSummary?: Position;
+    onOpenSummary: () => void;
+    onCloseSummary: () => void;
+    onAddSummary: () => void;
+    onMouseDownSummary?: () => void;
+}
+export declare const WarningEventFormDialog: React.FC<WarningEventFormDialogProps>;

package/dist/src/lib/components/WarningEvents/WarningEventDialog/index.d.ts

@@ -1,4 +1,7 @@
 export { WarningEventDialog } from './WarningEventDialog';
+export type { WarningEventFormDialogProps } from './WarningEventFormDialog';
+export { WarningEventFormDialog } from './WarningEventFormDialog';
 export type { WarningEventDialogProps } from './WarningEventDialog';
 export { WarningEventDialogConnect } from './WarningEventDialogConnect';
 export type { WarningEventDialogConnectProps } from './WarningEventDialogConnect';
+export { useWarningEventActions } from './utils';

package/dist/src/lib/components/WarningEvents/WarningEventDialog/utils.d.ts

@@ -0,0 +1,16 @@
+import type { TFunction } from 'i18next';
+import type { ConfirmationOptions } from '@opengeoweb/shared';
+import type { FormAction } from '../../../store/warningsEventForm/reducer';
+import type { EventWarningForWarningList, WarningEvent } from '../../../store/warningsForm/types';
+import type { TimeFilter } from '../../FilterList/filter-utils';
+import type { ConfirmDialogProps } from '../../PublicWarningList/ConfirmWarningDialog';
+export declare const getNewEventWithLinkedToId: (event: WarningEvent) => WarningEvent;
+export declare const warningFormConfirmationOptions: (t: TFunction) => ConfirmationOptions;
+interface WarningEventsActions {
+    selectedEventId: string;
+    openWarningsEventDialog: (formAction?: FormAction, warning?: EventWarningForWarningList) => Promise<void>;
+    deleteWarningsEvent: (warningEventId: string, currentUser: string, setConfirmDialogOptions: React.Dispatch<React.SetStateAction<ConfirmDialogProps | undefined>>) => Promise<void>;
+    updateWarningsEvent: (warningEventId: string, currentUser: string) => Promise<void>;
+}
+export declare const useWarningEventActions: (panelId: string, timeFilter?: TimeFilter) => WarningEventsActions;
+export {};

package/dist/src/lib/components/WarningEvents/WarningEventForm/CollapseToggleButton.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+interface CollapseToggleButtonProps {
+    isCollapsed: boolean;
+    onToggle: () => void;
+    collapseLabel: string;
+    expandLabel: string;
+}
+export declare const CollapseToggleButton: React.FC<CollapseToggleButtonProps>;
+export {};

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventFormContent.d.ts

@@ -1,11 +1,20 @@
 import React from 'react';
+import type { FormError } from '../../../store/warningsEventForm/reducer';
 import type { WarningEvent } from '../../../store/warningsForm/types';
 export interface WarningEventFormContentProps {
+    error?: FormError;
+    currentEventEditor?: string;
+    isSummaryDialogOpen?: boolean;
+    selectedEvent?: WarningEvent;
+    shouldHideFormToggleMode?: boolean;
     isReadOnly?: boolean;
+    isDefaultCollapsed?: boolean;
     onCancel?: () => void;
+    onChangeFormMode?: (isReadOnly: boolean) => void;
     onDelete?: () => void;
+    onFormDirty?: (isFormDirty: boolean) => void;
     onOpenWarningSummary?: () => void;
-    onSaveAsDraft?: (formValues: WarningEvent) => void;
-    onPublish?: (formValues: WarningEvent) => void;
+    onSaveDraft?: (formValues: WarningEvent) => Promise<Headers | null>;
+    onPublish?: (formValues: WarningEvent) => Promise<Headers | null>;
 }
 export declare const WarningEventFormContent: React.FC<WarningEventFormContentProps>;

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventItem.d.ts

@@ -1,9 +1,10 @@
 import React from 'react';
-import type { WarningEventBody } from '../../../store/warningsForm/types';
-export declare const warningEventItemDefaultValues: WarningEventBody;
 export declare const WarningEventItem: React.FC<{
     index: number;
     isReadOnly: boolean;
+    isCompact: boolean;
+    isDeleteButtonDisabled: boolean;
+    onToggleCompact: () => void;
     onDeleteWarning: (index: number) => void;
 }>;
 export default WarningEventItem;

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventTimeline/WarningEventTimeline.d.ts

@@ -1,11 +1,17 @@
 import React from 'react';
+import type { TimelineEditing } from './WarningEventTimelineBlock';
+import type { PublicWarningStatus } from '../../../../store/warningsForm/types';
+export type { TimelineEditing };
 export interface WarningEventTimelineProps {
     start: Date;
     end: Date;
     validFrom: string;
     validUntil: string;
     level: string;
+    status?: PublicWarningStatus;
     now?: Date;
+    isCompact?: boolean;
+    editing?: TimelineEditing;
 }
 interface AxisIntervals {
     tickHours: number;
@@ -13,4 +19,3 @@ interface AxisIntervals {
 }
 export declare const getAxisIntervals: (rangeDays: number) => AxisIntervals;
 export declare const WarningEventTimeline: React.FC<WarningEventTimelineProps>;
-export {};

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventTimeline/WarningEventTimelineBlock.d.ts

@@ -1,4 +1,10 @@
 import React from 'react';
+import { PublicWarningStatus } from '../../../../store/warningsForm/types';
+import { WarningLevel } from '../../../PublicWarningsForm/LevelField';
+export interface TimelineEditing {
+    onTimesChange: (validFrom: string, validUntil: string) => void;
+    onLevelChange?: (level: WarningLevel) => void;
+}
 interface WarningEventTimelineBlockProps {
     start: Date;
     end: Date;
@@ -7,6 +13,9 @@ interface WarningEventTimelineBlockProps {
     validFrom: string;
     validUntil: string;
     level: string;
+    status?: PublicWarningStatus;
+    isCompact?: boolean;
+    editing?: TimelineEditing;
 }
 export declare const WarningEventTimelineBlock: React.FC<WarningEventTimelineBlockProps>;
 export {};

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventTimeline/WarningEventTimelineBlockControls.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { TimelineEditing } from './WarningEventTimelineBlock';
+interface WarningEventTimelineBlockControlsProps {
+    left: number;
+    width: number;
+    containerWidth: number;
+    from: Date;
+    until: Date;
+    now: Date;
+    maxPickerDate: Date;
+    editing: TimelineEditing;
+    showEditAffordances: boolean;
+}
+export declare const WarningEventTimelineBlockControls: React.FC<WarningEventTimelineBlockControlsProps>;
+export {};

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventTimeline/timelineTestUtils.d.ts

@@ -0,0 +1,4 @@
+export declare const mockTimelineLayout: ({ width, height, }?: {
+    width?: number | undefined;
+    height?: number | undefined;
+}) => void;

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventTimeline/useBlockDrag.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { DragMode } from './warningEventTimelineDragUtils';
+interface DragPreview {
+    from: Date;
+    until: Date;
+}
+export interface UseBlockDragParams {
+    from: Date | null;
+    until: Date | null;
+    rangeStart: Date;
+    rangeEnd: Date;
+    now: Date;
+    maxUntil: Date;
+    drawableWidth: number;
+    onTimesChange?: (validFrom: string, validUntil: string) => void;
+}
+export interface UseBlockDragResult {
+    dragPreview: DragPreview | null;
+    dragMode: DragMode | null;
+    beginDrag: (mode: DragMode, event: React.PointerEvent) => void;
+    onPointerMove: (event: React.PointerEvent) => void;
+    onPointerUp: (event: React.PointerEvent) => void;
+    onPointerCancel: (event: React.PointerEvent) => void;
+}
+export declare const useBlockDrag: ({ from, until, rangeStart, rangeEnd, now, maxUntil, drawableWidth, onTimesChange, }: UseBlockDragParams) => UseBlockDragResult;
+export {};

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventTimeline/useModifierKeyHeld.d.ts

@@ -0,0 +1 @@
+export declare const useModifierKeyHeld: (isEnabled?: boolean) => boolean;

package/dist/src/lib/components/WarningEvents/WarningEventForm/WarningEventTimeline/warningEventTimelineDragUtils.d.ts

@@ -0,0 +1,37 @@
+export declare const SNAP_MINUTES = 30;
+export declare const MIN_DURATION_MINUTES = 30;
+export declare const MIN_VISIBLE_MINUTES = 30;
+export declare const ABSOLUTE_MAX_DAY = 7;
+export declare const EDGE_HIT_ZONE_PX = 8;
+export declare const EXPANDED_BLOCK_TOP = 58;
+export declare const EXPANDED_BLOCK_HEIGHT = 56;
+export declare const TIME_FIELD_WIDTH = 200;
+export declare const TIME_FIELD_GAP = 8;
+export type DragMode = 'start' | 'end' | 'move';
+export declare const snapToInterval: (timeMs: number, intervalMs?: number) => number;
+export declare const formatOverflowHours: (overflowMs: number) => string;
+export declare const getEndTimeForMovedStart: (fromMs: number, untilMs: number, newFromMs: number, maxUntilMs: number) => number;
+export interface TimeFieldPositions {
+    startLeft: number;
+    endLeft: number;
+    isStacked: boolean;
+}
+export declare const getTimeFieldPositions: ({ left, width, containerWidth, }: {
+    left: number;
+    width: number;
+    containerWidth: number;
+}) => TimeFieldPositions;
+export interface ComputeDraggedTimesParams {
+    mode: DragMode;
+    deltaMs: number;
+    fromMs: number;
+    untilMs: number;
+    rangeStartMs: number;
+    rangeEndMs: number;
+    nowMs: number;
+    maxUntilMs: number;
+}
+export declare const computeDraggedTimes: ({ mode, deltaMs, fromMs, untilMs, rangeStartMs, rangeEndMs, nowMs, maxUntilMs, }: ComputeDraggedTimesParams) => {
+    fromMs: number;
+    untilMs: number;
+};

package/dist/src/lib/components/WarningEvents/WarningEventForm/types.d.ts

@@ -1,11 +1,22 @@
-import type { WarningEvent } from '../../../store/warningsForm/types';
-import { WarningEventType } from '../../../store/warningsForm/types';
+import type { WarningEvent, WarningEventBody } from '../../../store/warningsForm/types';
+import { WarningEventMode, WarningEventType } from '../../../store/warningsForm/types';
 export declare const warningEventTypes: {
     translationKey: string;
     key: WarningEventType;
     defaultDayRange: [number, number];
     minSelectableDay: number;
 }[];
+export declare const warningEventModes: {
+    translationKey: string;
+    key: WarningEventMode;
+}[];
 export declare const getDefaultDayRangeForType: (type: WarningEventType) => [number, number];
 export declare const getMinSelectableDayForType: (type: WarningEventType) => number;
+export declare const getDefaultWarningTimes: (type: WarningEventType, now?: Date) => {
+    validFrom: string;
+    validUntil: string;
+};
 export declare const defaultValues: WarningEvent;
+export declare const warningEventItemDefaultValues: WarningEventBody;
+export declare const buildDefaultWarningItem: (event: Pick<WarningEvent, "warningEventType" | "incident" | "phenomenon">) => WarningEventBody;
+export declare const getDefaultValues: (initialValues?: Partial<WarningEvent>) => WarningEvent;

package/dist/src/lib/components/WarningEvents/WarningEventForm/utils.d.ts

@@ -0,0 +1,8 @@
+import type { WarningEventBody, WarningEvent, PublicWarningStatus } from '../../../store/warningsForm/types';
+interface FormData extends WarningEvent {
+    IS_DRAFT?: boolean | string;
+}
+export declare const buildSubmitValues: (values: FormData) => WarningEvent;
+export declare const getFormData: (warningsEvent: WarningEvent | undefined) => FormData;
+export declare const constructWarningWithNewStatus: (warningsEvent: WarningEvent, status: PublicWarningStatus) => WarningEventBody[];
+export {};

package/dist/src/lib/components/WarningEvents/WarningEventForm/warningEventStoryData.d.ts

@@ -11,4 +11,5 @@ export declare const emptyWarning: {
     type: number;
     warning_handle_uuid: string;
 };
+export declare const buildEarlyWarningInitialValues: () => Partial<WarningEvent>;
 export declare const buildLiveInitialValues: () => Partial<WarningEvent>;

package/dist/src/lib/components/WarningEvents/WarningEventSummaryDialog/WarningEventSummaryDialog.d.ts

@@ -12,4 +12,5 @@ export declare const WarningEventSummaryDialog: React.FC<{
     size?: DraggableSize;
     startPosition?: Position;
     headerSize?: HeaderSize;
+    onClickAdd?: () => void;
 }>;

package/dist/src/lib/components/WarningEvents/WarningEventSummaryDialog/WarningEventSummaryForm.d.ts

@@ -1,12 +1,16 @@
 import type { TFunction } from 'i18next';
 import React from 'react';
+export declare const SUMMARY_HEADLINE_LIMIT = 80;
+export declare const SUMMARY_CONCISE_SUMMARY_LIMIT = 300;
+export declare const SUMMARY_DESCRIPTION_LIMIT = 500;
 export declare const RemainingChars: React.FC<{
-    curValue: string;
+    name: string;
     limit: number;
     t: TFunction<'warn'>;
 }>;
 interface FormProps {
     isReadOnly?: boolean;
+    onClickAdd?: () => void;
 }
 export declare const WarningEventSummaryForm: React.FC<FormProps>;
 export {};

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

@@ -1,9 +1,11 @@
 import type { CoreAppStore } from '@opengeoweb/store';
 import type { DrawState } from './warningsDrawings/types';
+import type { WarningsEventFormState } from './warningsEventForm/reducer';
 import type { WarningsFiltersState } from './warningsFilters/types';
 import type { WarningFormState } from './warningsForm/reducer';
 export interface WarningModuleStore extends CoreAppStore {
     drawings?: DrawState;
+    warningsEventForm?: WarningsEventFormState;
     warningsForm?: WarningFormState;
     warningsFilters?: WarningsFiltersState;
 }

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

@@ -0,0 +1,2 @@
+export { warningsEventFormReducer, warningsEventFormActions } from './reducer';
+export { warningsEventFormListener } from './listener';

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

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

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

@@ -0,0 +1,37 @@
+import type { AlertColor } from '@mui/material';
+import type { Draft, PayloadAction } from '@reduxjs/toolkit';
+import type { WarningEvent } from '../warningsForm/types';
+export type FormAction = '' | 'saving' | 'publishing' | 'readonly' | 'edit' | 'amending' | 'cancel';
+export interface FormError {
+    severity?: AlertColor;
+    message: string;
+}
+export interface WarningsEventFormState {
+    event?: WarningEvent;
+    formState?: FormAction;
+    error?: FormError;
+    selectedEventId?: string;
+    isFormDirty?: boolean;
+    warningType?: 'warningsEvent';
+    panelId?: string;
+}
+export declare const TAKEOVER_MESSAGE = "You are no longer the editor of this warning";
+export declare const initialState: WarningsEventFormState;
+export declare const warningsEventFormReducer: import("redux").Reducer<WarningsEventFormState>, warningsEventFormActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    setFormValues: (draft: Draft<WarningsEventFormState>, action: PayloadAction<{
+        event?: WarningEvent;
+        formState?: FormAction;
+    }>) => void;
+    openWarningsEventFormDialog: (draft: Draft<WarningsEventFormState>, action: PayloadAction<{
+        formState?: FormAction;
+        event?: WarningEvent;
+        panelId?: string;
+        selectedEventId?: string;
+    }>) => void;
+    setFormError: (draft: Draft<WarningsEventFormState>, action: PayloadAction<FormError>) => void;
+    removeFormError: (draft: Draft<WarningsEventFormState>) => void;
+    setFormDirty: (draft: Draft<WarningsEventFormState>, action: PayloadAction<{
+        isFormDirty: boolean;
+    }>) => void;
+    setSelectedEventId: (draft: Draft<WarningsEventFormState>, action: PayloadAction<string>) => void;
+}, "warningsEventForm">;

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

@@ -0,0 +1,66 @@
+import type { WarningModuleStore } from '../types';
+import type { WarningsEventFormState } from './reducer';
+export declare const selectWarningsEventFormState: (store: WarningModuleStore) => WarningsEventFormState;
+export declare const getWarningEvent: ((state: WarningModuleStore) => import("../warningsForm/types").WarningEvent | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningsEventFormState) => import("../warningsForm/types").WarningEvent | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningsEventFormState) => import("../warningsForm/types").WarningEvent | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../warningsForm/types").WarningEvent | undefined;
+    dependencies: [(store: WarningModuleStore) => WarningsEventFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getSelectedEventId: ((state: WarningModuleStore) => string) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningsEventFormState) => string;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningsEventFormState) => string) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string;
+    dependencies: [(store: WarningModuleStore) => WarningsEventFormState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const getWarningsEventIsFormDirty: ((state: WarningModuleStore) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: WarningsEventFormState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: WarningsEventFormState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [(store: WarningModuleStore) => WarningsEventFormState];
+    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

@@ -5,7 +5,7 @@ export interface Area {
     areaId?: string;
     published_warning_uuid?: string;
 }
-export interface PublicWarningDetail {
+export interface WarningBodyBase {
     id?: string;
     phenomenon: string;
     areas?: Area[];
@@ -13,8 +13,6 @@ export interface PublicWarningDetail {
     validUntil: string;
     level: string;
     probability: number;
-    descriptionOriginal: string;
-    descriptionTranslation: string;
     domain?: string;
     warningProposalSource?: string;
     authority?: string;
@@ -22,6 +20,10 @@ export interface PublicWarningDetail {
     warning_handle_uuid?: string;
     proposal_id?: string;
     linked_to_id?: string;
+}
+export interface PublicWarningDetail extends WarningBodyBase {
+    descriptionOriginal: string;
+    descriptionTranslation: string;
     incident?: string;
 }
 export type AviationWarningDetails = Airmet | CancelAirmet | Sigmet | CancelSigmet;
@@ -40,7 +42,7 @@ export declare enum MaritimeWarningAction {
     EXTEND = "EXTEND"
 }
 export type MaritimeWarningsType = 'maritimeWarningCoastal' | 'maritimeWarningNorthSea';
-export type WarningType = 'public' | 'airmet' | 'sigmet' | MaritimeWarningsType | 'warningEvent';
+export type WarningType = 'public' | 'airmet' | 'sigmet' | MaritimeWarningsType | 'warningsEvent';
 interface BaseWarning {
     status?: PublicWarningStatus;
     productStatus?: ProductStatus;
@@ -69,7 +71,18 @@ export interface MaritimeWarning extends BaseWarning {
         windDirectionTo?: string;
     };
 }
-export type WarningEventBody = Omit<PublicWarningDetail, 'descriptionOriginal' | 'descriptionTranslation'>;
+export interface EventWarningForWarningList extends BaseWarning {
+    type: 'warningsEvent';
+    eventId?: string;
+    warningDetail: PublicWarningDetail & {
+        eventId?: string;
+    };
+}
+export interface WarningEventBody extends WarningBodyBase {
+    incident: string;
+    eventId?: string;
+    status?: PublicWarningStatus;
+}
 export interface WarningEventTexts {
     headlineOriginal: string;
     headlineTranslation: string;
@@ -82,6 +95,10 @@ export declare enum WarningEventType {
     WARNING = "WARNING",
     EARLY_WARNING = "EARLY_WARNING"
 }
+export declare enum WarningEventMode {
+    ACTUAL = "ACTUAL",
+    TEST = "TEST"
+}
 export interface WarningEvent {
     eventId?: string;
     status?: PublicWarningStatus;
@@ -90,11 +107,13 @@ export interface WarningEvent {
     phenomenon: string;
     validFrom: string;
     validUntil: string;
-    incident?: string;
-    type?: 'public';
+    incident: string;
+    type?: 'warningsEvent';
     warningEventType: WarningEventType;
     warnings: WarningEventBody[];
     texts: WarningEventTexts;
+    linked_to_id?: string;
+    mode: WarningEventMode;
 }
-export type Warning = PublicWarning | AirmetWarning | SigmetWarning | MaritimeWarning;
+export type Warning = PublicWarning | AirmetWarning | SigmetWarning | MaritimeWarning | EventWarningForWarningList;
 export {};

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

@@ -1,3 +1,4 @@
 import { uiTypes } from '@opengeoweb/store';
 export declare const publicWarningDialogType = uiTypes.DialogTypes.PublicWarnings;
 export declare const warningEventDialogType = uiTypes.DialogTypes.WarningsEvent;
+export declare const warningEventsSummaryDialogType = uiTypes.DialogTypes.WarningsEventSummary;