@opengeoweb/warnings 19.1.0 → 19.2.0

package/dist/src/lib/components/FilterList/filter-utils.d.ts

@@ -0,0 +1,111 @@
+import { AirmetPhenomena, SigmetPhenomena } from '@opengeoweb/api';
+import type { Warning } from '../../store/warningsForm/types';
+export declare enum Domain {
+    aviation = "aviation",
+    maritime = "maritime",
+    public = "public"
+}
+export declare enum Level {
+    extreme = "extreme",
+    moderate = "moderate",
+    severe = "severe",
+    airmet = "AIR",
+    sigmet = "SIG"
+}
+export declare enum Phenomenon {
+    wind = "wind",
+    fog = "fog",
+    thunderstorm = "thunderstorm",
+    snowIce = "snowIce",
+    rain = "rain",
+    highTemp = "highTemp",
+    lowTemp = "lowTemp",
+    coastalEvent = "coastalEvent"
+}
+export declare const emptyFilterId = "unspecified";
+export declare const defaultDomainFilter: Record<Domain, boolean>;
+export declare const domainLevels: Record<Domain, Level[]>;
+export declare const defaultLevelFilter: Record<Level | 'unspecified', boolean>;
+export declare const defaultEmptyFilter: Record<string, boolean>;
+export declare const makeFilterFromList: <T extends string>(options: T[], value?: boolean) => Record<T | "unspecified", boolean>;
+declare const AllPhenomena: {
+    readonly wind: Phenomenon.wind;
+    readonly fog: Phenomenon.fog;
+    readonly thunderstorm: Phenomenon.thunderstorm;
+    readonly snowIce: Phenomenon.snowIce;
+    readonly rain: Phenomenon.rain;
+    readonly highTemp: Phenomenon.highTemp;
+    readonly lowTemp: Phenomenon.lowTemp;
+    readonly coastalEvent: Phenomenon.coastalEvent;
+    readonly EMBD_TS: SigmetPhenomena.EMBD_TS;
+    readonly EMBD_TSGR: SigmetPhenomena.EMBD_TSGR;
+    readonly FRQ_TS: SigmetPhenomena.FRQ_TS;
+    readonly FRQ_TSGR: SigmetPhenomena.FRQ_TSGR;
+    readonly HVY_DS: SigmetPhenomena.HVY_DS;
+    readonly HVY_SS: SigmetPhenomena.HVY_SS;
+    readonly OBSC_TS: SigmetPhenomena.OBSC_TS;
+    readonly OBSC_TSGR: SigmetPhenomena.OBSC_TSGR;
+    readonly RDOACT_CLD: SigmetPhenomena.RDOACT_CLD;
+    readonly SEV_ICE: SigmetPhenomena.SEV_ICE;
+    readonly SEV_ICE_FRZ_RN: SigmetPhenomena.SEV_ICE_FRZ_RN;
+    readonly SEV_MTW: SigmetPhenomena.SEV_MTW;
+    readonly SEV_TURB: SigmetPhenomena.SEV_TURB;
+    readonly SQL_TS: SigmetPhenomena.SQL_TS;
+    readonly SQL_TSGR: SigmetPhenomena.SQL_TSGR;
+    readonly VA_CLD: SigmetPhenomena.VA_CLD;
+    readonly SFC_VIS: AirmetPhenomena.SFC_VIS;
+    readonly SFC_WIND: AirmetPhenomena.SFC_WIND;
+    readonly OVC_CLD: AirmetPhenomena.OVC_CLD;
+    readonly BKN_CLD: AirmetPhenomena.BKN_CLD;
+    readonly ISOL_CB: AirmetPhenomena.ISOL_CB;
+    readonly OCNL_CB: AirmetPhenomena.OCNL_CB;
+    readonly FRQ_CB: AirmetPhenomena.FRQ_CB;
+    readonly ISOL_TS: AirmetPhenomena.ISOL_TS;
+    readonly OCNL_TS: AirmetPhenomena.OCNL_TS;
+    readonly ISOL_TSGR: AirmetPhenomena.ISOL_TSGR;
+    readonly OCNL_TSGR: AirmetPhenomena.OCNL_TSGR;
+    readonly ISOL_TCU: AirmetPhenomena.ISOL_TCU;
+    readonly OCNL_TCU: AirmetPhenomena.OCNL_TCU;
+    readonly FRQ_TCU: AirmetPhenomena.FRQ_TCU;
+    readonly MOD_ICE: AirmetPhenomena.MOD_ICE;
+    readonly MOD_MTW: AirmetPhenomena.MOD_MTW;
+    readonly MOD_TURB: AirmetPhenomena.MOD_TURB;
+    readonly MT_OBSC: AirmetPhenomena.MT_OBSC;
+};
+export declare const AllPhenomenaKeys: Record<keyof typeof AllPhenomena, keyof typeof AllPhenomena>;
+export declare const domainPhenomena: Record<Domain, Partial<keyof typeof AllPhenomenaKeys>[]>;
+export declare const defaultPhenomenonFilter: Record<string, boolean>;
+type OptionsType = Partial<Record<Domain | Level | Phenomenon, boolean>>;
+interface OptionsMetadata {
+    /** The number of selected options */
+    noSelectedOptions: number;
+    /** Whether or not all options are selected */
+    allSelected: boolean;
+}
+export declare const getSelectedOptions: (options?: OptionsType) => OptionsMetadata;
+export declare const updateState: <T extends string>(state: Record<T, boolean>, optionKey: T | "ALL", value: boolean, only?: boolean) => Record<T, boolean>;
+/** Make sure our value is in the filter */
+export declare const getValue: <T>(values: Record<string, T>, value: string) => T | "unspecified";
+export declare const getFiltersFromWarnings: (warnings: Warning[], filterKey: string) => string[];
+export declare enum TimeFilterMode {
+    all = "all",
+    today = "today",
+    tomorrow = "tomorrow",
+    custom = "custom"
+}
+export interface TimeFilter {
+    mode: TimeFilterMode;
+    customStart?: string;
+    customEnd?: string;
+}
+export declare const defaultTimeFilter: TimeFilter;
+export declare const isWarningWithinInterval: (warning: Warning, timeFilter: TimeFilter) => boolean;
+export declare const getApiParams: (timeFilter: TimeFilter) => Record<string, string>;
+export declare const initialFilters: {
+    source: Record<string, boolean>;
+    domain: Record<Domain, boolean>;
+    phenomenon: Record<string, boolean>;
+    level: Record<"unspecified" | Level, boolean>;
+    time: TimeFilter;
+};
+export {};

