@opengeoweb/core 4.4.0 → 4.5.0

package/lib/components/CanvasComponent/CanvasComponent.d.ts

@@ -3,7 +3,7 @@ interface CanvasComponentProps {
     onRenderCanvas: (ctx: CanvasRenderingContext2D, width: number, height: number, canvas: HTMLCanvasElement) => void;
     onCanvasClick?: (x: number, y: number, width: number, height: number) => void;
     onMouseMove?: (x: number, y: number, event: MouseEvent, width: number) => void;
-    onMouseUp?: () => void;
+    onMouseUp?: (x: number) => void;
     onMouseDown?: (x: number, y: number, width: number) => void;
     onTouchStart?: (event: TouchEvent, width: number) => void;
     onTouchEnd?: () => void;
@@ -59,7 +59,7 @@ export default class CanvasComponent extends Component<CanvasComponentProps> {
     updateCanvas(): void;
     resize(): void;
     handleMouseMoveEvent(event: MouseEvent): void;
-    handleMouseUpEvent(): void;
+    handleMouseUpEvent(event: MouseEvent): void;
     handleMouseDownEvent(event: MouseEvent): void;
     handleTouchStartEvent(event: TouchEvent): void;
     handleTouchEndEvent(): void;

package/lib/components/ConfigurableMap/ConfigurableMapConnect.d.ts

@@ -30,5 +30,6 @@ export interface ConfigurableMapConnectProps {
     multiLegend?: boolean;
     shouldShowLayerManager?: boolean;
     showClock?: boolean;
+    children?: React.ReactNode;
 }
 export declare const ConfigurableMapConnect: React.FC<ConfigurableMapConnectProps>;

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

@@ -1,12 +1,10 @@
 import * as React from 'react';
-import { LayerManagerWidth } from '../LayerManagerUtils';
 import { Layer } from '../../../store/mapStore/types';
 import { Service } from '../../WMSLoader/services';
 interface BaseLayerRowProps {
     mapId: string;
     preloadedAvailableBaseLayers?: Layer[];
     preloadedServices?: Service[];
-    layerManagerWidth: LayerManagerWidth;
     tooltip?: string;
 }
 declare const BaseLayerRow: React.FC<BaseLayerRowProps>;

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

@@ -1,14 +1,9 @@
 import * as React from 'react';
-import { Service } from '../../WMSLoader/services';
-import { LayerType } from '../../../store/mapStore/types';
-import { LayerManagerWidth } from '../LayerManagerUtils';
+import { Source } from '../../../store/ui/types';
 interface DescriptionRowProps {
     mapId: string;
-    preloadedServices?: Service[];
-    layerType?: LayerType;
-    tooltip?: string;
-    layerManagerWidth: LayerManagerWidth;
-    layerSelect?: boolean;
+    mapPresetsModule?: React.ReactElement;
+    source?: Source;
 }
 declare const DescriptionRow: React.FC<DescriptionRowProps>;
 export default DescriptionRow;

package/lib/components/LayerManager/DockedLayerManagerConnect.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { Layer } from '../../store/mapStore/types';
+import { Service } from '../WMSLoader/services';
+interface DockedLayerManagerConnectProps {
+    mapId: string;
+    preloadedAvailableBaseLayers?: Layer[];
+    preloadedBaseServices?: Service[];
+    bounds?: string;
+    showTitle?: boolean;
+    leftHeaderComponent?: React.ReactElement;
+}
+/**
+ * Docked Layer Manager connected to the store displaying the layers for the corresponding map it's included in
+ * Expects the following props:
+ * @param {Service[]} preloadedBaseServices preloadedBaseServices: array of Service objects - contains an array of Service objects that are preloaded into in the WMS Loader fpr baselayers
+ * @param {Layer[]} preloadedAvailableBaseLayers preloadedAvailableBaseLayers: array of Layer objects - contains an array of Layer objects (consisting solely of type baseLayer) that are available to be shown as basemaps
+ * ``` <LayerManagerConnect />```
+ */
+declare const DockedLayerManagerConnect: React.FC<DockedLayerManagerConnectProps>;
+export default DockedLayerManagerConnect;

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

@@ -1,8 +1,6 @@
 import * as React from 'react';
-import { LayerManagerWidth } from '../LayerManagerUtils';
 interface LayerContainerRowProps {
     mapId: string;
-    layerManagerWidth: LayerManagerWidth;
 }
 declare const LayerContainerRow: React.FC<LayerContainerRowProps>;
 /**

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

@@ -4,6 +4,7 @@ interface ActivateLayerProps {
     onClickActivate: () => void;
     isActive?: boolean;
     isEnabled?: boolean;
+    id?: string;
 }
 declare const ActivateLayer: React.FC<ActivateLayerProps>;
 export default ActivateLayer;

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

@@ -2,6 +2,8 @@ import * as React from 'react';
 interface EnableLayerProps {
     layerId: string;
     mapId: string;
+    isEnabled?: boolean;
+    layerName?: string;
 }
 declare const EnableLayerConnect: React.FC<EnableLayerProps>;
 /**

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

@@ -1,9 +1,9 @@
 import React from 'react';
 import { Dimension, Layer, Services } from '../../../../store/mapStore/types';
-import { LayerManagerWidth } from '../../LayerManagerUtils';
 interface LayerRowProps {
     layerId?: string;
     layer?: Layer;
+    layerName?: string;
     mapId: string;
     onLayerRowClick?: (layerId?: string) => void;
     onLayerEnable?: (payload: {
@@ -44,7 +44,6 @@ interface LayerRowProps {
     layerMenuLayout?: React.ReactChild;
     layerActiveLayout?: React.ReactChild;
     services?: Services;
-    layerManagerWidth: LayerManagerWidth;
     isEnabled?: boolean;
     dragHandle?: React.ReactElement;
     isLayerMissing?: boolean;

package/lib/components/LayerManager/LayerContainerRow/LayerRow/LayerRowConnect.d.ts

@@ -1,9 +1,7 @@
 import * as React from 'react';
-import { LayerManagerWidth } from '../../LayerManagerUtils';
 interface LayerRowConnectProps {
     layerId: string;
     mapId: string;
-    layerManagerWidth: LayerManagerWidth;
     dragHandle: React.ReactElement;
     layerIndex: number;
 }

package/lib/components/LayerManager/LayerManager.d.ts

@@ -2,10 +2,15 @@ import * as React from 'react';
 import { Layer } from '../../store/mapStore/types';
 import { Source } from '../../store/ui/types';
 import { Service } from '../WMSLoader/services';
+import { Size } from './LayerManagerHeaderOptions';
+export declare type Position = {
+    top: number;
+    left?: number;
+    right?: number;
+};
 interface LayerManagerProps {
     mapId: string;
     preloadedAvailableBaseLayers?: Layer[];
-    preloadedMapServices?: Service[];
     preloadedBaseServices?: Service[];
     bounds?: string;
     showTitle?: boolean;
@@ -14,24 +19,14 @@ interface LayerManagerProps {
     isOpen: boolean;
     order?: number;
     source?: Source;
-    layerSelect?: boolean;
-    showAddLayersTooltip?: boolean;
-    leftComponent?: React.ReactNode;
+    leftHeaderComponent?: React.ReactElement;
     isLoading?: boolean;
     error?: string;
+    isDockedLayerManager?: boolean;
+    onToggleDock?: () => void;
+    size?: Size;
+    startPosition?: Position;
 }
-export declare const calculateStartSize: (minSize: {
-    width: number;
-    height: number;
-}, prefSize: {
-    width: number;
-    height: number;
-}, startPosition: {
-    top: number;
-    left: number;
-}) => {
-    width: number;
-    height: number;
-};
+export declare const calculateStartSize: (minSize: Size, prefSize: Size, startPosition: Position) => Size;
 declare const LayerManager: React.FC<LayerManagerProps>;
 export default LayerManager;

package/lib/components/LayerManager/LayerManager.stories.d.ts

@@ -9,6 +9,26 @@ export declare const LayerManagerLightTheme: {
     };
     storyName: string;
 };
+export declare const DockedLayerManagerLightTheme: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+    storyName: string;
+};
+export declare const LayerManagerLightThemeSmall: () => React.ReactElement;
+export declare const LayerManagerLightThemeMedium: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+};
 export declare const LayerManagerDarkTheme: {
     (): React.ReactElement;
     parameters: {
@@ -19,6 +39,26 @@ export declare const LayerManagerDarkTheme: {
     };
     storyName: string;
 };
+export declare const DockedLayerManagerDarkTheme: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+    storyName: string;
+};
+export declare const LayerManagerDarkThemeSmall: () => React.ReactElement;
+export declare const LayerManagerDarkThemeMedium: {
+    (): React.ReactElement;
+    parameters: {
+        zeplinLink: {
+            name: string;
+            link: string;
+        }[];
+    };
+};
 export declare const LayerManagerLoadingState: () => React.ReactElement;
 export declare const LayerManagerWithErrorLight: {
     (): React.ReactElement;

package/lib/components/LayerManager/LayerManagerConnect.d.ts

@@ -7,8 +7,7 @@ interface LayerManagerConnectProps {
     preloadedBaseServices?: Service[];
     bounds?: string;
     showTitle?: boolean;
-    layerSelect?: boolean;
-    leftComponent?: React.ReactNode;
+    leftHeaderComponent?: React.ReactElement;
 }
 /**
  * Layer Managerconnected to the store displaying the layers forthe active map Id

package/lib/components/LayerManager/LayerManagerHeaderOptions.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+export declare type Size = {
+    width: number;
+    height: number;
+};
+interface HeaderOptionsProps {
+    isDockedLayerManager: boolean;
+    onClickDockButton: () => void;
+    onChangeSize: (size: Size) => void;
+}
+export declare const sizeSmall: {
+    width: number;
+    height: number;
+};
+export declare const sizeMedium: {
+    width: number;
+    height: number;
+};
+export declare const sizeLarge: {
+    width: number;
+    height: number;
+};
+declare const HeaderOptions: React.FC<HeaderOptionsProps>;
+export default HeaderOptions;

package/lib/components/LayerManager/LayerManagerUtils.d.ts

@@ -1,54 +1,151 @@
-export declare const LayerManagerColumnsLarge: {
-    column1: {
+export declare const columnClasses: {
+    column1: string;
+    column2: string;
+    column3: string;
+    column4: string;
+    column5: string;
+    column6: string;
+    column7: string;
+};
+export declare const layerManagerStyle: {
+    '@container (max-width: 320px)'?: {
+        '.layermanager': {
+            '.column-1:not(.container-query-polyfill)': {
+                width: string;
+            };
+            '.enable-btn-mini:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.activateLayer-btn:not(.container-query-polyfill), .enable-btn:not(.container-query-polyfill), .column-2:not(.container-query-polyfill), .column-3:not(.container-query-polyfill), .column-4:not(.container-query-polyfill), .column-5:not(.container-query-polyfill), .column-6:not(.container-query-polyfill), .column-7:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '#mappresets-menubutton:not(.container-query-polyfill), .addLayer-column:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.descriptionRow:not(.container-query-polyfill)': {
+                height: number;
+                '.MuiButtonBase-root:not(.container-query-polyfill)': {
+                    display: string;
+                };
+            };
+        };
+        '.header-layermanager': {
+            '.header-left:not(.container-query-polyfill), .header-title:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '&>div:not(.container-query-polyfill)': {
+                justifyContent: string;
+                padding: number;
+                height: number;
+            };
+            '.header-right:not(.container-query-polyfill)': {
+                maxWidth: string;
+                flexBasis: string;
+            };
+            '.collapseSmall-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+    } | undefined;
+    '@container (max-width: 600px)'?: {
+        '.layermanager': {
+            '.column-3:not(.container-query-polyfill), .column-4:not(.container-query-polyfill), .column-5:not(.container-query-polyfill), .column-6:not(.container-query-polyfill), .column-7:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.column-2:not(.container-query-polyfill)': {
+                width: string;
+            };
+            '.header-layer.mappresetsModule-enabled:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.header-mapPresets:not(.container-query-polyfill)': {
+                display: string;
+                '.MuiButtonBase-root:not(.container-query-polyfill)': {
+                    height: number;
+                    '.MuiBox-root:not(.container-query-polyfill)': {
+                        textAlign: string;
+                    };
+                };
+            };
+        };
+        '.header-layermanager': {
+            '.mapPresets-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.collapseLarge-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+    } | undefined;
+    '@container (max-width: 600px) and (min-width: 321px)'?: {
+        '.layermanager': {
+            '.medium-layermanager:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+        '.deleteBtnMedium:not(.container-query-polyfill)': {
+            display: string;
+            '&+button:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+        '.layerRow': {
+            '.column-1:not(.container-query-polyfill)': {
+                display: string;
+            };
+            '.column-2:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+        '.header-layermanager': {
+            '.collapseMedium-btn:not(.container-query-polyfill)': {
+                display: string;
+            };
+        };
+    } | undefined;
+    '.layerManagerContainer': {
+        containerType: string;
+    };
+    '.is-dragging header+.MuiBox-root': {
+        overflow: string;
+    };
+    '.column-1': {
         width: number;
         display: string;
+        background: string;
     };
-    column2: {
+    '.column-2': {
         width: string;
     };
-    column3: {
+    '.column-3': {
         width: string;
     };
-    column4: {
+    '.column-4': {
         width: string;
     };
-    column5: {
+    '.column-5': {
         width: string;
     };
-    column6: {
+    '.column-6': {
         width: number;
         display: string;
     };
-    columns35: {
-        width: string;
-    };
-};
-export declare const LayerManagerColumnsSmall: {
-    column1: {
-        width: number;
-    };
-    column2: {
+    '.column-7': {
         width: string;
     };
-    column3: {
+    '.enable-btn-mini': {
         display: string;
     };
-    column4: {
-        display: string;
+    '.header-layermanager': {
+        containerType: string;
     };
-    column5: {
+    '.header-mapPresets': {
         display: string;
     };
-    column6: {
-        width: number;
+    '.medium-layermanager': {
         display: string;
     };
-    columns35: {
+    '.collapseLarge-btn': {
         display: string;
     };
 };
-export declare enum LayerManagerWidth {
-    sm = 0,
-    lg = 1
-}
-export declare const widthToWidthClass: (w: number) => LayerManagerWidth;

package/lib/components/LayerManager/LayerSelect/LayerSelectUtils.d.ts

@@ -1,4 +1,5 @@
 import { CSSProperties } from 'react';
+import { ActiveServices } from '../../../store/layerSelect/types';
 export declare const layerSelectColumnsLarge: {
     column1: {
         width: number;
@@ -73,3 +74,4 @@ export declare const layerSelectColumnsSmall: {
 };
 export declare const widthToColumns: (width: number) => Record<string, CSSProperties>;
 export declare const widthToRowHeight: (width: number) => number;
+export declare const sortByService: (serviceObj: ActiveServices) => ActiveServices;

package/lib/components/LayerManager/LayerSelect/ServiceList/ServiceListConnect.d.ts

@@ -1,8 +1,6 @@
 import * as React from 'react';
-import { ActiveServices } from '../../../../store/layerSelect/types';
 interface ServiceListConnectProps {
     setHeight: (height: number) => void;
 }
-export declare const sortByService: (serviceObj: ActiveServices) => ActiveServices;
 declare const ServiceListConnect: React.FC<ServiceListConnectProps>;
 export default ServiceListConnect;

package/lib/components/LayerManager/LayerSelect/ServiceOptionsDialog/ServiceOptionsDialog.d.ts

@@ -4,7 +4,7 @@ import { PopupVariant } from '../ServicePopup/ServicePopup';
 import { ReduxLayer } from '../../../../store/mapStore/types';
 interface ServiceOptionsDialogProps {
     services: ActiveServices;
-    layerSelectRemoveService?: (serviceId: string, serviceUrl: string) => void;
+    layerSelectRemoveService?: (serviceId: string, serviceUrl: string, serviceName: string) => void;
     layerSelectReloadService?: (serviceUrl: string) => void;
     selectedLayers: ReduxLayer[];
     setServicePopupInfo?: (popupInfo: ServicePopupInfo) => void;

package/lib/components/LayerManager/LayerSelect/ServicePopup/ServicePopup.d.ts

@@ -7,6 +7,7 @@ export interface ServicePopupProps {
     hideBackdrop?: boolean;
     isOpen?: boolean;
     closePopup?: () => void;
+    shouldDisableAutoFocus?: boolean;
     serviceId?: string;
     serviceUrl?: string;
     serviceName?: string;

package/lib/components/LayerManager/LayerSelect/ServicePopup/utils.d.ts

@@ -5,6 +5,7 @@ export declare const VALIDATIONS_NAME_EXISTING = "This name already exists. Choo
 export declare const VALIDATIONS_SERVICE_EXISTING = "URL already exists.";
 export declare const VALIDATIONS_SERVICE_VALID_URL = "Not a valid URL.";
 export declare const VALIDATIONS_REQUEST_FAILED = "Download failed. Check the URL.";
+export declare const VALIDATIONS_FIELD_REQUIRED = "This field is required";
 export declare const validateServiceName: (value: string, services: ActiveServices, ownServiceName?: string) => ValidationResult;
 export declare const validateServiceUrl: (value: string, services: ActiveServices) => ValidationResult;
 export declare const loadWMSService: (serviceUrl: string, forceReload?: boolean) => Promise<SetLayersForServicePayload>;

package/lib/components/LayerManager/index.d.ts

@@ -1,2 +1,4 @@
 export { default as LayerManagerConnect } from './LayerManagerConnect';
+export { default as DockedLayerManagerConnect } from './DockedLayerManagerConnect';
+export { default as LayerSelectConnect } from './LayerSelect/LayerSelectConnect';
 export { default as LayerManagerMapButtonConnect } from './LayerManagerMapButtonConnect';

package/lib/components/TimeSlider/TimeSlider.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 export interface TimeSliderProps {
     buttons?: React.ReactChild;
-    rail?: React.ReactChild;
+    timeBox?: React.ReactChild;
     legend?: React.ReactChild;
     mapIsActive?: boolean;
     onToggleTimeSlider?: (isVisible: boolean) => void;

package/lib/components/TimeSlider/TimeSliderButtons/ControlButtons/ControlButtons.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export declare const ControlButtons: React.FC<{
+    backwardBtn?: React.ReactChild;
+    forwardBtn?: React.ReactChild;
+    playBtn?: React.ReactChild;
+}>;

package/lib/components/TimeSlider/TimeSliderButtons/ControlButtons/ControlButtonsConnect.d.ts

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

package/lib/components/TimeSlider/TimeSliderButtons/ControlButtons/ControlButtonsConnect.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/TimeSlider/TimeSliderButtons/OptionsMenuButton/OptionsMenu.d.ts

@@ -0,0 +1,8 @@
+import React, { FC } from 'react';
+export declare const OptionsMenu: FC<{
+    nowBtn?: React.ReactChild;
+    timeScaleBtn?: React.ReactChild;
+    timeStepBtn?: React.ReactChild;
+    speedBtn?: React.ReactChild;
+    autoUpdateBtn?: React.ReactChild;
+}>;

package/lib/components/TimeSlider/TimeSliderButtons/OptionsMenuButton/OptionsMenuButton.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { FC } from 'react';
 interface OptionsMenuButtonProps {
     nowBtn?: React.ReactChild;
     autoUpdateBtn?: React.ReactChild;
@@ -7,5 +7,5 @@ interface OptionsMenuButtonProps {
     timeScaleBtn?: React.ReactChild;
     isOpenByDefault?: boolean;
 }
-declare const OptionsMenuButton: React.FC<OptionsMenuButtonProps>;
+declare const OptionsMenuButton: FC<OptionsMenuButtonProps>;
 export default OptionsMenuButton;

package/lib/components/TimeSlider/TimeSliderButtons/OptionsMenuButton/OptionsMenuConnect.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+export declare const OptionsMenuConnect: FC<{
+    sourceId: string;
+    mapId: string;
+}>;

package/lib/components/TimeSlider/TimeSliderButtons/OptionsMenuButton/OptionsMenuConnect.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/TimeSlider/TimeSliderButtons/TimeSliderMenu/TimeSliderMenu.d.ts

@@ -14,5 +14,6 @@ export interface TimeSliderMenuProps {
     isDisabled?: boolean;
     handleAutoClick?: () => void;
     isAutoSelected?: boolean;
+    onChangeMouseWheel?: (element: Mark) => void;
 }
-export declare const TimeSliderMenu: ({ marks, value, isOpenByDefault, handleMenuItemClick, isDisabled, handleAutoClick, isAutoSelected, title, icon, }: TimeSliderMenuProps) => JSX.Element;
+export declare const TimeSliderMenu: ({ marks, value, isOpenByDefault, handleMenuItemClick, isDisabled, handleAutoClick, isAutoSelected, title, icon, onChangeMouseWheel, }: TimeSliderMenuProps) => JSX.Element;

package/lib/components/TimeSlider/TimeSliderClock/ClockContainer.d.ts

@@ -0,0 +1,12 @@
+import moment from 'moment';
+import { FC } from 'react';
+import type { PopperPlacement } from './TimeSliderClock';
+export declare const ClockContainer: FC<{
+    hideButton: boolean;
+    onButtonClick: () => void;
+    isPopperOpen: boolean;
+    fontSize: number;
+    time: moment.Moment;
+    setButtonElement: (anchorElement: HTMLDivElement | null) => void;
+    popperPlacement: PopperPlacement;
+}>;

package/lib/components/TimeSlider/TimeSliderClock/PopperMenu.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import type { PopperPlacement } from './TimeSliderClock';
+export declare const PopperMenu: FC<{
+    popperPlacement: PopperPlacement;
+    isPopperOpen: boolean;
+    buttonElement: HTMLDivElement | null;
+    options: JSX.Element | undefined;
+    controls: JSX.Element | undefined;
+}>;

package/lib/components/TimeSlider/TimeSliderClock/TimeSliderClock.d.ts

@@ -1,5 +1,10 @@
 import { Moment } from 'moment';
-import * as React from 'react';
-export declare const TimeSliderClock: React.FC<{
+import { FC } from 'react';
+export declare type PopperPlacement = 'right' | 'left' | 'top' | 'bottom';
+export declare const TimeSliderClock: FC<{
     time: Moment;
+    options?: JSX.Element;
+    controls?: JSX.Element;
+    hideButton?: boolean;
+    isPopperOpenByDefault?: boolean;
 }>;

package/lib/components/TimeSlider/TimeSliderClock/TimeSliderClock.spec.d.ts

@@ -0,0 +1 @@
+export {};