@opengeoweb/core 19.0.0 → 19.1.1

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import coreTranslations from '../locales/core.json';
+export * from './lib';
+export { CORE_NAMESPACE } from './lib/utils/i18n';
+export { coreTranslations };

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

@@ -0,0 +1,4 @@
+import type { FC } from 'react';
+export declare const ClockConnect: FC<{
+    mapId: string;
+}>;

package/dist/src/lib/components/ClockConnect/OptionsMenu.d.ts

@@ -0,0 +1,10 @@
+import type { FC } from 'react';
+export type PopperPlacement = 'right' | 'left' | 'top' | 'bottom';
+export declare const getPopperplacement: (buttonElement: HTMLButtonElement | null, mapId: string) => PopperPlacement;
+export interface OptionsMenuProps {
+    isOpen?: boolean;
+    popperPlacement: PopperPlacement;
+    buttonElement: HTMLButtonElement | null;
+    mapId: string;
+}
+export declare const OptionsMenu: FC<OptionsMenuProps>;

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

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

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

@@ -0,0 +1,62 @@
+import React from 'react';
+import type { Coordinates, PlotPreset, SourceSelection, TimeSeriesService } from '@opengeoweb/shared';
+import type { mapTypes } from '@opengeoweb/store';
+import type { InitialHarmTempAndPrecipProps } from '../MultiMapViewConnect/HarmoniePresets';
+import type { ModelRunIntervalProps } from '../MultiMapViewConnect/ModelRunInterval';
+export interface InitialMultiMapProps {
+    mapPreset: mapTypes.MapPreset[];
+    syncGroupsIds: string[];
+    shouldShowZoomControls?: boolean;
+}
+export interface InitialSliderProps {
+    sliderPreset: {
+        mapId: string;
+    };
+    syncGroupsIds: string[];
+}
+export interface InitialMapProps {
+    mapPreset: mapTypes.MapPreset;
+    syncGroupsIds: string[];
+    mapControls?: React.ReactNode;
+    shouldDisplayDrawControls?: boolean;
+    displaySearchButtonInMap?: boolean;
+    displayDataExplorerButtonOnMap?: boolean;
+}
+export interface InitialTimeSeriesProps {
+    plotPreset: PlotPreset;
+    services: TimeSeriesService[];
+    hideLocationMarkers?: boolean;
+    syncGroupsIds: string[];
+}
+export interface InitialSoundingsProps {
+    selectedSources: Record<string, SourceSelection>;
+    selectedLocations: Record<string, string | Coordinates | undefined>;
+    selectedTime?: string;
+    diagramType?: 'SKEWT' | 'BIJVOET' | 'EMAGRAM';
+    syncGroupsIds: string[];
+}
+export interface InitialPluginProps {
+    id: string;
+    name: string;
+    url: string;
+    author?: {
+        name?: string;
+    };
+    version?: string;
+    description?: string;
+    license?: string;
+}
+export type InitialProps = InitialMapProps | InitialMultiMapProps | InitialHarmTempAndPrecipProps | ModelRunIntervalProps | mapTypes.MapPresetInitialProps | InitialSliderProps | InitialTimeSeriesProps | InitialSoundingsProps | InitialPluginProps | Record<string, unknown>;
+/**
+ * The lookup table is for registering your own components with the workspace.
+ * @param payload
+ * @returns
+ */
+export type SupportedComponentTypes = 'Map' | 'MultiMap' | 'ModelRunInterval' | 'HarmonieTempAndPrecipPreset' | 'TimeSlider';
+export interface ComponentsLookUpPayload {
+    componentType: SupportedComponentTypes;
+    id: string;
+    title?: string;
+    initialProps: InitialProps;
+}
+export declare const componentsLookUp: ({ componentType, initialProps, id, }: ComponentsLookUpPayload) => React.ReactElement;

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

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

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

