@opengeoweb/warnings 19.1.0 → 19.2.0

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+import warningsTranslations from '../locales/warnings.json';
+export * from './lib/components/ObjectManager';
+export * from './lib/components/DrawingTool';
+export * from './lib/components/DrawingToolForm';
+export * from './lib/components/PublicWarningsFormDialog';
+export * from './lib/components/ComponentsLookUp';
+export * from './lib/components/WarningsTimeline';
+export * from './lib/store';
+export { WARN_NAMESPACE } from './lib/utils/i18n';
+export { warningsTranslations };
+export * as publicWarningsSelectors from './lib/store/warningsFilters/selectors';
+export type * from './lib/store/types';

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

@@ -0,0 +1,12 @@
+import type { TimeFilter } from '../components/FilterList/filter-utils';
+import type { Warning } from '../store/warningsForm/types';
+interface WarningsResponse {
+    combinedWarnings: Warning[];
+    refetchWarnings: () => void;
+    isFetching: boolean;
+    error?: Error;
+    dataUpdatedAt: number;
+}
+export declare const useWarnings: (disabled?: boolean, timeFilter?: TimeFilter) => WarningsResponse;
+export declare function useAutoRefetchOnExpiry(combinedWarnings: Warning[], refetchWarnings: () => void): void;
+export {};

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

@@ -0,0 +1,23 @@
+import type { AirmetConfig, AirmetFromBackend, SigmetConfig, SigmetFromBackend } from '@opengeoweb/api';
+import type { Credentials } from '@opengeoweb/authentication';
+import type { AirmetFromFrontend, AviationProduct, SigmetFromFrontend } from '@opengeoweb/sigmet-airmet';
+export declare const airmetBaseUrl: string;
+export declare const sigmetBaseUrl: string;
+export declare const getAirmetList: (auth: Credentials, params?: Record<string, string>) => Promise<AirmetFromBackend[]>;
+export declare const getSigmetList: (auth: Credentials, params?: Record<string, string>) => Promise<SigmetFromBackend[]>;
+export declare const getAirmetConfig: (auth: Credentials) => Promise<AirmetConfig>;
+export declare const getSigmetConfig: (auth: Credentials) => Promise<SigmetConfig>;
+export declare const getAirmetTAC: (product: AviationProduct, auth?: Credentials) => Promise<{
+    data: string;
+}>;
+export declare const getSigmetTAC: (product: AviationProduct, auth?: Credentials) => Promise<{
+    data: string;
+}>;
+export declare const getAirmetCancelTAC: (product: AviationProduct, auth?: Credentials) => Promise<{
+    data: string;
+}>;
+export declare const getSigmetCancelTAC: (product: AviationProduct, auth?: Credentials) => Promise<{
+    data: string;
+}>;
+export declare const postSigmet: (auth: Credentials, data: SigmetFromFrontend) => Promise<SigmetFromBackend>;
+export declare const postAirmet: (auth: Credentials, data: AirmetFromFrontend) => Promise<AirmetFromBackend>;

package/dist/src/lib/api/aviation-api/errorHandling.d.ts

@@ -0,0 +1 @@
+export declare function humanizeApiErrorMessage(err: unknown): string;

package/dist/src/lib/api/aviation-api/fakeApi.d.ts

@@ -0,0 +1,8 @@
+import type { AirmetFromBackend, SigmetFromBackend } from '@opengeoweb/api';
+export declare const airmetList: AirmetFromBackend[];
+export declare const sigmetList: SigmetFromBackend[];
+export declare const fakeSigmetTAC = "EHAA SIGMET T01 VALID 121249/121449 EHDB- EHAA AMSTERDAM FIR FRQ TS OBS ENTIRE FIR FL010 STNR WKN";
+export declare const fakeAirmetTAC = "EHAA AIRMET -1 VALID 310700/311100 EHDB- EHAA AMSTERDAM FIR ISOL CB OBS ENTIRE FIR FL020 STNR NC";
+export declare const fakeDraftCancelSigmetTAC = "EHAA SIGMET T02 121249/121449 EHDB- EHAA AMSTERDAM FIR";
+export declare const fakeDraftCancelAirmetTAC = "EHAA AIRMET 2  310700/311100 EHDB- EHAA AMSTERDAM FIR ";
+export declare const aviationEndpoints: import("msw").HttpHandler[];

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

