@opengeoweb/time-series 19.1.0 → 19.2.0

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import timeseriesTranslations from '../locales/timeseries.json';
+export * from './lib';
+export { TIME_SERIES_NAMESPACE } from './lib/utils/i18n';
+export { timeseriesTranslations };

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

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { TimeSeriesService } from '@opengeoweb/shared';
+import type { PlotPreset } from '../TimeSeries/types';
+interface InitialTimeseriesProps {
+    plotPreset: PlotPreset;
+    services: TimeSeriesService[];
+    hideLocationMarkers?: boolean;
+    syncGroupsIds: string[];
+}
+export type SupportedComponentTypes = 'TimeSeries';
+export type InitialProps = InitialTimeseriesProps;
+export interface ComponentsLookUpPayload {
+    componentType: SupportedComponentTypes;
+    id: string;
+    title?: string;
+    initialProps: InitialProps;
+}
+/**
+ * The lookup table is for registering your own components with the workspace.
+ * @param payload
+ * @returns
+ */
+export declare const componentsLookUp: ({ id: panelId, componentType, initialProps, }: ComponentsLookUpPayload) => React.ReactElement;
+export {};

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

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

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

@@ -0,0 +1,32 @@
+import type { Theme } from '@mui/material';
+import type { Store } from '@reduxjs/toolkit';
+import React from 'react';
+import type { ThemeProviderProps } from '@opengeoweb/theme';
+export declare const TimeSeriesThemeWrapper: React.FC<ThemeProviderProps>;
+interface TimeSeriesApiProviderProps {
+    children: React.ReactNode;
+}
+interface TimeSeriesThemeStoreProviderProps {
+    children?: React.ReactNode;
+    theme?: Theme;
+    store: Store;
+}
+interface TimeseriesTranslationWrapperProps {
+    children?: React.ReactNode;
+}
+/**
+ * A Provider component which returns the Api Provider for the TimeSeries library
+ * @param children
+ * @returns
+ */
+export declare const TimeSeriesApiProvider: React.FC<TimeSeriesApiProviderProps>;
+export interface TimeSeriesStoreProviderProps extends ThemeProviderProps {
+    store: Store;
+}
+export declare const TimeSerieStoreProvider: React.FC<{
+    children?: React.ReactNode;
+    store: Store;
+}>;
+export declare const TimeSeriesThemeStoreProvider: React.FC<TimeSeriesThemeStoreProviderProps>;
+export declare const TimeseriesI18nProvider: React.FC<TimeseriesTranslationWrapperProps>;
+export {};

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

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

package/dist/src/lib/components/TimeSeries/LocationDropdown/LocationDropdown.d.ts

@@ -0,0 +1,13 @@
+import type { FeatureCollection, GeometryObject } from 'geojson';
+import React from 'react';
+import type { GeoJsonWithService } from '../types';
+interface LocationDropdownProps {
+    splitGeoJson?: GeoJsonWithService[];
+    handleChange: (newSelectedLocation: string) => void;
+    selectedLocation: string;
+    geoJson?: FeatureCollection<GeometryObject>;
+    isDisabled?: boolean;
+    defaultExpanded?: boolean;
+}
+export declare const LocationDropdown: React.FC<LocationDropdownProps>;
+export {};

package/dist/src/lib/components/TimeSeries/LocationDropdown/LocationDropdownHeader.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface LocationDropdownHeaderProps {
+    searchTerm: string;
+    setSearchTerm: (value: string) => void;
+}
+export declare const LocationDropdownHeader: React.FC<LocationDropdownHeaderProps>;
+export {};

package/dist/src/lib/components/TimeSeries/LocationDropdown/LocationListItem.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface LocationListItemProps {
+    location: string;
+    handleChange: (newSelectedLocation: string) => void;
+    selectedLocation: string;
+    isDisabled?: boolean;
+}
+export declare const LocationListItem: React.FC<LocationListItemProps>;

package/dist/src/lib/components/TimeSeries/LocationDropdown/OverflowTooltip.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+interface OverflowTooltipProps {
+    text: string;
+    textContainerWidth: number;
+    children?: ReactNode;
+}
+export declare const OverflowTooltip: React.FC<OverflowTooltipProps>;
+export {};