@@ -0,0 +1,51 @@
+import type { StyleLike } from 'ol/style/Style';
+import React from 'react';
+import type { mapTypes, layerTypes } from '@opengeoweb/store';
+import type { TileServerSettings } from '@opengeoweb/webmap';
+export declare const defaultBbox: {
+    srs: "EPSG:3857";
+    bbox: {
+        left: number;
+        bottom: number;
+        right: number;
+        top: number;
+    };
+};
+export interface ConfigurableMapConnectProps {
+    id?: string;
+    dockedLayerManagerSize?: mapTypes.DockedLayerManagerSize;
+    shouldAutoUpdate?: boolean;
+    shouldAnimate?: boolean;
+    shouldAutoFetch?: boolean | number;
+    title?: string;
+    layers: layerTypes.Layer[];
+    tileServerSettings?: TileServerSettings;
+    autoUpdateLayerId?: string;
+    autoTimeStepLayerId?: string;
+    initialBbox?: mapTypes.Bbox;
+    srs?: string;
+    dimensions?: mapTypes.Dimension[];
+    animationPayload?: mapTypes.AnimationPayloadType;
+    shouldShowZoomControls?: boolean;
+    displayMapPin?: boolean;
+    showTimeSlider?: boolean;
+    disableTimeSlider?: boolean;
+    toggleTimestepAuto?: boolean;
+    displayTimeInMap?: boolean;
+    displayLayerManagerAndLegendButtonInMap?: boolean;
+    displayDimensionSelectButtonInMap?: boolean;
+    multiLegend?: boolean;
+    shouldShowLayerManager?: boolean;
+    shouldShowDockedLayerManager?: boolean;
+    isClockEnabled?: boolean;
+    displayGetFeatureInfoButtonInMap?: boolean;
+    shouldDisplayDrawControls?: boolean;
+    displaySearchButtonInMap?: boolean;
+    displayDataExplorerButtonOnMap?: boolean;
+    children?: React.ReactNode;
+    mapControls?: React.ReactNode;
+    shouldDisablePrefetching?: boolean;
+    featureStyle?: StyleLike;
+    shouldDisplayMeasureToolButton?: boolean;
+}
+export declare const ConfigurableMapConnect: React.FC<ConfigurableMapConnectProps>;

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

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

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

@@ -0,0 +1,14 @@
+import React from 'react';
+export declare const languages: {
+    language: string;
+    code: string;
+    flag: React.ReactElement;
+}[];
+export declare const languageLocalStorageKey = "language";
+export declare const getLanguageFromLocalStorage: () => string | null;
+export declare const saveLanguageToLocalStorage: (languageKey: string) => void;
+declare const LanguageSelect: React.FC<{
+    onChangeLanguage: (currentLanguage: string) => void;
+    isOpen?: boolean;
+}>;
+export default LanguageSelect;

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

@@ -0,0 +1 @@
+export { default as LanguageSelect, getLanguageFromLocalStorage, saveLanguageToLocalStorage, languageLocalStorageKey, } from './LanguageSelect';

package/dist/src/lib/components/LayerInfoConnect/LayerInfoButtonConnect.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { uiTypes } from '@opengeoweb/store';
+interface LayerInfoButtonProps {
+    isLayerMissing?: boolean;
+    isFeatureLayer?: boolean;
+    mapId: string;
+    serviceUrl: string;
+    layerName: string;
+    layerId: string;
+    source?: uiTypes.Source;
+}
+export declare const LayerInfoButtonConnect: React.FC<LayerInfoButtonProps>;
+export {};

package/dist/src/lib/components/LayerInfoConnect/LayerInfoDialogConnect.d.ts

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

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

@@ -0,0 +1,2 @@
+export * from './LayerInfoButtonConnect';
+export * from './LayerInfoDialogConnect';

package/dist/src/lib/components/LayerManager/AddLayersButton/AddLayersButton.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { serviceTypes } from '@opengeoweb/store';
+import { LayerType } from '@opengeoweb/webmap';
+interface AddLayerButtonProps {
+    onRenderTree?: (service: serviceTypes.InitialService) => React.ReactNode;
+    preloadedServices?: serviceTypes.InitialService[];
+    tooltip?: string;
+    layerType?: LayerType;
+    shouldFocus?: boolean;
+}
+declare const AddLayersButton: React.FC<AddLayerButtonProps>;
+export default AddLayersButton;