@@ -0,0 +1,43 @@
+import type { UseMutationResult, UseQueryResult } from '@tanstack/react-query';
+import type { AirmetConfig, AirmetFromBackend, SigmetConfig, SigmetFromBackend } from '@opengeoweb/api';
+import type { AirmetFromFrontend, AviationProduct, SigmetFromFrontend } from '@opengeoweb/sigmet-airmet';
+import type { TimeFilter } from '../../components/FilterList/filter-utils';
+import type { WarningType } from '../../store/warningsForm/types';
+interface TACData {
+    data: string;
+}
+type TACResult = UseQueryResult<{
+    data: string;
+}>;
+export declare const useAirmetList: (disabled?: boolean, timeFilter?: TimeFilter) => UseQueryResult<AirmetFromBackend[]>;
+export declare const useSigmetList: (disabled?: boolean, timeFilter?: TimeFilter) => UseQueryResult<SigmetFromBackend[]>;
+export declare const useAviationWarnings: () => (SigmetFromBackend | AirmetFromBackend)[];
+export declare const useProductConfig: (warningType?: WarningType, disabled?: boolean) => UseQueryResult<SigmetConfig | AirmetConfig>;
+export declare const useFetchSigmetTAC: (product: AviationProduct, enabled?: boolean) => TACResult;
+export declare const useFetchAirmetTAC: (product: AviationProduct, enabled?: boolean) => TACResult;
+export declare const useFetchSigmetCancelTAC: (product: AviationProduct, enabled?: boolean) => TACResult;
+export declare const useFetchAirmetCancelTAC: (product: AviationProduct, enabled?: boolean) => TACResult;
+interface UseTACApi {
+    fetchSigmetTAC: (product: AviationProduct) => Promise<TACData>;
+    fetchAirmetTAC: (product: AviationProduct) => Promise<TACData>;
+    fetchSigmetCancelTAC: (product: AviationProduct) => Promise<TACData>;
+    fetchAirmetCancelTAC: (product: AviationProduct) => Promise<TACData>;
+}
+export declare const useTACApi: () => UseTACApi;
+/**
+ * Hook for posting a SIGMET, with feedback.
+ *
+ * @param snackBarMessage - Message to show on success.
+ * @param onDialogClose - Optional callback to close a dialog.
+ * @returns A mutation result for posting a SIGMET.
+ */
+export declare const usePostSigmet: () => UseMutationResult<SigmetFromBackend, Error, SigmetFromFrontend>;
+/**
+ * Hook for posting an AIRMET, with feedback.
+ *
+ * @param snackBarMessage - Message to show on success.
+ * @param onDialogClose - Optional callback to close a dialog.
+ * @returns A mutation result for posting an AIRMET.
+ */
+export declare const usePostAirmet: () => UseMutationResult<AirmetFromBackend, Error, AirmetFromFrontend>;
+export {};

package/dist/src/lib/api/aviation-api/queryOptions.d.ts