package/dist/src/lib/components/TimeSeries/LocationDropdown/testData.d.ts

@@ -0,0 +1,2 @@
+import type { GeoJsonWithService } from '../types';
+export declare const testDataWith3Services: GeoJsonWithService[];

package/dist/src/lib/components/TimeSeries/LocationInfo/LocationInfo.d.ts

@@ -0,0 +1,30 @@
+import type { Feature, GeometryObject } from 'geojson';
+import type { TimeSeriesService } from '@opengeoweb/shared';
+import type { MapLocation } from '@opengeoweb/webmap-react';
+export interface ParameterInfo {
+    loading: boolean;
+    parameters: string[];
+}
+export interface CalculatedLocationCollectionInfo {
+    properties: Record<string, string>;
+    parameterIndex: number;
+}
+export interface CalculatedLocationInfo {
+    geometry: GeometryObject;
+    properties: Record<string, string>;
+    collections: CalculatedLocationCollectionInfo[];
+}
+export interface LocationInfoProps {
+    feature?: Feature<GeometryObject> | null;
+    mapPinLocation?: MapLocation;
+    services?: TimeSeriesService[];
+    isOpen: boolean;
+    onClose: () => void;
+    onMouseDown: () => void;
+    order: number;
+}
+export declare const LocationInfo: React.FC<LocationInfoProps>;
+export interface ParameterInfoTextProps {
+    label: string;
+    value: string;
+}

package/dist/src/lib/components/TimeSeries/LocationInfo/LocationInfoButtonConnect.d.ts

@@ -0,0 +1,7 @@
+import type { TFunction } from 'i18next';
+import React from 'react';
+export interface LocationInfoButtonConnectProps {
+    panelId: string;
+    t: TFunction;
+}
+export declare const LocationInfoButtonConnect: React.FC<LocationInfoButtonConnectProps>;

package/dist/src/lib/components/TimeSeries/LocationInfo/LocationInfoConnect.d.ts

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

package/dist/src/lib/components/TimeSeries/LocationSelect/LocationSelectButtonConnect.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface LocationSelectButtonConnectProps {
+    panelId: string;
+}
+export declare const LocationSelectButtonConnect: React.FC<LocationSelectButtonConnectProps>;
+export {};

package/dist/src/lib/components/TimeSeries/LocationSelect/LocationSelectDialogConnect.d.ts

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

package/dist/src/lib/components/TimeSeries/LocationSelect/index.d.ts

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

package/dist/src/lib/components/TimeSeries/TimeSeriesChart.d.ts

@@ -0,0 +1,34 @@
+import type { EChartsInstance, EChartsOption } from 'echarts-for-react';
+import ReactECharts from 'echarts-for-react';
+import React from 'react';
+import type { PlotWithData } from './types';
+export declare const useChartHeight: ({ plotsWithData, shouldShowLegend, option, onLegendHeightChange, }: {
+    plotsWithData: PlotWithData[];
+    shouldShowLegend: boolean;
+    option: EChartsOption;
+    onLegendHeightChange?: (height: number) => void;
+}) => {
+    chartHeight: number;
+    chartRef: React.RefObject<ReactECharts | null>;
+    updateHeight: (echartsInstance: EChartsInstance) => void;
+};
+export interface DataZoomState {
+    start: number;
+    end: number;
+}
+export declare const applyDataZoomState: (option: EChartsOption, dataZoomState: DataZoomState | null) => EChartsOption;
+export declare const extractDataZoomState: (params: {
+    start?: number;
+    end?: number;
+    batch?: {
+        start: number;
+        end: number;
+    }[];
+}) => DataZoomState | null;
+export declare const TimeSeriesChart: React.FC<{
+    plotsWithData: PlotWithData[];
+    animation?: boolean;
+    shouldShowLegend?: boolean;
+    onToggleLegendParam?: (legendId: string) => void;
+    onLegendHeightChange?: (height: number) => void;
+}>;

package/dist/src/lib/components/TimeSeries/TimeSeriesConnect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { TimeSeriesService } from '@opengeoweb/shared';
+import type { Parameter } from './types';
+import type { GetLocationsOption } from '../../utils/timeseries-api/hooks';
+export declare const getUniqueServicesFromPreset: (parameters: Parameter[], services: TimeSeriesService[]) => GetLocationsOption[];
+export interface TimeSeriesConnectProps {
+    panelId: string;
+}
+export declare const TimeSeriesConnect: React.FC<TimeSeriesConnectProps>;