package/dist/src/lib/components/LayerManager/AddLayersPopup/AddLayersPopup.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { serviceTypes } from '@opengeoweb/store';
+import { LayerType } from '@opengeoweb/webmap';
+interface AddLayerPopupProps {
+    onRenderTree?: (service: serviceTypes.InitialService) => React.ReactNode;
+    preloadedServices?: serviceTypes.InitialService[];
+    open?: boolean;
+    handleClose?: () => void;
+    layerType?: LayerType;
+}
+declare const AddLayersPopup: React.FC<AddLayerPopupProps>;
+export default AddLayersPopup;

package/dist/src/lib/components/LayerManager/AddLayersPopup/WMSLayerTree/WMSLayerTree.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { layerTypes, serviceTypes } from '@opengeoweb/store';
+interface WMSLayerTreeProps {
+    service: serviceTypes.InitialService;
+    onClickLayer: (serviceURL: string, layerName: string) => void;
+    highlightedLayers: layerTypes.Layer[];
+}
+declare const WMSLayerTree: React.FC<WMSLayerTreeProps>;
+export default WMSLayerTree;

package/dist/src/lib/components/LayerManager/AddLayersPopup/WMSLayerTree/WMSLayerTreeConnect.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { serviceTypes } from '@opengeoweb/store';
+import { layerActions, layerTypes } from '@opengeoweb/store';
+import { LayerType } from '@opengeoweb/webmap';
+export interface WMSLayerTreeConnectProps {
+    service: serviceTypes.InitialService;
+    addLayer?: typeof layerActions.addLayer;
+    setBaseLayers?: typeof layerActions.setBaseLayers;
+    addAvailableBaseLayer?: typeof layerActions.addAvailableBaseLayer;
+    mapId: string;
+    loadedLayers?: layerTypes.Layer[];
+    layerType?: LayerType;
+}
+declare const WMSLayerTreeConnect: import("react-redux").ConnectedComponent<React.FC<WMSLayerTreeConnectProps>, {
+    mapId: string;
+    layerType?: LayerType | undefined;
+    service: serviceTypes.InitialService;
+    addLayer?: typeof layerActions.addLayer | undefined;
+    setBaseLayers?: typeof layerActions.setBaseLayers | undefined;
+    addAvailableBaseLayer?: typeof layerActions.addAvailableBaseLayer | undefined;
+    loadedLayers?: layerTypes.Layer[] | undefined;
+    context?: React.Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction> | null> | undefined;
+    store?: import("redux").Store | undefined;
+}>;
+export default WMSLayerTreeConnect;

package/dist/src/lib/components/LayerManager/AddLayersPopup/WMSLayerTree/WMSLayerTreeHeader.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface WMSLayerTreeHeaderProps {
+    serviceName: string;
+    onClickReload?: () => void;
+}
+declare const WMSLayerTreeHeader: React.FC<WMSLayerTreeHeaderProps>;
+export default WMSLayerTreeHeader;

package/dist/src/lib/components/LayerManager/AddLayersPopup/WMSServerList/WMSServerList.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { serviceTypes } from '@opengeoweb/store';
+interface WMSServerListProps {
+    availableServices: serviceTypes.InitialService[];
+    handleChangeService: (service: serviceTypes.InitialService) => void;
+    service: serviceTypes.InitialService;
+}
+declare const WMSServerList: React.FC<WMSServerListProps>;
+export default WMSServerList;

package/dist/src/lib/components/LayerManager/BaseLayerRow/BaseLayerRow.d.ts