package/dist/src/lib/components/MaritimeWarningsForm/AreaList/AreaList.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { DistrictsType } from '../types';
+export interface AreaListProps {
+    areas: DistrictsType[];
+    selected: string[];
+    disabled: string[];
+    isReadOnly?: boolean;
+    onToggleSelectArea?: (id: string) => void;
+    onSelectMultipleAreas: (ids: string[]) => void;
+}
+export declare const AreaList: React.MemoExoticComponent<({ areas, selected, disabled, isReadOnly, onToggleSelectArea, onSelectMultipleAreas, }: AreaListProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/src/lib/components/MaritimeWarningsForm/AreaList/index.d.ts

@@ -0,0 +1 @@
+export * from './AreaList';

package/dist/src/lib/components/MaritimeWarningsForm/AssignedAreas/AssignedAreas.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { DistrictsType } from '../types';
+export interface AssignedAreasProps {
+    assignedAreas: DistrictsType[];
+    selectedAreaIds: string[];
+    onAddClick: () => void;
+    onDeleteClick: (id: string) => void;
+    onToggleSelectArea: (id: string) => void;
+    onSelectMultipleAreas: (id: string[]) => void;
+    shouldShowDistricts?: boolean;
+    isReadOnly?: boolean;
+}
+export declare const AssignedAreas: React.FC<AssignedAreasProps>;

package/dist/src/lib/components/MaritimeWarningsForm/MaritimeWarningsAvatar.d.ts

@@ -0,0 +1,8 @@
+import type { TooltipProps } from '@mui/material';
+import React from 'react';
+export interface MaritimeWarningAvatarProps {
+    editor: string;
+    tooltipPlacement?: TooltipProps['placement'];
+}
+declare const MaritimeWarningAvatar: React.FC<MaritimeWarningAvatarProps>;
+export default MaritimeWarningAvatar;

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

@@ -0,0 +1,34 @@
+import type { AlertColor } from '@mui/material';
+import type { TFunction } from 'i18next';
+import React from 'react';
+import type { MaritimeWarningsDomain, MaritimeWarningItem, MaritimeWarningItemAttributes, MaritimeWarningsConfig, DistrictsType } from './types';
+export declare const getWarningsValidity: (t: TFunction, warnings: MaritimeWarningItem[]) => string;
+export interface MaritimeWarningsFormProps {
+    areas: DistrictsType[];
+    selectedAreaIds: string[];
+    warnings: MaritimeWarningItem[];
+    modified: boolean;
+    onToggleSelectArea: (id: string) => void;
+    onSelectMultipleAreas: (ids: string[]) => void;
+    onAddSelectedAreas: (id: string) => void;
+    onRemoveWarning: (id: string) => void;
+    onRemoveArea: (id: string) => void;
+    onAddWarning: () => void;
+    onChangeWarning: (id: string, newValues: Partial<MaritimeWarningItemAttributes>) => void;
+    onMoveWarning: (oldIndex: number, newIndex: number) => void;
+    onSubmit: (shouldExtend?: boolean) => Promise<void>;
+    onClear: () => void;
+    onToggleReadOnly: (isReadOnly: boolean) => void;
+    isReadOnly: boolean;
+    shouldHideEditorToggle: boolean;
+    shouldShowDistricts?: boolean;
+    editor?: string;
+    error?: {
+        title: string;
+        severity: AlertColor;
+    };
+    maritimeConfig: MaritimeWarningsConfig;
+    lastUpdatedTime?: string;
+    domain: MaritimeWarningsDomain;
+}
+export declare const MaritimeWarningsForm: React.FC<MaritimeWarningsFormProps>;

package/dist/src/lib/components/MaritimeWarningsForm/MaritimeWarningsFormConnect.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { MaritimeWarningsDomain } from './types';
+export interface MaritimeWarningsFormConnectProps {
+    domain: MaritimeWarningsDomain;
+    onPreventCloseView?: (on: boolean) => void;
+    onModifyForm?: (isFormDirty: boolean) => void;
+}
+export declare const MaritimeWarningsFormConnect: React.FC<MaritimeWarningsFormConnectProps>;

package/dist/src/lib/components/MaritimeWarningsForm/WarningList/WarningList.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { DistrictsType, MaritimeWarningsDomain, MaritimeWarningItem, MaritimeWarningItemAttributes, MaritimeWarningsConfig } from '../types';
+export interface WarningListProps {
+    warnings: MaritimeWarningItem[];
+    onAddSelectedAreas: (id: string) => void;
+    onRemoveArea: (areaId: string) => void;
+    onRemoveWarning: (id: string) => void;
+    onChangeWarning: (id: string, newValues: Partial<MaritimeWarningItemAttributes>) => void;
+    onToggleSelectArea: (areaId: string) => void;
+    onSelectMultipleAreas: (areaIds: string[]) => void;
+    onMoveWarning: (oldIndex: number, newIndex: number) => void;
+    selectedAreaIds: string[];
+    areas: DistrictsType[];
+    isReadOnly: boolean;
+    shouldShowDistricts?: boolean;
+    maritimeConfig: MaritimeWarningsConfig;
+    domain: MaritimeWarningsDomain;
+}
+export declare const WarningList: React.FC<WarningListProps>;

package/dist/src/lib/components/MaritimeWarningsForm/WarningList/WarningListDragHandle.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const WarningListDragHandle: React.FC;

package/dist/src/lib/components/MaritimeWarningsForm/WarningList/WarningListItem.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { DistrictsType, MaritimeWarningsDomain, MaritimeWarningItem, MaritimeWarningItemAttributes, MaritimeWarningsConfig } from '../types';
+export interface WarningListItemProps {
+    warning: MaritimeWarningItem;
+    areas: DistrictsType[];
+    selectedAreaIds: string[];
+    isReadOnly: boolean;
+    onAddClick: (id: string) => void;
+    onRemove: (id: string) => void;
+    onChange: (id: string, values: MaritimeWarningItemAttributes) => void;
+    onToggleSelectArea: (id: string) => void;
+    onSelectMultipleAreas: (ids: string[]) => void;
+    onRemoveArea: (id: string) => void;
+    shouldShowDistricts?: boolean;
+    maritimeConfig: MaritimeWarningsConfig;
+    domain: MaritimeWarningsDomain;
+}
+export declare const WarningListItem: React.MemoExoticComponent<({ warning, areas, selectedAreaIds, onAddClick, onRemove, onChange, onToggleSelectArea, onSelectMultipleAreas, onRemoveArea, isReadOnly, shouldShowDistricts, maritimeConfig, domain, }: WarningListItemProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/src/lib/components/MaritimeWarningsForm/WarningList/WarningListSelect.d.ts

@@ -0,0 +1,21 @@
+import type { SxProps } from '@mui/material';
+import type { TFunction } from 'i18next';
+import React from 'react';
+export interface WarningListSelectOption {
+    value: string;
+    label: string | ((t: TFunction) => string);
+}
+export interface WarningListSelectProps {
+    options: WarningListSelectOption[];
+    label: string;
+    value?: string;
+    onChange: (value: string) => void;
+    renderOption?: (option: WarningListSelectOption, index: number) => React.ReactElement;
+    renderValue?: (option: unknown) => React.ReactNode;
+    gridArea: string;
+    additionalStyling?: SxProps;
+    isReadOnly?: boolean;
+    emptyMessage?: string;
+    validationResult?: true | 'error' | 'warning';
+}
+export declare const WarningListSelect: React.MemoExoticComponent<({ options, value, label, onChange, renderOption, renderValue, gridArea, additionalStyling, isReadOnly, emptyMessage, validationResult, }: WarningListSelectProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/src/lib/components/MaritimeWarningsForm/WarningList/WindForceSelect.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export declare enum WindForceLevel {
+    moderate = "moderate",
+    severe = "severe",
+    extreme = "extreme"
+}
+export interface ColorDefinition {
+    color: string;
+    textColor: string;
+    borderColor: string;
+}
+export declare const windForceStyles: Record<WindForceLevel, ColorDefinition>;
+export interface WindForceOption {
+    level: WindForceLevel;
+    value: string;
+}
+export interface WindForceSelectProps {
+    value?: string;
+    onChange: (value: string) => void;
+    gridArea: string;
+    options: WindForceOption[];
+    isReadOnly?: boolean;
+}
+export declare const WindForceSelect: React.FC<WindForceSelectProps>;

package/dist/src/lib/components/MaritimeWarningsForm/index.d.ts

@@ -0,0 +1 @@
+export * from './MaritimeWarningsForm';

package/dist/src/lib/components/MaritimeWarningsForm/testUtils.d.ts

@@ -0,0 +1,3 @@
+import type { WarningListSelectOption } from './WarningList/WarningListSelect';
+export declare function getLabelFromOptionLabel(label: WarningListSelectOption['label']): string;
+export declare function selectOption(container: HTMLElement, comboboxLabel: string, optionLabel: WarningListSelectOption['label']): Promise<void>;

package/dist/src/lib/components/MaritimeWarningsForm/types.d.ts

@@ -0,0 +1,51 @@
+export interface Area {
+    label: string;
+    id: string;
+}
+export interface MaritimeWarningItemAttributes {
+    windDirectionFrom?: string;
+    windForce?: string;
+    changeType?: string;
+    windDirectionTo?: string;
+    validFrom?: string;
+    validUntil?: string;
+}
+export interface MaritimeWarningItem extends MaritimeWarningItemAttributes {
+    id: string;
+    assignedAreaIds: string[];
+}
+export type MaritimeWarningsDomain = 'northSeaDistricts' | 'coastalWaters';
+export interface WindDirectionType {
+    value: string;
+    label: string;
+    degrees: number;
+}
+export interface DistrictsType {
+    geoJSON: GeoJSON.FeatureCollection;
+    districtName: string;
+}
+export interface LevelDefinitionType {
+    windForce: string;
+    level: string;
+}
+export interface ChangeType {
+    label: string;
+    key: string;
+}
+export type MaritimeLevelTiming = 'maritimeLevelsSummer' | 'maritimeLevelsWinter';
+export interface ValidationItem {
+    level: 'error' | 'warning';
+    value: number;
+}
+export interface MaritimeWarningsConfig {
+    districtList: Record<MaritimeWarningsDomain, DistrictsType[]>;
+    maritimeLevelDefinition: Record<MaritimeLevelTiming, Record<MaritimeWarningsDomain, LevelDefinitionType[]>>;
+    windDirectionDefinition: WindDirectionType[];
+    changeType: ChangeType[];
+    validation: {
+        dirTo: {
+            min_wind_change: ValidationItem;
+            max_wind_change: ValidationItem;
+        };
+    };
+}

package/dist/src/lib/components/MaritimeWarningsForm/useConfirmDeleteDialog.d.ts

@@ -0,0 +1,12 @@
+import type { DistrictsType, MaritimeWarningItem, MaritimeWarningsConfig } from './types';
+interface UseConfirmDeleteDialogProps {
+    areas: DistrictsType[];
+    warnings: MaritimeWarningItem[];
+    maritimeConfig: MaritimeWarningsConfig;
+    onRemoveWarning: (id: string) => void;
+}
+interface UseConfirmDeleteDialog {
+    onRemoveWarningWithConfirmation: (id: string) => Promise<void>;
+}
+export declare function useConfirmDeleteDialog({ areas, warnings, maritimeConfig, onRemoveWarning, }: UseConfirmDeleteDialogProps): UseConfirmDeleteDialog;
+export {};

package/dist/src/lib/components/MaritimeWarningsForm/useFilterChipSelect.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface UseFilterChipSelectProps {
+    selectedIds: string[];
+    assignedIds: string[];
+    onToggleSelect?: (id: string) => void;
+    onSelectMultiple?: (ids: string[]) => void;
+}
+interface UseFilterChipSelect {
+    handleChipClick: (id: string, event: React.MouseEvent) => void;
+}
+export declare function useFilterChipSelect({ selectedIds, assignedIds, onToggleSelect, onSelectMultiple, }: UseFilterChipSelectProps): UseFilterChipSelect;
+export {};

package/dist/src/lib/components/MaritimeWarningsForm/useMaritimeWarningsFormState.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+import type { MaritimeWarningItem, MaritimeWarningItemAttributes } from './types';
+export declare function createWarning(): MaritimeWarningItem;
+export declare function isPublishedWarning(warning: MaritimeWarningItem): boolean;
+interface State {
+    selectedAreaIds: string[];
+    warnings: MaritimeWarningItem[];
+    modified: boolean;
+}
+export declare const initialState: State;
+interface Initialize {
+    type: 'initialize';
+    warnings: MaritimeWarningItem[];
+}
+interface ToggleSelectArea {
+    type: 'toggleSelectArea';
+    id: string;
+}
+interface SelectMultipleAreas {
+    type: 'selectMultipleAreas';
+    ids: string[];
+}
+interface NewWarning {
+    type: 'newWarning';
+}
+interface AddSelectedAreasToWarning {
+    type: 'addSelectedAreasToWarning';
+    id: string;
+}
+interface RemoveWarning {
+    type: 'removeWarning';
+    id: string;
+}
+interface ChangeWarning {
+    type: 'changeWarning';
+    id: string;
+    newValues: Partial<MaritimeWarningItemAttributes>;
+}
+interface RemoveArea {
+    type: 'removeArea';
+    areaId: string;
+}
+interface ClearWarnings {
+    type: 'clearWarnings';
+}
+interface MoveWarning {
+    type: 'moveWarning';
+    oldIndex: number;
+    newIndex: number;
+}
+interface MergeWarnings {
+    type: 'mergeWarnings';
+}
+interface SubmitWarnings {
+    type: 'submitWarnings';
+}
+type Action = ToggleSelectArea | NewWarning | Initialize | AddSelectedAreasToWarning | ChangeWarning | RemoveWarning | RemoveArea | ClearWarnings | MoveWarning | SelectMultipleAreas | MergeWarnings | SubmitWarnings;
+export declare function reducer(state: State, action: Action): State;
+export declare function useMaritimeWarningsFormState(): [
+    State,
+    React.Dispatch<Action>
+];
+export {};

package/dist/src/lib/components/MaritimeWarningsForm/utils.d.ts

@@ -0,0 +1,7 @@
+import type { MaritimeWarningItem, MaritimeWarningsConfig, MaritimeWarningsDomain } from './types';
+import type { MaritimeWarning, MaritimeWarningsType } from '../../store/warningsForm/types';
+export declare const isWarningsValid: (warnings: MaritimeWarningItem[], config: MaritimeWarningsConfig, allowEmpty?: boolean) => boolean;
+export declare const getType: (domain: MaritimeWarningsDomain) => MaritimeWarningsType;
+export declare const mapItemsToMaritimeWarnings: (warnings: MaritimeWarningItem[], domain: MaritimeWarningsDomain, maritimeConfig: MaritimeWarningsConfig, editor?: string, shouldExtend?: boolean) => MaritimeWarning[];
+export declare const mapMaritimeWarningsToItems: (warnings: MaritimeWarning[]) => MaritimeWarningItem[];
+export declare const validateWindDirectionChange: (directionFrom: string | undefined, directionTo: string | undefined, changeType: string | undefined, config?: MaritimeWarningsConfig) => true | "warning" | "error";

package/dist/src/lib/components/ObjectManager/Areas.d.ts

@@ -0,0 +1,13 @@
+import type { FC } from 'react';
+import type { AreaListItem } from '../../store/warningsDrawings/types';
+export type SelectedAreaFeatureNamesByAreaId = Record<string, string[]>;
+export declare const Areas: FC<{
+    areas: AreaListItem[];
+    onHoverArea?: (area: AreaListItem) => void;
+    onHoverAreaEnd?: () => void;
+    onClickArea: (area: AreaListItem) => void;
+    activeArea: string;
+    selectedAreaFeatureNamesByAreaId?: SelectedAreaFeatureNamesByAreaId;
+    isLoading?: boolean;
+    dialogWidth?: number;
+}>;

package/dist/src/lib/components/ObjectManager/ConfirmDeleteDialog.d.ts

@@ -0,0 +1,10 @@
+import type { TFunction } from 'i18next';
+import React from 'react';
+export declare const getDeleteDescription: (objectName: string, t: TFunction) => string;
+export declare const getDeleteSucces: (objectName: string, t: TFunction) => string;
+export declare const ConfirmDeleteDialog: React.FC<{
+    objectId: string;
+    objectName: string;
+    onDeleteSucces: (objectId: string) => void;
+    onClose: () => void;
+}>;

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

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { HeaderSize, Position, DraggableSize } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+import type { SelectedAreaFeatureNamesByAreaId } from './Areas';
+import type { AreaListItem, DrawingListItem } from '../../store/warningsDrawings/types';
+export declare const ObjectManager: React.FC<{
+    bounds?: string;
+    title?: string;
+    onClose: () => void;
+    onMouseDown?: () => void;
+    isOpen: boolean;
+    order?: number;
+    source?: uiTypes.Source;
+    size?: DraggableSize;
+    startPosition?: Position;
+    headerSize?: HeaderSize;
+    drawingListItems: DrawingListItem[];
+    predefinedAreaListItems: AreaListItem[];
+    onClickDrawing?: (drawing: DrawingListItem) => void;
+    onClickArea?: (area: AreaListItem) => void;
+    onHoverArea?: (area: AreaListItem) => void;
+    onHoverAreaEnd?: () => void;
+    onEditDrawing?: (drawingId: string) => void;
+    onDeleteDrawing?: (drawingId: string) => void;
+    onShareObject?: (object: DrawingListItem) => void;
+    onCreateNewObject?: () => void;
+    activeDrawingId?: string;
+    selectedAreaFeatureNamesByAreaId?: SelectedAreaFeatureNamesByAreaId;
+    error?: string;
+    isLoading?: boolean;
+    selectedTab?: number;
+    onChangeTab?: (tab: number) => void;
+}>;

package/dist/src/lib/components/ObjectManager/ObjectManagerConnect.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { uiTypes } from '@opengeoweb/store';
+export declare const ObjectManagerConnect: React.FC<{
+    bounds?: string;
+    source?: uiTypes.Source;
+}>;

package/dist/src/lib/components/ObjectManager/ObjectManagerMapButtonConnect.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { uiTypes } from '@opengeoweb/store';
+export declare const ObjectManagerMapButtonConnect: React.FC<{
+    mapId: string;
+    source?: uiTypes.Source;
+}>;

package/dist/src/lib/components/ObjectManager/Objects.d.ts

@@ -0,0 +1,29 @@
+import type { FC } from 'react';
+import type { DrawingListItem } from '../../store/warningsDrawings/types';
+export declare const DEFAULT_ADD_BUTTON_HEIGHT = 80;
+export declare const DEFAULT_OBJECT_MANAGER_TAB_HEIGHT = 40;
+export declare const DEFAULT_OBJECT_MANAGER_MIN_SIZE: {
+    width: number;
+    height: number;
+};
+export declare const BUTTON_AIRMET = "AIRMET";
+export declare const BUTTON_SIGMET = "SIGMET";
+type ListInclHeadersType = {
+    isObject: boolean;
+    index: number;
+}[];
+export declare const getListInclHeaders: (objects: DrawingListItem[]) => {
+    listInclHeaders: ListInclHeadersType;
+    headerList: string[];
+};
+export declare const Objects: FC<{
+    objects: DrawingListItem[];
+    onClickObject: (object: DrawingListItem) => void;
+    onClickEdit: (objectId: string) => void;
+    onClickDelete: (drawingId: string) => void;
+    onClickShare: (object: DrawingListItem) => void;
+    activeObject: string;
+    isLoading?: boolean;
+    dialogWidth?: number;
+}>;
+export {};

package/dist/src/lib/components/ObjectManager/index.d.ts

@@ -0,0 +1,2 @@
+export { ObjectManagerMapButtonConnect } from './ObjectManagerMapButtonConnect';
+export { ObjectManagerConnect } from './ObjectManagerConnect';

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

@@ -0,0 +1,29 @@
+import type { Theme } from '@mui/material';
+import type { Store } from '@reduxjs/toolkit';
+import { QueryClient } from '@tanstack/react-query';
+import React from 'react';
+interface WarningsClientProviderProps {
+    children: React.ReactNode;
+    optionalQueryClient?: QueryClient;
+}
+export interface WarningsThemeProviderProps extends WarningsClientProviderProps {
+    theme?: Theme;
+}
+export declare const WarningsThemeProvider: React.FC<WarningsThemeProviderProps>;
+interface WarningStoreProviderProps {
+    store?: Store;
+    optionalQueryClient?: QueryClient;
+    isLoggedIn?: boolean;
+}
+export declare const WarningsStoreProvider: React.FC<WarningStoreProviderProps & WarningsClientProviderProps>;
+export interface WarningsThemeStoreProviderProps extends WarningsThemeProviderProps {
+    store?: Store;
+    optionalQueryClient?: QueryClient;
+    isLoggedIn?: boolean;
+}
+export declare const WarningsThemeStoreProvider: React.FC<WarningsThemeStoreProviderProps>;
+interface WarningsTranslationsWrapperProps {
+    children?: React.ReactNode;
+}
+export declare const WarningsI18nProvider: React.FC<WarningsTranslationsWrapperProps>;
+export {};

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { AirmetFromBackend, SigmetFromBackend } from '@opengeoweb/api';
+export interface ConfirmDialogProps {
+    title: string;
+    description: string;
+    request: () => Promise<void> | Promise<Headers | null> | Promise<SigmetFromBackend | AirmetFromBackend> | Promise<string[]>;
+    confirmLabel: string;
+    callback?: (data?: unknown) => void;
+    isLocked?: boolean;
+}
+export declare const ConfirmDeleteWarningDialog: React.FC<{
+    onClose: () => void;
+} & ConfirmDialogProps>;
+export default ConfirmDeleteWarningDialog;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { WarningType } from '../../../store/warningsForm/types';
+export declare const BUTTON_AIRMET = "AIRMET";
+export declare const BUTTON_SIGMET = "SIGMET";
+export interface NewWarningButtonProps {
+    onCreateWarning: (warningType?: WarningType) => void;
+    isDefaultOpen?: boolean;
+}
+export declare const NewWarningButton: React.FC<NewWarningButtonProps>;

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

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { WarningListItemActions } from './WarningListItemMenu';
+import type { Warning } from '../../store/warningsForm/types';
+import type { FilterHookState } from '../FilterList/filter-hooks';
+export interface PublicWarningListProps extends WarningListItemActions {
+    warnings: Warning[];
+    onSelectWarning?: (warning: Warning) => void;
+    isLoading?: boolean;
+    error?: Error;
+    selectedWarningId?: string;
+    lastUpdatedTime?: string;
+    onCreateWarning?: () => void;
+    onRefetchWarnings?: () => void;
+    filterHookState: FilterHookState;
+    hoveredFeatureId?: string;
+    expandedSections: Record<string, boolean>;
+    setExpandedSections: (expandedSections: Record<string, boolean>) => void;
+    onHoverWarning?: (warningId?: string) => void;
+    onActionAviationWarning?: () => void;
+    onClickBatchDelete?: (warningIds: string[]) => void;
+    limitAlertCount?: number;
+    showLimitAlert?: boolean;
+    shouldDisableAviationAmendOption: boolean;
+    hiddenWarningIds?: Set<string>;
+    onToggleWarningVisibility?: (warningId: string) => void;
+    selectedForBatchDelete?: string[];
+    toggleWarningForBatchDelete?: (warningId: string) => void;
+    onSelectAllForBatchDelete?: (warningIds: string[]) => void;
+    onClearBatchDeleteSelection?: () => void;
+}
+export declare const PublicWarningList: React.FC<PublicWarningListProps>;
+export default PublicWarningList;