@@ -0,0 +1,68 @@
+import type { Credentials } from '@opengeoweb/authentication';
+import type { AviationProduct } from '@opengeoweb/sigmet-airmet';
+export declare const aviationQueryOptions: {
+    readonly getSigmetTAC: (product: AviationProduct, credentials?: Credentials) => import("@tanstack/query-core").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+        data: string;
+    }, Error, {
+        data: string;
+    }, string[]>, "queryFn"> & {
+        queryFn?: import("@tanstack/query-core").QueryFunction<{
+            data: string;
+        }, string[], never> | undefined;
+    } & {
+        queryKey: string[] & {
+            [dataTagSymbol]: {
+                data: string;
+            };
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    readonly getAirmetTAC: (product: AviationProduct, credentials?: Credentials) => import("@tanstack/query-core").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+        data: string;
+    }, Error, {
+        data: string;
+    }, string[]>, "queryFn"> & {
+        queryFn?: import("@tanstack/query-core").QueryFunction<{
+            data: string;
+        }, string[], never> | undefined;
+    } & {
+        queryKey: string[] & {
+            [dataTagSymbol]: {
+                data: string;
+            };
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    readonly getSigmetCancelTAC: (product: AviationProduct, credentials?: Credentials) => import("@tanstack/query-core").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+        data: string;
+    }, Error, {
+        data: string;
+    }, string[]>, "queryFn"> & {
+        queryFn?: import("@tanstack/query-core").QueryFunction<{
+            data: string;
+        }, string[], never> | undefined;
+    } & {
+        queryKey: string[] & {
+            [dataTagSymbol]: {
+                data: string;
+            };
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+    readonly getAirmetCancelTAC: (product: AviationProduct, credentials?: Credentials) => import("@tanstack/query-core").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
+        data: string;
+    }, Error, {
+        data: string;
+    }, string[]>, "queryFn"> & {
+        queryFn?: import("@tanstack/query-core").QueryFunction<{
+            data: string;
+        }, string[], never> | undefined;
+    } & {
+        queryKey: string[] & {
+            [dataTagSymbol]: {
+                data: string;
+            };
+            [dataTagErrorSymbol]: Error;
+        };
+    };
+};

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

@@ -0,0 +1,19 @@
+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';
+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>;
+export declare const postPublicWarning: (auth: Credentials, data: PublicWarning) => Promise<Headers | null>;
+export declare const postMaritimeWarnings: (auth: Credentials, data: MaritimeWarning[]) => Promise<Headers | null>;
+export declare const updateMaritimeWarningsEditor: (domain: MaritimeWarningsType, isEditor: boolean, auth: Credentials, force?: boolean) => Promise<Headers | null>;
+export declare const deleteWarning: (warningId: string, auth: Credentials) => Promise<null>;
+export declare const getDrawings: (auth: Credentials, params?: FetchDrawingParams) => Promise<DrawingListItem[]>;
+export declare const getDrawingsPredefinedAreas: (auth: Credentials) => Promise<DrawingListItem[]>;
+export declare const getDrawingDetails: (auth: Credentials, drawingId: string) => Promise<DrawingFromBE>;
+export declare const getAreaKeywords: (auth: Credentials) => Promise<string[]>;
+export declare const saveDrawingAs: (auth: Credentials, data: DrawingFromFE) => Promise<Headers>;
+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>;

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

@@ -0,0 +1,58 @@
+import type { 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';
+/**
+ * @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;
+}>;
+type DrawingMutationReturnType<T> = UseMutationResult<{
+    id: string;
+}, Error, T, void>;
+interface MutateEditorProps {
+    id: string;
+    isEditor: boolean;
+    force?: boolean;
+}
+export declare const useMutatePublicWarningEditor: () => MutationReturnType<MutateEditorProps>;
+interface UpdateWarningProps {
+    id?: string;
+    data: PublicWarning;
+    panelId?: string;
+}
+export declare const useMutateWarning: (snackBarMessage: string) => MutationReturnType<UpdateWarningProps>;
+export declare const useMutateDeleteWarning: () => MutationReturnType<{
+    id: string;
+}>;
+export declare const usePublishWarning: () => MutationReturnType<UpdateWarningProps>;
+export declare const useSaveWarning: () => MutationReturnType<UpdateWarningProps>;
+export declare const useDrawings: (params?: FetchDrawingParams, enabled?: boolean) => UseQueryResult<DrawingListItem[]>;
+export declare const useDrawingsPredefinedAreas: (enabled?: boolean) => UseQueryResult<DrawingListItem[]>;
+export declare const useDrawingDetails: (drawingId: string) => UseQueryResult<DrawingFromBE>;
+export declare const useAreaKeywords: (enabled?: boolean) => UseQueryResult<string[]>;
+export declare const useMutateSaveOrUpdateDrawing: () => DrawingMutationReturnType<{
+    data: DrawingFromFE;
+    id?: string;
+}>;
+interface DeleteDrawingParams {
+    drawingId: string;
+    objectName: string;
+}
+export declare const useMutateDeleteDrawing: () => UseMutationResult<{
+    id: string;
+}, Error, DeleteDrawingParams>;
+export declare const BE_EDITOR_WARNING = "Warning is being edited by another user and cannot be updated";
+export declare const usePostMaritimeWarnings: () => MutationReturnType<MaritimeWarning[]>;
+interface MutateMaritimeEditorParams {
+    domain: MaritimeWarningsType;
+    isEditor: boolean;
+    force?: boolean;
+}
+export declare const useMutateMaritimeWarningsEditor: () => MutationReturnType<MutateMaritimeEditorParams>;
+export declare const useMaritimeWarningsConfig: (disabled?: boolean) => UseQueryResult<MaritimeWarningsConfig>;
+export {};

package/dist/src/lib/components/AreaObjectLoader/AreaObjectFilter.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ListFilter } from '@opengeoweb/shared';
+export interface AreaObjectFilterProps {
+    filters: ListFilter[];
+    onClickFilterChip?: (id: string, selected: boolean) => void;
+    searchQuery: string;
+    onSearch?: (searchQuery: string) => void;
+}
+export declare const AreaObjectFilter: React.ForwardRefExoticComponent<AreaObjectFilterProps & React.RefAttributes<HTMLElement>>;

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

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { HeaderSize, Position, DraggableSize } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+import type { AreaObjectFilterProps } from './AreaObjectFilter';
+import type { DrawingListItem } from '../../store/warningsDrawings/types';
+import type { Area } from '../../store/warningsForm/types';
+export declare const areaErrorType = "area";
+export declare const AreaObjectLoader: 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[];
+    error?: uiTypes.UISetErrorPayload;
+    isLoading?: boolean;
+    onAddArea?: (drawingListItem: DrawingListItem) => void;
+    onRemoveArea?: (drawingListItem: DrawingListItem) => void;
+    selectedAreas?: Area[];
+    isChangeAreaDisabled?: boolean;
+    onRetryRequest?: (errorType: string) => void;
+    shouldDisableRemoveWarning?: boolean;
+} & AreaObjectFilterProps>;

package/dist/src/lib/components/AreaObjectLoader/AreaObjectLoaderConnect.d.ts

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

package/dist/src/lib/components/AreaObjectLoader/AreasObjects.d.ts

@@ -0,0 +1,28 @@
+import type { TFunction } from 'i18next';
+import type { FC } from 'react';
+import React from 'react';
+import type { DrawingListItem } from '../../store/warningsDrawings/types';
+import type { Area } from '../../store/warningsForm/types';
+interface ObjectAreaList {
+    title: string;
+    items: DrawingListItem[];
+}
+export declare const useGetFilterHeight: (filterRef?: React.RefObject<HTMLElement>) => number;
+export declare const getListInclHeaders: (items: DrawingListItem[], translateFn: TFunction) => {
+    objects: ObjectAreaList;
+    areas: ObjectAreaList;
+};
+export declare const getLabel: (selectedAreas: Area[], isAreaSelected: boolean) => string;
+export declare const getDisplayDate: (date: string) => string;
+export declare const AreasObjects: FC<{
+    drawingListItems: DrawingListItem[];
+    isLoading?: boolean;
+    hasError?: boolean;
+    filterRef?: React.RefObject<HTMLElement>;
+    onAddArea?: (drawingListItem: DrawingListItem) => void;
+    onRemoveArea?: (drawingListItem: DrawingListItem) => void;
+    selectedAreas?: Area[];
+    isChangeAreaDisabled?: boolean;
+    shouldDisableRemoveWarning?: boolean;
+}>;
+export {};

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

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { ApiModule, ApiUrls } from '@opengeoweb/api';
+import type { ExpandedWarningSections } from '../../store/warningsFilters/types';
+import type { PickedFilterState } from '../FilterList/filter-hooks';
+import type { MaritimeWarningsDomain } from '../MaritimeWarningsForm/types';
+export type WarningListComponentType = 'WarningList' | 'MaritimeWarnings' | 'WarningsTimeline';
+interface WarningsInitialProps {
+    filterState?: PickedFilterState;
+    expandedSections?: ExpandedWarningSections;
+    domain?: MaritimeWarningsDomain;
+}
+export interface ComponentsLookUpPayload {
+    componentType: WarningListComponentType;
+    id: string;
+    title?: string;
+    initialProps: WarningsInitialProps;
+}
+export interface ApiModuleProps extends ApiModule {
+    config: ApiUrls;
+}
+export declare const componentsLookUp: (payload: ComponentsLookUpPayload, ComponentsLookUpWrapper?: any) => React.ReactElement;
+export {};

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

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

package/dist/src/lib/components/DrawingTool/DrawingToolConnect.d.ts

@@ -0,0 +1,16 @@
+import type { TFunction } from 'i18next';
+import React from 'react';
+import { uiTypes } from '@opengeoweb/store';
+import type { DrawMode } from '@opengeoweb/webmap-react';
+export declare const getDialogType: (mapId: string, isMultiMap: boolean) => uiTypes.DialogType;
+export declare const translateDrawModes: (drawModes: DrawMode[], translateFn: TFunction) => DrawMode[];
+interface DrawingToolConnectProps {
+    mapId?: string;
+    bounds?: string;
+    title?: string;
+    showMapIdInTitle?: boolean;
+    isMultiMap?: boolean;
+    source?: uiTypes.Source;
+}
+declare const DrawingToolConnect: React.FC<DrawingToolConnectProps>;
+export default DrawingToolConnect;

package/dist/src/lib/components/DrawingTool/DrawingToolDialog.d.ts

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

package/dist/src/lib/components/DrawingTool/DrawingToolMapButtonConnect.d.ts

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

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

@@ -0,0 +1,3 @@
+export { default as DrawingToolMapButtonConnect } from './DrawingToolMapButtonConnect';
+export { default as DrawingToolConnect } from './DrawingToolConnect';
+export { useObjectDrawDialogAction } from './useObjectDrawDialogAction';

package/dist/src/lib/components/DrawingTool/useObjectDrawDialogAction.d.ts

@@ -0,0 +1,25 @@
+import type { TFunction } from 'i18next';
+import type { ConfirmationOptions } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+export declare const confirmationDialogOptions: (t: TFunction) => ConfirmationOptions;
+export declare const useCloseDrawDialog: ({ mapId, source, }: {
+    mapId: string;
+    source?: uiTypes.Source;
+}) => {
+    closeDrawDialog: (skipConfirmationDialog?: boolean) => void;
+};
+export declare const useCloseObjectDialog: ({ mapId, source, }: {
+    mapId: string;
+    source?: uiTypes.Source;
+}) => {
+    closeObjectDialog: (shouldReset?: boolean) => void;
+};
+export declare const useObjectDrawDialogAction: ({ mapId, source, }: {
+    mapId: string;
+    source?: uiTypes.Source;
+}) => {
+    openDrawDialog: (geoJSON?: GeoJSON.FeatureCollection) => void;
+    closeDrawDialog: () => void;
+    openObjectDialog: () => void;
+    closeObjectDialog: (shouldReset?: boolean) => void;
+};

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

@@ -0,0 +1,26 @@
+import type { FeatureCollection, GeoJsonProperties, Geometry } from 'geojson';
+import React from 'react';
+import type { DrawMode } from '@opengeoweb/webmap-react';
+import type { DrawingToolFormValues } from './DrawingToolFormContents';
+export declare const opacityOptions: number[];
+export declare const getObjectName: (objectName: string) => string;
+export interface DrawingToolFormComponentProps {
+    onSubmitForm: (formValues: DrawingToolFormValues) => void;
+    objectName?: string;
+    isLoading?: boolean;
+    dialogError?: string;
+    id?: string;
+    drawModes: DrawMode[];
+    onChangeDrawMode: (newMode: DrawMode) => void;
+    activeDrawModeId: string;
+    onDeactivateTool: () => void;
+    isInEditMode: boolean;
+    geoJSONProperties: GeoJSON.GeoJsonProperties;
+    onChangeProperties: (properties: GeoJSON.GeoJsonProperties) => void;
+    onChangeName: (name: string) => void;
+    onFormDirty?: (isFormDirty: boolean) => void;
+    geoJSON: FeatureCollection<Geometry, GeoJsonProperties> | undefined;
+}
+declare const Wrapper: React.FC<DrawingToolFormComponentProps>;
+export { Wrapper as DrawingToolForm };
+export default Wrapper;

package/dist/src/lib/components/DrawingToolForm/DrawingToolFormConnect.d.ts

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

package/dist/src/lib/components/DrawingToolForm/DrawingToolFormContents.d.ts

@@ -0,0 +1,28 @@
+import type { SelectChangeEvent } from '@mui/material';
+import React from 'react';
+import type { FieldErrors, FieldValues } from 'react-hook-form';
+import type { DrawMode } from '@opengeoweb/webmap-react';
+export declare const opacityOptions: number[];
+export interface DrawingToolFormValues {
+    objectName: string;
+    geoJSON: GeoJSON.FeatureCollection;
+    id: string;
+}
+export interface DrawingToolFormContentsProps {
+    isLoading?: boolean;
+    dialogError?: string;
+    id?: string;
+    drawModes: DrawMode[];
+    activeDrawModeId: string;
+    opacity: number;
+    isInEditMode: boolean;
+    isDirty: boolean;
+    errors: FieldErrors<FieldValues>;
+    onChangeDrawMode: (newMode: DrawMode) => void;
+    onChangeOpacity: (event: SelectChangeEvent<unknown>) => void;
+    onBlurName: (event: React.FocusEvent<HTMLInputElement>) => void;
+    onSubmit: () => void;
+    geoJSONProperties?: GeoJSON.GeoJsonProperties;
+}
+export declare const DrawingToolFormContentsNoMemo: React.FC<DrawingToolFormContentsProps>;
+export declare const DrawingToolFormContents: React.NamedExoticComponent<DrawingToolFormContentsProps>;

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

@@ -0,0 +1,2 @@
+export { default as DrawingToolForm } from './DrawingToolForm';
+export { DrawingToolFormConnect } from './DrawingToolFormConnect';

package/dist/src/lib/components/FilterList/ExpandableFilterChip.d.ts

@@ -0,0 +1,9 @@
+import type { PickedFilterState, UpdateFilter } from './filter-hooks';
+type IdType = Exclude<keyof PickedFilterState, 'time'>;
+export interface ExpandableFilterChipProps {
+    id: IdType;
+    options: PickedFilterState[IdType];
+    updateFilter: UpdateFilter;
+}
+declare const ExpandableFilterChip: React.FC<ExpandableFilterChipProps>;
+export default ExpandableFilterChip;

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

@@ -0,0 +1,13 @@
+import type { FC } from 'react';
+import type { PickedFilterState, UpdateFilter } from './filter-hooks';
+import type { TimeFilter } from './filter-utils';
+interface FilterListProps {
+    onClickAll?: (isChecked: boolean) => void;
+    isAllSelected?: boolean;
+    filterState: PickedFilterState;
+    updateFilter: UpdateFilter;
+    timeFilter: TimeFilter;
+    onUpdateTimeFilter: (timeFilter: TimeFilter) => void;
+}
+declare const FilterList: FC<FilterListProps>;
+export default FilterList;

package/dist/src/lib/components/FilterList/TimeFilterChip.d.ts

@@ -0,0 +1,7 @@
+import type { TimeFilter } from './filter-utils';
+interface TimeFilterChipProps {
+    timeFilter: TimeFilter;
+    onUpdateTimeFilter: (timeFilter: TimeFilter) => void;
+}
+declare const TimeFilterChip: React.FC<TimeFilterChipProps>;
+export default TimeFilterChip;

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

@@ -0,0 +1,31 @@
+import type { defaultDomainFilter, defaultPhenomenonFilter, TimeFilter } from './filter-utils';
+import { AllPhenomenaKeys, defaultEmptyFilter, defaultLevelFilter, Domain } from './filter-utils';
+import type { Warning } from '../../store/warningsForm/types';
+export interface PickedFilterState {
+    source: Partial<typeof defaultEmptyFilter>;
+    domain: Partial<typeof defaultDomainFilter>;
+    phenomenon: Partial<typeof defaultPhenomenonFilter>;
+    level: Partial<typeof defaultLevelFilter>;
+    time: TimeFilter;
+}
+export interface FilterState extends PickedFilterState {
+    source: typeof defaultEmptyFilter;
+    domain: typeof defaultDomainFilter;
+    phenomenon: typeof defaultPhenomenonFilter;
+    level: typeof defaultLevelFilter;
+    time: TimeFilter;
+}
+export type FilterKeyType = keyof FilterState;
+export type OptionKey<T extends FilterKeyType> = keyof FilterState[T];
+export type UpdateFilter = <T extends FilterKeyType>(filterKey: T | 'ALL', optionKey: OptionKey<T> | 'ALL', value: boolean, only?: boolean) => void;
+export interface FilterHookState {
+    allSelected: boolean;
+    updateFilter: UpdateFilter;
+    updateTimeFilter: (timeFilter: TimeFilter) => void;
+    byFilterState: (warning: Warning) => boolean;
+    filterState: PickedFilterState;
+    timeFilter: TimeFilter;
+}
+export declare const getPhenomenaForDomainFilter: (domainFilter: Record<Domain, boolean>) => (keyof typeof AllPhenomenaKeys)[];
+export declare const createWarningFilterPredicate: (warnings: Warning[], savedFilterState: FilterState) => ((warning: Warning) => boolean);
+export declare const useWarningFilters: (warnings: Warning[], onUpdateFilters: (filterState: Partial<FilterState>, systemUpdate?: boolean) => void, savedFilterState: FilterState, presetFilterState?: PickedFilterState) => FilterHookState;

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

@@ -0,0 +1,2 @@
+import type { ColorDefinition } from '../PublicWarningsForm/LevelField';
+export declare const warningColors: Record<string, ColorDefinition | undefined>;