@@ -0,0 +1,13 @@
+import { Grid } from '@mui/material';
+import React from 'react';
+import type { layerTypes, serviceTypes } from '@opengeoweb/store';
+import type { LayerManagerCustomSettings } from '../LayerManagerUtils';
+interface BaseLayerRowProps extends React.ComponentProps<typeof Grid> {
+    mapId: string;
+    preloadedAvailableBaseLayers?: layerTypes.Layer[];
+    preloadedServices?: serviceTypes.InitialService[];
+    tooltip?: string;
+    settings?: LayerManagerCustomSettings['footer'];
+}
+declare const BaseLayerRow: React.FC<BaseLayerRowProps>;
+export default BaseLayerRow;

package/dist/src/lib/components/LayerManager/BaseLayerRow/BaseLayers/BaseLayers.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { layerTypes } from '@opengeoweb/store';
+interface BaseLayersProps {
+    selectedBaseLayers: layerTypes.Layer[];
+    availableBaseLayers: layerTypes.Layer[];
+    onChangeBaseLayers: (name: string) => void;
+    icon?: React.ElementType;
+    tooltipPrefix?: string;
+}
+declare const BaseLayers: React.FC<BaseLayersProps>;
+export default BaseLayers;

package/dist/src/lib/components/LayerManager/BaseLayerRow/BaseLayers/BaseLayersConnect.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { layerTypes } from '@opengeoweb/store';
+export declare const constructLayerId: (baseLayer: layerTypes.Layer, selectedBaseLayers: layerTypes.Layer[]) => string;
+export declare const constructListAvailableBaseLayers: (selectedBaseLayers: layerTypes.Layer[], preloadedAvailableBaseLayers: layerTypes.Layer[], mapId: string) => layerTypes.Layer[];
+export declare const areAvailableBaseLayersSame: (availableBaseLayerList: layerTypes.Layer[], newBaseLayerList: layerTypes.Layer[]) => boolean;
+interface BaseLayersConnectProps {
+    mapId: string;
+    preloadedAvailableBaseLayers: layerTypes.Layer[];
+    tooltipPrefix?: string;
+    icon?: React.ElementType;
+}
+declare const BaseLayersConnect: React.FC<BaseLayersConnectProps>;
+/**
+ * Allows you to select a baselayer
+ *
+ * Expects the following props:
+ * @param {string} mapId mapId: string - Id of the map
+ * @param {layerTypes.Layer[]} preloadedAvailableBaseLayers preloadedAvailableBaseLayers: array of layerTypes.Layer objects - contains an array of layerTypes.Layer objects (consisting solely of type baseLayer) that are available to be shown as basemaps
+ * @example
+ * ``` <BaseLayersConnect mapId="mapid_1" preloadedAvailableBaseLayers = {baseLayersList} /> ```
+ */
+export default BaseLayersConnect;

package/dist/src/lib/components/LayerManager/DescriptionRow/DescriptionRow.d.ts

@@ -0,0 +1,13 @@
+import { Grid } from '@mui/material';
+import React from 'react';
+import type { uiTypes } from '@opengeoweb/store';
+import type { LayerManagerCustomSettings } from '../LayerManagerUtils';
+interface DescriptionRowProps extends React.ComponentProps<typeof Grid> {
+    source?: uiTypes.Source;
+    settings?: LayerManagerCustomSettings['header'];
+    addLayerComponent?: React.ReactElement;
+    onToggleCollapsed?: (name: string) => void;
+    collapsedColumns?: Record<string, boolean>;
+}
+declare const DescriptionRow: React.FC<DescriptionRowProps>;
+export default DescriptionRow;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerContainerRow.d.ts

@@ -0,0 +1,19 @@
+import { Grid } from '@mui/material';
+import React from 'react';
+import type { LayerManagerCustomSettings } from '../LayerManagerUtils';
+interface LayerContainerRowProps extends React.ComponentProps<typeof Grid> {
+    mapId: string;
+    settings?: LayerManagerCustomSettings['content'];
+    collapsedColumns?: Record<string, boolean>;
+}
+declare const LayerContainerRow: React.FC<LayerContainerRowProps>;
+/**
+ * A Connected container component for rendering a sortable set of rows
+ *
+ * Expects the following props:
+ * @param {string} mapId mapId: string - Id of the map
+ * @param {LayerManagerWidth} layerManagerWidth layerManagerWidth: LayerManagerWidth - Width of the Layer Manager
+ * @example
+ * ``` <LayerContainerRow mapId={mapId} layerManagerWidth={LayerManagerWidth.lg} />```
+ */
+export default LayerContainerRow;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/AcceptanceTime/AcceptanceTime.d.ts

