@opengeoweb/warnings 19.2.0 → 19.4.0

package/dist/src/index.d.ts

@@ -3,6 +3,8 @@ export * from './lib/components/ObjectManager';
 export * from './lib/components/DrawingTool';
 export * from './lib/components/DrawingToolForm';
 export * from './lib/components/PublicWarningsFormDialog';
+export * from './lib/components/WarningEvents/WarningEventForm';
+export * from './lib/components/WarningEvents/WarningEventDialog';
 export * from './lib/components/ComponentsLookUp';
 export * from './lib/components/WarningsTimeline';
 export * from './lib/store';

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

@@ -1,7 +1,7 @@
 import type { Credentials } from '@opengeoweb/authentication';
 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';
 export declare const getPublicWarningList: (auth: Credentials, apiParams?: Record<string, string>) => Promise<PublicWarning[]>;
 export declare const updatePublicWarningEditor: (warningId: string, isEditor: boolean, auth: Credentials, force?: boolean) => Promise<Headers | null>;
 export declare const updatePublicWarning: (warningId: string, auth: Credentials, data: PublicWarning) => Promise<Headers | null>;
@@ -17,3 +17,8 @@ export declare const saveDrawingAs: (auth: Credentials, data: DrawingFromFE) =>
 export declare const updateDrawing: (auth: Credentials, drawingId: string, data: DrawingFromFE) => Promise<void>;
 export declare const deleteDrawing: (auth: Credentials, drawingId: string) => Promise<void>;
 export declare const getMaritimeWarningsConfig: (auth: Credentials) => Promise<MaritimeWarningsConfig>;
+export declare const getWarningEventList: (auth: Credentials, apiParams?: Record<string, string>) => Promise<WarningEvent[]>;
+export declare const updateWarningEventEditor: (eventId: string, isEditor: boolean, auth: Credentials, force?: boolean) => Promise<Headers | null>;
+export declare const updateWarningEvent: (eventId: string, auth: Credentials, data: WarningEvent) => Promise<Headers | null>;
+export declare const postWarningEvent: (auth: Credentials, data: WarningEvent) => Promise<Headers | null>;
+export declare const deleteWarningEvent: (eventId: string, auth: Credentials) => Promise<null>;

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/PublicWarningListConnect.d.ts

@@ -6,5 +6,4 @@ export interface PublicWarningListConnectProps {
     presetFilterState?: PickedFilterState;
     presetExpandedSections?: ExpandedWarningSections;
 }
-export declare const WARNING_HOVER_DISPATCH_DELAY = 50;
 export declare const PublicWarningListConnect: React.FC<PublicWarningListConnectProps>;

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/PublicWarningList/useWarningListFeatureSync.d.ts

@@ -0,0 +1,15 @@
+import type { Warning } from '../../store/warningsForm/types';
+export declare const WARNING_HOVER_DISPATCH_DELAY = 50;
+interface UseWarningListFeatureSyncProps {
+    filteredWarningsByExpandedSections: Warning[];
+    hiddenWarningIds: Set<string>;
+    panelId: string;
+    selectedFormWarning?: Warning;
+    selectedWarningId?: string;
+}
+interface UseWarningListFeatureSyncResult {
+    handleHoverWarning: (warningId?: string) => void;
+    hoveredFeatureId?: string;
+}
+export declare const useWarningListFeatureSync: ({ filteredWarningsByExpandedSections, hiddenWarningIds, panelId, selectedFormWarning, selectedWarningId, }: UseWarningListFeatureSyncProps) => UseWarningListFeatureSyncResult;
+export {};

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

@@ -0,0 +1,15 @@
+import type { syncGroupsTypes } from '@opengeoweb/store';
+import type { Warning } from '../../store/warningsForm/types';
+export interface SyncedWarningFeature {
+    id: string;
+    originalId: string;
+    geoJSON: GeoJSON.FeatureCollection;
+}
+export declare const getSelectedFormAreaIds: (selectedFormWarning?: Warning) => Set<string>;
+export declare const shouldExcludeWarningFromFeatureSync: ({ hiddenWarningIds, hasMatchingAreaId, selectedWarningId, warningIds, }: {
+    hiddenWarningIds: Set<string>;
+    hasMatchingAreaId: boolean;
+    selectedWarningId?: string;
+    warningIds: string[];
+}) => boolean;
+export declare const createWarningFeatureCollection: (allFeatures: SyncedWarningFeature[]) => GeoJSON.FeatureCollection<GeoJSON.Geometry, syncGroupsTypes.PotentialDataProperties | null>;

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/WarningEventDialog.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { DraggableSize, HeaderSize, Position } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+export interface WarningEventDialogProps {
+    bounds?: string;
+    isOpen: boolean;
+    onClose: () => void;
+    onMouseDown?: () => void;
+    order?: number;
+    source?: uiTypes.Source;
+    size?: DraggableSize;
+    startPosition?: Position;
+    headerSize?: HeaderSize;
+    children: React.ReactNode;
+}
+export declare const WarningEventDialog: React.FC<WarningEventDialogProps>;

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

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { DraggableSize, Position } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+export interface WarningEventDialogConnectProps {
+    bounds?: string;
+    source?: uiTypes.Source;
+    size?: DraggableSize;
+    startPosition?: Position;
+    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

@@ -0,0 +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

@@ -0,0 +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;
+    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

@@ -0,0 +1,10 @@
+import React from 'react';
+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

@@ -0,0 +1,21 @@
+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;
+    labelHours: number;
+}
+export declare const getAxisIntervals: (rangeDays: number) => AxisIntervals;
+export declare const WarningEventTimeline: React.FC<WarningEventTimelineProps>;

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

@@ -0,0 +1,21 @@
+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;
+    now: Date;
+    drawableWidth: number;
+    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/WarningEventTimelineContext.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { TimelineRange } from './getTimelineRange';
+export declare const WarningEventTimelineRangeProvider: React.FC<{
+    range: TimelineRange;
+    children: React.ReactNode;
+}>;
+export declare const useTimelineRange: () => TimelineRange;

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

@@ -0,0 +1,5 @@
+export interface TimelineRange {
+    start: Date;
+    end: Date;
+}
+export declare const getTimelineRange: (selectedDays: readonly number[], now?: Date) => TimelineRange;

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

@@ -0,0 +1,3 @@
+export * from './WarningEventTimeline';
+export * from './WarningEventTimelineContext';
+export * from './getTimelineRange';

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/index.d.ts

@@ -0,0 +1,2 @@
+export { WarningEventFormContent } from './WarningEventFormContent';
+export type { WarningEventFormContentProps } from './WarningEventFormContent';

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,15 @@
+import type { WarningEvent } from '../../../store/warningsForm/types';
+export declare const emptyWarning: {
+    incident: string;
+    validFrom: string;
+    validUntil: string;
+    level: string;
+    domain: string;
+    warningProposalSource: string;
+    authority: string;
+    phenomenon: string;
+    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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { HeaderSize, Position, DraggableSize } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+export declare const WarningEventSummaryDialog: React.FC<{
+    bounds?: string;
+    title?: string;
+    onClose: () => void;
+    onMouseDown?: () => void;
+    isOpen: boolean;
+    order?: number;
+    source?: uiTypes.Source;
+    size?: DraggableSize;
+    startPosition?: Position;
+    headerSize?: HeaderSize;
+    onClickAdd?: () => void;
+}>;

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

@@ -0,0 +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<{
+    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/components/WarningEvents/WarningEventSummaryDialog/index.d.ts

@@ -0,0 +1 @@
+export { WarningEventSummaryDialog } from './WarningEventSummaryDialog';

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">;