package/dist/src/lib/components/TimeSeries/TimeSeriesConnectWrapper.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { TimeSeriesPreset } from '../../store/types';
+interface Props {
+    panelId: string;
+    timeSeriesPreset: TimeSeriesPreset;
+    hideLocationMarkers?: boolean;
+}
+export declare const TimeSeriesConnectWrapper: React.FC<Props>;
+export {};

package/dist/src/lib/components/TimeSeries/TimeSeriesMarkersSwitch.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface TimeSeriesMarkersSwitchProps {
+    shouldHideMarkers: boolean;
+    toggleMarkers: (shouldHideMarkers: boolean) => void;
+}
+export declare const TimeSeriesMarkersSwitch: React.FC<TimeSeriesMarkersSwitchProps>;

package/dist/src/lib/components/TimeSeries/TimeSeriesTopRowButton.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { CustomToggleButtonProps } from '@opengeoweb/shared';
+interface TimeSeriesButtonProps extends CustomToggleButtonProps {
+    icon: React.ReactNode;
+    shortText?: string;
+    longText: string;
+}
+export declare const TimeSeriesTopRowButton: import("@emotion/styled").StyledComponent<Omit<TimeSeriesButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
+export {};

package/dist/src/lib/components/TimeSeries/TimeSeriesView.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { PlotPreset, TimeSeriesService } from '@opengeoweb/shared';
+import type { TimeSliderStartEndStep } from '@opengeoweb/store';
+import type { PointerLocation, GeoJsonWithService } from './types';
+interface TimeSeriesViewProps {
+    plotPreset: PlotPreset;
+    selectedLocation: PointerLocation;
+    services: TimeSeriesService[];
+    splitGeoJsonByCollection: GeoJsonWithService[];
+    isLoading?: (startOrFinish: boolean) => void;
+    shouldShowLegend?: boolean;
+    onToggleLegendParam?: (legendId: string) => void;
+    syncgroupTimeState?: TimeSliderStartEndStep;
+}
+export declare const TimeSeriesView: React.FC<TimeSeriesViewProps>;
+export {};

package/dist/src/lib/components/TimeSeries/chartUtils.d.ts

@@ -0,0 +1,43 @@
+import type { EChartsOption, XAXisComponentOption, YAXisComponentOption, GridComponentOption, LineSeriesOption, BarSeriesOption, ScatterSeriesOption } from 'echarts';
+import type { ParameterWithData, Plot, PlotWithData } from './types';
+export declare const MIN_GRAPH_WIDTH = 300;
+export declare const dateFormatter: (date: string) => string;
+export declare const getTooltipTimeLabel: (date: string) => string;
+export declare const createParameterNames: (plotsWithData: PlotWithData[]) => {
+    name: string;
+    id: string;
+    enabled: boolean;
+}[];
+interface ParamIntervalType {
+    unit?: string;
+    propertyName?: string;
+    presentation?: string;
+    interval: number;
+    minNumberOfIntervals?: number;
+    maxNumberOfIntervals?: number;
+}
+export declare const paramIntervals: ParamIntervalType[];
+export declare const getYAxis: (plotCharts: PlotChart[]) => YAXisComponentOption[];
+export declare const getXAxis: (plotCharts: PlotChart[]) => XAXisComponentOption[];
+export declare const getParameterDisplayName: (parameter: ParameterWithData) => string;
+export declare const roundDecimalValues: (value: number) => string;
+export declare const getOption: (plotsWithData: PlotWithData[], shouldShowLegend?: boolean) => EChartsOption;
+export declare const getEChartsSeriesDataByTimestep: (timesteps: Date[], parameter: ParameterWithData) => (number | string)[][];
+export declare const getSeries: (plotCharts: PlotChart[], parameterNames: {
+    name: string;
+    id: string;
+}[]) => (LineSeriesOption | BarSeriesOption | ScatterSeriesOption)[];
+export declare const getGrid: (plotCharts: PlotChart[]) => GridComponentOption[];
+export declare const Y_AXIS_OFFSET = 80;
+export declare const PLOT_HEIGHT = 150;
+export interface PlotChart extends Plot {
+    parametersByUnit: Record<string, ParameterWithData[]>;
+    countPreviousUnits: number;
+}
+/**
+ * This function iterates over all added plots and paramters, finds the min and max values from all datasets to determine how to set the timespan
+ * @param PlotsWithData Plots that contain fetched parameter data
+ * @returns left and right values for the timespan
+ */
+export declare const CalculateTimeSpan: (plotsWithData: PlotWithData[]) => Record<string, Date>;
+export {};

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