@@ -0,0 +1,10 @@
+import type { FC } from 'react';
+import React from 'react';
+export declare const AcceptanceTime: FC<{
+    isEnabled?: boolean;
+    acceptanceTimeInMinutes: number | null | undefined;
+    onChangeAcceptanceTime: (acceptanceTime: number | null) => void;
+    icon?: React.ElementType;
+    tooltipTitle?: string;
+    skipLocalStyling?: boolean;
+}>;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/AcceptanceTime/AcceptanceTimeConnect.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+import React from 'react';
+export declare const AcceptanceTimeConnect: FC<{
+    layerId: string | undefined;
+    icon?: React.ElementType;
+    tooltipTitle?: string;
+    skipLocalStyling?: boolean;
+    mapId: string;
+}>;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/ActivateLayer/ActivateLayer.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export declare enum AutoOptions {
+    BOTH = "Auto both",
+    NONE = "Auto none",
+    TIMESTEP = "Auto-timestep",
+    UPDATE = "Auto-update"
+}
+interface ActivateLayerProps {
+    onChange: (autoOption: AutoOptions) => void;
+    isEnabled: boolean;
+    current: AutoOptions;
+}
+declare const ActivateLayer: React.FC<ActivateLayerProps>;
+export default ActivateLayer;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/ActivateLayer/ActivateLayerConnect.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface ActivateLayerProps {
+    layerId: string;
+    mapId: string;
+}
+declare const ActivateLayerConnect: React.FC<ActivateLayerProps>;
+/**
+ * Activates a maplayer from the store
+ *
+ * Expects the following props:
+ * @param {string} mapId mapId: string - Id of the map
+ * @param {string} layerId layerId: string - Id of the layer that is activated
+ * @example
+ * ``` <ActivateLayerConnect mapId={mapId} layerId={layerId} />```
+ */
+export default ActivateLayerConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/CustomDimensionSelect/CustomDimensionSelectConnect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { LayerManagerCustomSettings } from '../../../LayerManagerUtils';
+import type { DimensionSelectProps } from '../DimensionSelect/DimensionSelectConnect';
+type Content = NonNullable<LayerManagerCustomSettings['content']>;
+type Dimensions = NonNullable<Content['dimensions']>;
+type DimensionsSettingsProps = Omit<Dimensions, 'nameMappings'>;
+type CustomDimensionSelectProps = DimensionSelectProps & DimensionsSettingsProps;
+declare const CustomDimensionSelectConnect: React.FC<CustomDimensionSelectProps>;
+export default CustomDimensionSelectConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/DeleteLayer/DeleteLayerConnect.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface DeleteLayerProps {
+    layerId: string;
+    mapId: string;
+    tooltipTitle?: string;
+    icon?: React.ReactNode;
+}
+declare const DeleteLayerConnect: React.FC<DeleteLayerProps>;
+/**
+ * Deletes a maplayer from the store
+ *
+ * Expects the following props:
+ * @param {string} mapId mapId: string - Id of the map
+ * @param {string} layerId layerId: string - Id of the layer that is deleted
+ * @example
+ * ``` <DeleteLayerConnect mapId={mapId} layerId={layerId} />```
+ */
+export default DeleteLayerConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/DimensionSelect/DimensionSelect.d.ts

@@ -0,0 +1,28 @@
+import type { TFunction } from 'i18next';
+import type { ElementType, FC } from 'react';
+import React from 'react';
+import type { mapTypes, layerTypes } from '@opengeoweb/store';
+import type { DimensionNameMappings, DimensionValueMappings } from '../../../LayerManagerUtils';
+export interface SingleValueComponentProps extends mapTypes.Dimension {
+    position: 'dimension' | 'value';
+    nameMappings?: DimensionNameMappings;
+    valueMappings?: DimensionValueMappings;
+}
+export type DimensionTooltipGenerator = (t: TFunction, selectedDimension: mapTypes.Dimension, isValue?: boolean) => string;
+export interface DimensionSelectProps {
+    layerDimensions?: mapTypes.Dimension[];
+    onLayerChangeDimension: (dimensionName: string, dimensionValue: string, origin?: layerTypes.LayerActionOrigin.layerManager) => void;
+    isEnabled?: boolean;
+    icon?: ElementType;
+    nameMappings?: DimensionNameMappings;
+    valueMappings?: DimensionValueMappings;
+    tooltipGenerator?: DimensionTooltipGenerator;
+    useLatestReferenceTime?: boolean;
+    setUseLatestReferenceTime?: (useLatestReferenceTime: boolean) => void;
+    SingleValueComponent?: React.FC<SingleValueComponentProps>;
+    hideLatestDuplicate?: boolean;
+    skipLocalStyling?: boolean;
+    layerId: string;
+}
+declare const DimensionSelect: FC<DimensionSelectProps>;
+export default DimensionSelect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/DimensionSelect/DimensionSelectConnect.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface DimensionSelectProps {
+    layerId: string;
+    mapId: string;
+    skipLocalStyling?: boolean;
+}
+declare const DimensionSelectConnect: React.FC<DimensionSelectProps>;
+export default DimensionSelectConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/DimensionSelect/DimensionSelectName.d.ts

@@ -0,0 +1,13 @@
+import type { ElementType, FC } from 'react';
+import type { DimensionNameMappings } from '../../../LayerManagerUtils';
+declare const DimensionSelectName: FC<{
+    dimensionNames: string[];
+    selectedDimensionName: string;
+    setSelectedDimensionName: (dimension: string) => void;
+    icon?: ElementType;
+    nameMappings?: DimensionNameMappings;
+    tooltip: string;
+    isEnabled: boolean;
+    skipLocalStyling?: boolean;
+}>;
+export default DimensionSelectName;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/DimensionSelect/DimensionSelectValue.d.ts

@@ -0,0 +1,26 @@
+import type { ElementType, FC } from 'react';
+import type { mapTypes } from '@opengeoweb/store';
+import { layerTypes } from '@opengeoweb/store';
+import type { DimensionValueMappings } from '../../../LayerManagerUtils';
+export declare enum LatestOptions {
+    LATEST_0 = "Latest",
+    LATEST_1 = "Latest -1",
+    LATEST_2 = "Latest -2",
+    LATEST_3 = "Latest -3"
+}
+declare const DimensionSelectValue: FC<{
+    selectedDimension?: Omit<mapTypes.Dimension, 'currentValue'> & {
+        currentValue?: string;
+    };
+    generatedValues: string[];
+    icon?: ElementType;
+    tooltip: string;
+    isEnabled: boolean;
+    onLayerChangeDimension: (dimensionName: string, dimensionValue: string, origin?: layerTypes.LayerActionOrigin.layerManager) => void;
+    valueMappings?: DimensionValueMappings;
+    hideLatestDuplicate?: boolean;
+    useLatestReferenceTime?: boolean;
+    skipLocalStyling?: boolean;
+    setUseLatestReferenceTime?: (useLatestReferenceTime: boolean) => void;
+}>;
+export default DimensionSelectValue;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/DimensionSelect/dimensionSelectHooks.d.ts