@@ -0,0 +1,251 @@
+import type { FeatureCollection, GeometryObject } from 'geojson';
+import type { syncGroupsTypes } from '@opengeoweb/store';
+import type { MapFeatureClass } from '@opengeoweb/webmap-react';
+export interface Geometry {
+    type: string;
+    coordinates: number[];
+}
+export interface Properties {
+    timestep: Date[];
+    propertyName: string;
+    values: number[];
+}
+export interface FailedParameterInfo {
+    propertyName: string;
+    serviceId: string;
+    collectionId: string;
+}
+export interface UseGetLocationReturnTypeProperties {
+    name?: string;
+    detail?: string;
+    serviceId: string;
+    collectionId: string;
+    parameterName?: string[];
+    mapFeatureClass: MapFeatureClass;
+}
+export interface ObservationProperties {
+    timestep: string[];
+    observedPropertyName: string;
+    result: string[];
+}
+export interface Feature {
+    type: string;
+    geometry: Geometry;
+    properties: ObservationProperties;
+}
+export interface ParameterApiData {
+    type: string;
+    features: Feature[];
+    timeStamp: string;
+    numberReturned: number;
+}
+export interface PlotPreset {
+    mapId: string;
+    plots: Plot[];
+    parameters: Parameter[];
+}
+export interface Plot {
+    title: string;
+    plotId: string;
+    enabled?: boolean;
+    parameters?: Parameter[];
+}
+export interface PlotWithData extends Plot {
+    parametersWithData: ParameterWithData[];
+    errors?: string[];
+    failedParameters?: FailedParameterInfo[];
+}
+export type PlotType = 'bar' | 'line' | 'scatter';
+export interface Parameter {
+    id?: string;
+    plotId: string;
+    unit?: string;
+    propertyName: string;
+    propertyLabel?: string;
+    plotType: PlotType | 'area';
+    enabled?: boolean;
+    color?: string;
+    opacity?: number;
+    serviceId: string;
+    collectionId: string;
+    instanceId?: string;
+    instances?: EDRInstance[];
+    dimension?: {
+        id: string;
+        value: string;
+    };
+}
+export type ParameterForFetching = Pick<Parameter, 'propertyName' | 'serviceId' | 'collectionId' | 'instanceId' | 'dimension'>;
+export interface ParameterWithData extends Parameter {
+    timestep: Date[];
+    value: number[];
+    unit: string;
+}
+export interface PointerLocation {
+    lon: number;
+    lat: number;
+}
+export interface TimeSeriesLocation extends PointerLocation {
+    id?: string;
+    occurrences?: syncGroupsTypes.Occurrence[];
+}
+export declare const isTimeSeriesLocation: (obj: PointerLocation | TimeSeriesLocation) => obj is TimeSeriesLocation;
+export interface EDRAxes {
+    t: {
+        values: string[];
+    };
+    x: {
+        values: number[];
+    };
+    y: {
+        values: number[];
+    };
+}
+export interface EDRDomain {
+    axes: EDRAxes;
+}
+export interface EDRObservedProperty {
+    id: string;
+    label: EDRI18nString;
+}
+export type EDRI18nString = string | Record<string, string>;
+export interface EDRParameter {
+    id: string;
+    label?: string;
+    observedProperty?: EDRObservedProperty;
+    unit?: {
+        label?: EDRI18nString;
+        symbol?: string | {
+            type: string;
+            value: string;
+        };
+    };
+}
+export type EDRParameters = Record<string, EDRParameter>;
+export interface EDRRangeParameter {
+    axisNames: string[];
+    dataType: string;
+    shape: number[];
+    type: string;
+    values: number[];
+}
+export type EDRRange = Record<string, EDRRangeParameter>;
+export interface EDRPositionResponse {
+    type: string;
+    domain: EDRDomain;
+    parameters: EDRParameters;
+    ranges?: EDRRange;
+}
+export interface EDRPositionResponseCoverageCollection {
+    coverages: EDRPositionResponse[];
+    parameters: EDRParameters;
+    type: string;
+}
+export interface EDRDataQueriesObject {
+    cube?: object;
+    locations?: object;
+    position?: object;
+    instances?: object;
+}
+export interface EDRExtentObject {
+    temporal?: {
+        interval: string[][];
+        trs: string;
+        values: string[];
+    };
+    spatial?: {
+        crs: string;
+        bbox: [[number, number, number, number]];
+    };
+    custom?: CustomDimension[];
+}
+export interface EDRCollection {
+    parameter_names?: object;
+    parameters?: object;
+    data_queries?: EDRDataQueriesObject;
+    extent?: EDRExtentObject;
+    id: string;
+    title: string;
+    description: string;
+}
+export interface EDRInstance {
+    id: string;
+    data_queries?: {
+        position?: {
+            link: {
+                variables: {
+                    output_formats: string[];
+                };
+            };
+        };
+        locations?: {
+            link: {
+                variables: {
+                    output_formats: string[];
+                };
+            };
+        };
+        instances?: {
+            link: string;
+        };
+    };
+    extent?: {
+        temporal?: {
+            interval: string[][];
+            trs: string;
+            values: string[];
+        };
+        spatial: {
+            crs: string;
+            bbox: [[number, number, number, number]];
+        };
+        custom?: CustomDimension[];
+    };
+    parameter_names?: object;
+    parameters?: object;
+}
+export interface ParameterApiDataRequest {
+    urlDomain: string;
+    lon: number;
+    lat: number;
+    parameterName: string;
+}
+export interface EdrCollection {
+    id: string;
+    description: string;
+    parameters: SelectParameter[];
+    customDimensions?: CustomDimension[];
+}
+export type EdrCollections = Record<string, {
+    id: string;
+    title: string;
+    description: string;
+    parameters: SelectParameter[];
+}>;
+export interface SelectParameter {
+    propertyName: string;
+    propertyLabel?: string;
+    unit: string;
+    plotType: PlotType;
+    serviceId: string;
+    collectionId: string;
+    color: string;
+    instanceId?: string;
+    instances?: EDRInstance[];
+}
+export interface ParameterListStyles {
+    plot: React.CSSProperties;
+    row: React.CSSProperties;
+    rowText: React.CSSProperties;
+}
+export interface GeoJsonWithService {
+    collectionName: string;
+    serviceName: string;
+    geoJson: FeatureCollection<GeometryObject>;
+}
+export interface CustomDimension {
+    id: string;
+    interval: [number, number] | [string, string];
+    reference: string;
+    values: number[] | string[];
+}

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