@@ -0,0 +1,15 @@
+import type { layerTypes, mapTypes } from '@opengeoweb/store';
+interface LayerChangeDimensionParams {
+    dimension: mapTypes.Dimension;
+    origin: layerTypes.LayerActionOrigin | undefined;
+}
+export declare const useLayerDimensions: (layerId: string, mapId: string) => {
+    layerDimensions: mapTypes.Dimension[];
+    isLayerEnabled: boolean;
+    layerChangeDimension: ({ dimension, origin, }: LayerChangeDimensionParams) => void;
+};
+export declare const useReferenceTimeWithLatestOption: (layerId: string) => {
+    useLatestReferenceTime: boolean;
+    setUseLatestReferenceTime: (useLatestReferenceTime: boolean) => void;
+};
+export {};

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/DragHandle/DragHandle.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+interface DragHandleProps {
+    isDisabled?: boolean;
+    hideTooltip?: boolean;
+    isSorting?: boolean;
+    icon?: ReactNode;
+    tooltipTitle?: string;
+}
+declare const DragHandle: React.FC<DragHandleProps>;
+export default DragHandle;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/EnableLayer/EnableLayerConnect.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+interface EnableLayerProps {
+    layerId: string;
+    mapId: string;
+    isEnabled?: boolean;
+    layerName?: string;
+    icon?: React.ReactNode;
+    tooltipTitle?: string;
+}
+declare const EnableLayerConnect: React.FC<EnableLayerProps>;
+/**
+ * Allows you to show/hide a layer on the map
+ *
+ * Expects the following props:
+ * @param {string} layerId layerId: string - Id of the layer that is toggled
+ * @example
+ * ``` <EnableLayerConnect layerId={layerId} />```
+ */
+export default EnableLayerConnect;

package/dist/src/lib/components/LayerManager/LayerContainerRow/LayerRow/LayerRow.d.ts

@@ -0,0 +1,67 @@
+import React from 'react';
+import type { serviceTypes, mapTypes, layerTypes } from '@opengeoweb/store';
+interface LayerRowUnstyledProps {
+    layerId?: string;
+    layer?: layerTypes.Layer;
+    layerName?: string;
+    layerServiceName?: string;
+    mapId: string;
+    isEDRLayer?: boolean;
+    onLayerRowClick?: (layerId?: string) => void;
+    onLayerEnable?: (payload: {
+        layerId: string;
+        enabled: boolean;
+    }) => void;
+    onLayerChangeName?: (payload: {
+        layerId: string;
+        name: string;
+    }) => void;
+    onLayerChangeStyle?: (payload: {
+        layerId: string;
+        style: string;
+    }) => void;
+    onLayerChangeOpacity?: (payload: {
+        layerId: string;
+        opacity: number;
+    }) => void;
+    onLayerChangeDimension?: (payload: {
+        origin: string;
+        layerId: string;
+        dimension: mapTypes.Dimension;
+    }) => void;
+    onLayerDelete?: (payload: {
+        mapId: string;
+        layerId: string;
+    }) => void;
+    onLayerDuplicate?: (payload: {
+        mapId: string;
+        layerId: string;
+    }) => void;
+    onChangeAcceptanceTime?: (payload: {
+        layerId: string;
+        acceptanceTime: number | null;
+    }) => void;
+    layerEnableLayout?: React.ReactElement;
+    layerServicesLayout?: React.ReactElement;
+    layerStylesLayout?: React.ReactElement;
+    layerOpacityLayout?: React.ReactElement;
+    layerDimensionLayout?: React.ReactElement;
+    layerAcceptanceTimeLayout?: React.ReactElement;
+    layerMissingDataLayout?: React.ReactElement;
+    layerDeleteLayout?: React.ReactElement;
+    layerShowLayerInfoLayout?: React.ReactElement;
+    layerMenuLayout?: React.ReactElement;
+    layerActiveLayout?: React.ReactElement;
+    layerLoadDurationLayout?: React.ReactElement;
+    disableActivateLayer?: boolean;
+    services?: serviceTypes.Services;
+    isEnabled?: boolean;
+    dragHandle?: React.ReactElement;
+    isLayerMissing?: boolean;
+    className?: string;
+    collapsedColumns?: Record<string, boolean>;
+}
+declare const LayerRow: import("@emotion/styled").StyledComponent<LayerRowUnstyledProps & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme> & {
+    isEnabled?: boolean;
+}, {}, {}>;
+export default LayerRow;