@@ -0,0 +1,25 @@
+import type { FeatureCollection, GeometryObject } from 'geojson';
+import type { Plot, PlotParameter, PlotPreset, TimeSeriesService } from '@opengeoweb/shared';
+import type { syncGroupsTypes } from '@opengeoweb/store';
+import type { EDRPositionResponse, EDRPositionResponseCoverageCollection, FailedParameterInfo, GeoJsonWithService, Parameter, ParameterWithData, PlotWithData, PointerLocation, TimeSeriesLocation, UseGetLocationReturnTypeProperties } from './types';
+/** Maps plot ID to array of error message strings */
+export type PlotErrorsMap = Record<Plot['plotId'], string[]>;
+/** Maps plot ID to array of failed parameter information */
+export type FailedParametersMap = Record<Plot['plotId'], FailedParameterInfo[]>;
+export declare const createGeoJsonArrays: (locations: (FeatureCollection<GeometryObject, UseGetLocationReturnTypeProperties> | undefined)[], services: TimeSeriesService[] | undefined, hideFeatures: boolean, memoizedSelectedFeature: TimeSeriesLocation | null) => {
+    combinedGeoJson: FeatureCollection<GeometryObject, syncGroupsTypes.PotentialDataProperties>;
+};
+export declare const getNearbyLocation: (parameter: Parameter, service: TimeSeriesService, selectedLocation: PointerLocation, geojsonMap: Map<string, GeoJsonWithService>) => TimeSeriesLocation | null;
+export declare const getPlotsWithParameters: (plots: Plot[], parameters: ParameterWithData[], plotErrors?: PlotErrorsMap, failedParameters?: FailedParametersMap) => PlotWithData[];
+export declare function consolidateFeatures<P>(features: {
+    id: string;
+    geoJSON: FeatureCollection<GeometryObject, P>;
+}[]): FeatureCollection<GeometryObject, P>;
+export declare const combineParametersWithData: (parameters: Parameter[], data: ParameterWithData[]) => ParameterWithData[];
+export interface ParameterCollectionQueryData {
+    serviceId: string;
+    service: TimeSeriesService;
+    collectionId: string;
+}
+export declare const extractUsedCollections: (plotsWithoutData: PlotPreset, services: TimeSeriesService[]) => Record<string, ParameterCollectionQueryData>;
+export declare const extractDataFromfetchEdrParameterResponse: (edrResponse: EDRPositionResponse | EDRPositionResponseCoverageCollection | null, parameter: PlotParameter) => ParameterWithData | null;

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

@@ -0,0 +1,10 @@
+import type { TFunction } from 'i18next';
+import React from 'react';
+import type { PlotPreset } from '../TimeSeries/types';
+interface AddPlotButtonProps {
+    handleClick: (title: string) => void;
+    plotState: PlotPreset;
+    t: TFunction;
+}
+export declare const AddPlotButton: React.FC<AddPlotButtonProps>;
+export {};

package/dist/src/lib/components/TimeSeriesManager/ParameterInfo/ParameterInfoButton.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface ParameterInfoButtonProps {
+    isOpenInStore?: boolean;
+    isActive?: boolean;
+    onClick?: () => void;
+}
+export declare const ParameterInfoButton: React.FC<ParameterInfoButtonProps>;
+export {};

package/dist/src/lib/components/TimeSeriesManager/ParameterInfo/ParameterInfoButtonConnect.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { Parameter } from '../../TimeSeries/types';
+interface ParameterInfoButtonProps {
+    parameter: Parameter;
+    panelId: string;
+}
+export declare const ParameterInfoButtonConnect: React.FC<ParameterInfoButtonProps>;
+export {};

package/dist/src/lib/components/TimeSeriesManager/ParameterInfo/ParameterInfoDialog.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { TimeSeriesService } from '@opengeoweb/shared';
+import type { uiTypes } from '@opengeoweb/store';
+import type { EDRInstance, Parameter } from '../../TimeSeries/types';
+import type { TimeseriesCollectionDetail } from '../../TimeSeriesSelect/utils';
+export interface ParameterInfoDialogProps {
+    currentParameterInfo: Parameter;
+    relatedService: TimeSeriesService | undefined;
+    collectionInformation: TimeseriesCollectionDetail | undefined;
+    isLoadingCollectionInformation: boolean;
+    instanceInformation: EDRInstance[] | undefined;
+    isLoadingInstanceInformation: boolean;
+    supportsInstances: boolean;
+    onClose: () => void;
+    isOpen: boolean;
+    onMouseDown?: () => void;
+    order?: number;
+    source?: uiTypes.Source;
+    dialogHeight?: number;
+}
+export declare const ParameterInfoDialog: React.FC<ParameterInfoDialogProps>;
+export declare const QueryInfoElement: React.FC<{
+    queryInformation: TimeseriesCollectionDetail | undefined;
+    isLoadingCollectionInformation: boolean;
+}>;
+export declare const DimensionInfoElement: React.FC<{
+    instanceInformation: EDRInstance[] | undefined;
+    isLoading: boolean;
+}>;
+export interface ParameterInfoTextProps {
+    label: string;
+    value: string;
+}
+export interface ListItem {
+    label: string;
+    value: string;
+    icon: React.ReactElement;
+}
+export interface ParameterInfoListProps {
+    label: string;
+    list: ListItem[];
+}
+export declare const ParameterInfoList: React.FC<ParameterInfoListProps>;

package/dist/src/lib/components/TimeSeriesManager/ParameterInfo/ParameterInfoDialogConnect.d.ts

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