@equinor/esv-intersection 3.0.0-beta.6 → 3.0.0

package/README.md

@@ -1,6 +1,4 @@
 [![npm version](https://badge.fury.io/js/%40equinor%2Fesv-intersection.svg)](https://badge.fury.io/js/%40equinor%2Fesv-intersection)
-![Publish Package](https://github.com/equinor/esv-intersection/workflows/Publish%20Package/badge.svg)
-![Unit tests](https://github.com/equinor/esv-intersection/workflows/Unit%20tests/badge.svg)
 # ESV Intersection component
 A reusable component to create intersection visualizations for wells
 
@@ -8,9 +6,9 @@ Part of the [Equinor Subsurface Visualization project](https://github.com/equino
 
 - **Repository**: https://github.com/equinor/esv-intersection
 - **NPM Package**: https://www.npmjs.com/package/@equinor/esv-intersection
-- **Documentation (latest)**: https://equinor.github.io/esv-intersection/
-- **Storybook (latest)**: https://equinor.github.io/esv-intersection/storybook/latest
-- **Storybook (nightly)**: https://equinor.github.io/esv-intersection/storybook/master
+- **Documentation**: https://equinor.github.io/esv-intersection/
+- **Storybook (latest release)**: https://equinor.github.io/esv-intersection/storybook/latest
+- **Storybook (master branch)**: https://equinor.github.io/esv-intersection/storybook/master
 
 ## Getting started
 
@@ -47,27 +45,24 @@ For more examples, check out our stories in our online [storybook](https://equin
 ## Technical choices
 
 - **Compiler**: [Typescript](https://www.npmjs.com/package/typescript)
-- **Module bundler**: [Rollup](https://www.npmjs.com/package/rollup)
-- **Testing**: [Jest](https://www.npmjs.com/package/jest)
+- **Module bundler**: [Vite](https://www.npmjs.com/package/vite)
+- **Testing**: [Vitest](https://vitest.dev/)
 - **Documentation**: [TypeDoc](https://www.npmjs.com/package/typedoc)
-- **Code compressor**: [Terser](https://www.npmjs.com/package/terser)
 - **Miscellaneous**:
   - Architecture: A container component that holds several layers, specialized for the type of data and visualization they address (analogous to the VidEx-map component https://github.com/equinor/videx-map)
   - Browser support: Target Edge, Chrome, Firefox, Safari
   - Linting and unit tests run automatically on Github Actions
-  
 
-## Development methodology
-- The project is maintained by the [VidEx team](https://github.com/orgs/equinor/teams/viz) (Software Innovation Stavanger) and the [Heap Purple team](https://github.com/orgs/equinor/teams/heap-purple) (Software Innovation Bergen)
-- The maintainers meet once a month to discuss the direction of the project, and possible development activities
-- Development is currently limited to critical bug fixes. New features could be requested by opening a dedicated issue or, even better, by opening a [Pull Requests](CONTRIBUTION.md)
-- Development relies on a _project board_ hosted on github (https://github.com/equinor/intersection/projects/1)
+
+## Development
+- The project is maintained by the [VidEx team](https://github.com/orgs/equinor/teams/viz) and the [Heap Purple team](https://github.com/orgs/equinor/teams/heap-purple)
+- New features could be requested by opening a dedicated issue or, even better, by opening a [Pull Requests](CONTRIBUTION.md)
 
 
 ## Support
-If you are an equinor employee, the easiest way to get in touch with the maintainers is through the #esv-intersection channel on Slack.
+If you are an Equinor employee, the easiest way to get in touch with the maintainers is through the #esv-intersection channel on Slack.
 
-Otherwise, Github issues are the main communication channel with the maintainers. If you have a bug report, a feature request, or need some help using the component, simply [create an issue in the repository](https://github.com/equinor/esv-intersection/issues) and one of the maintainers will pick it up. Before creating an issue, please have a look at the following guidelines. Also keep in mind that creating [Pull Requests](CONTRIBUTION.md) is the preferred way to contribute to the project. 
+Otherwise, Github issues are the main communication channel with the maintainers. If you have a bug report, a feature request, or need some help using the component, simply [create an issue in the repository](https://github.com/equinor/esv-intersection/issues) and one of the maintainers will pick it up. Before creating an issue, please have a look at the following guidelines. Also keep in mind that creating [Pull Requests](CONTRIBUTION.md) is the preferred way to contribute to the project.
 
 ### Help needed
 Describe your use case in details, make sure to include the version of the component you are using, and relevant software that are part of your pipeline (eg, Chrome/Firefox/Safari, Node, npm, …), including their version as well

package/dist/components/axis.d.ts

@@ -1,47 +1,47 @@
-import { Selection } from 'd3-selection';
-import { ScaleLinear } from 'd3-scale';
-import { OnResizeEvent, OnRescaleEvent } from '../interfaces';
-export type Options = {
-    offsetX: number;
-    offsetY: number;
-    visible: boolean;
-};
-export declare class Axis {
-    private mainGroup;
-    private _scaleX;
-    private _scaleY;
-    private _showLabels;
-    private _labelXDesc;
-    private _labelYDesc;
-    private _unitOfMeasure;
-    private _offsetX;
-    private _offsetY;
-    private _flipX;
-    private _flipY;
-    private visible;
-    constructor(mainGroup: Selection<SVGElement, unknown, null, undefined>, showLabels: boolean, labelXDesc: string, labelYDesc: string, unitOfMeasure: string, options?: Options);
-    private renderLabelx;
-    private renderLabely;
-    private renderGy;
-    private renderGx;
-    private createOrGet;
-    render(): void;
-    onResize(event: OnResizeEvent): void;
-    onRescale(event: OnRescaleEvent): void;
-    show(): Axis;
-    hide(): Axis;
-    flipX(flipX: boolean): Axis;
-    flipY(flipY: boolean): Axis;
-    showLabels(): Axis;
-    hideLabels(): Axis;
-    setLabelX(label: string): Axis;
-    setLabelY(label: string): Axis;
-    setUnitOfMeasure(uom: string): Axis;
-    setLabels(labelX: string, labelY: string, unitOfMeasure: string): Axis;
-    get offsetX(): number;
-    set offsetX(offset: number);
-    get offsetY(): number;
-    set offsetY(offset: number);
-    get scaleX(): ScaleLinear<number, number>;
-    get scaleY(): ScaleLinear<number, number>;
-}
+import { Selection } from 'd3-selection';
+import { ScaleLinear } from 'd3-scale';
+import { OnResizeEvent, OnRescaleEvent } from '../interfaces';
+export declare type Options = {
+    offsetX: number;
+    offsetY: number;
+    visible: boolean;
+};
+export declare class Axis {
+    private mainGroup;
+    private _scaleX;
+    private _scaleY;
+    private _showLabels;
+    private _labelXDesc;
+    private _labelYDesc;
+    private _unitOfMeasure;
+    private _offsetX;
+    private _offsetY;
+    private _flipX;
+    private _flipY;
+    private visible;
+    constructor(mainGroup: Selection<SVGElement, unknown, null, undefined>, showLabels: boolean, labelXDesc: string, labelYDesc: string, unitOfMeasure: string, options?: Options);
+    private renderLabelx;
+    private renderLabely;
+    private renderGy;
+    private renderGx;
+    private createOrGet;
+    render(): void;
+    onResize(event: OnResizeEvent): void;
+    onRescale(event: OnRescaleEvent): void;
+    show(): Axis;
+    hide(): Axis;
+    flipX(flipX: boolean): Axis;
+    flipY(flipY: boolean): Axis;
+    showLabels(): Axis;
+    hideLabels(): Axis;
+    setLabelX(label: string): Axis;
+    setLabelY(label: string): Axis;
+    setUnitOfMeasure(uom: string): Axis;
+    setLabels(labelX: string, labelY: string, unitOfMeasure: string): Axis;
+    get offsetX(): number;
+    set offsetX(offset: number);
+    get offsetY(): number;
+    set offsetY(offset: number);
+    get scaleX(): ScaleLinear<number, number>;
+    get scaleY(): ScaleLinear<number, number>;
+}

package/dist/components/index.d.ts

@@ -1 +1 @@
-export * from './axis';
+export * from './axis';

package/dist/constants.d.ts

@@ -1,11 +1,11 @@
-export declare const DEFAULT_LAYER_WIDTH = 200;
-export declare const DEFAULT_LAYER_HEIGHT = 300;
-export declare const HORIZONTAL_AXIS_MARGIN = 40;
-export declare const VERTICAL_AXIS_MARGIN = 30;
-export declare const EXAGGERATED_DIAMETER = 100;
-export declare const HOLE_OUTLINE = 0.6;
-export declare const SCREEN_OUTLINE = 0.3;
-export declare const SHOE_WIDTH = 8;
-export declare const SHOE_LENGTH = 16;
-export declare const DEFAULT_TEXTURE_SIZE = 64;
-export declare const SURFACE_LINE_WIDTH = 1;
+export declare const DEFAULT_LAYER_WIDTH = 200;
+export declare const DEFAULT_LAYER_HEIGHT = 300;
+export declare const HORIZONTAL_AXIS_MARGIN = 40;
+export declare const VERTICAL_AXIS_MARGIN = 30;
+export declare const EXAGGERATED_DIAMETER = 100;
+export declare const HOLE_OUTLINE = 0.6;
+export declare const SCREEN_OUTLINE = 0.3;
+export declare const SHOE_WIDTH = 8;
+export declare const SHOE_LENGTH = 16;
+export declare const DEFAULT_TEXTURE_SIZE = 64;
+export declare const SURFACE_LINE_WIDTH = 1;

package/dist/control/ExtendedCurveInterpolator.d.ts

@@ -1,58 +1,58 @@
-import { CurveInterpolator } from 'curve-interpolator';
-import { Vector } from 'curve-interpolator/dist/src/interfaces';
-import { CurveInterpolatorOptions } from 'curve-interpolator/dist/src/curve-interpolator';
-export declare class ExtendedCurveInterpolator extends CurveInterpolator {
-    arcLengthLookup: number[];
-    constructor(points: Vector[], options?: CurveInterpolatorOptions);
-    /**
-     * Function which finds t value for arc length
-     * @param {Number} arcLength Target arc length
-     * @param {Number} tolerance Tolerance for result
-     * @param {Number} iterations Max number of iterations to use
-     */
-    findTForArcLength(arcLength: number, options?: {
-        approxT?: boolean;
-        quickT?: boolean;
-        normalizedLength?: number;
-    }): number;
-    /**
-     * Function which finds t value for arc length by finding root
-     * @param {Number} arcLength Target arc length
-     * @param {Number} tolerance Tolerance for result
-     * @param {Number} iterations Max number of iterations to use
-     */
-    findTByRootForArcLength(arcLength: number, tolerance?: number, iterations?: number): number;
-    /**
-     * Function which finds t value for arc length by simple approximation
-     * @param {Number} arcLength Target arclength
-     */
-    findApproxTForArcLength(arcLength: number, normalizedLength?: number): number;
-    /**
-     * Function which finds t value for arc length using lookup table
-     * @param {Number} arcLength Target arclength
-     */
-    findTQuickForArcLength(arcLength: number): number;
-    generateArcLengthLookup(segments?: number): void;
-    /**
-     * Function calculating length along curve using interpolator.
-     * @param {Number} from t at start (default = 0)
-     * @param {Number} to t at end (default = 1)
-     */
-    getArcLength(from?: number, to?: number): number;
-    /**
-     * Function calculating length along curve using interpolator.
-     * @param {Number} from t at start (default = 0)
-     * @param {Number} to t at end (default = 1)
-     */
-    getQuickArcLength(from?: number, to?: number): number;
-    /**
-     * Function getting a point at curve length.
-     * @param {Number} arcLength
-     */
-    getPointAtArcLength(arcLength: number, options?: {
-        approxT?: boolean;
-        quickT?: boolean;
-        normalizedLength?: number;
-    }): Vector;
-    getPointAt(t: number): Vector;
-}
+import { CurveInterpolator } from 'curve-interpolator';
+import { Vector } from 'curve-interpolator/dist/src/interfaces';
+import { CurveInterpolatorOptions } from 'curve-interpolator/dist/src/curve-interpolator';
+export declare class ExtendedCurveInterpolator extends CurveInterpolator {
+    arcLengthLookup: number[];
+    constructor(points: Vector[], options?: CurveInterpolatorOptions);
+    /**
+     * Function which finds t value for arc length
+     * @param {Number} arcLength Target arc length
+     * @param {Number} tolerance Tolerance for result
+     * @param {Number} iterations Max number of iterations to use
+     */
+    findTForArcLength(arcLength: number, options?: {
+        approxT?: boolean;
+        quickT?: boolean;
+        normalizedLength?: number;
+    }): number;
+    /**
+     * Function which finds t value for arc length by finding root
+     * @param {Number} arcLength Target arc length
+     * @param {Number} tolerance Tolerance for result
+     * @param {Number} iterations Max number of iterations to use
+     */
+    findTByRootForArcLength(arcLength: number, tolerance?: number, iterations?: number): number;
+    /**
+     * Function which finds t value for arc length by simple approximation
+     * @param {Number} arcLength Target arclength
+     */
+    findApproxTForArcLength(arcLength: number, normalizedLength?: number): number;
+    /**
+     * Function which finds t value for arc length using lookup table
+     * @param {Number} arcLength Target arclength
+     */
+    findTQuickForArcLength(arcLength: number): number;
+    generateArcLengthLookup(segments?: number): void;
+    /**
+     * Function calculating length along curve using interpolator.
+     * @param {Number} from t at start (default = 0)
+     * @param {Number} to t at end (default = 1)
+     */
+    getArcLength(from?: number, to?: number): number;
+    /**
+     * Function calculating length along curve using interpolator.
+     * @param {Number} from t at start (default = 0)
+     * @param {Number} to t at end (default = 1)
+     */
+    getQuickArcLength(from?: number, to?: number): number;
+    /**
+     * Function getting a point at curve length.
+     * @param {Number} arcLength
+     */
+    getPointAtArcLength(arcLength: number, options?: {
+        approxT?: boolean;
+        quickT?: boolean;
+        normalizedLength?: number;
+    }): Vector;
+    getPointAt(t: number): Vector;
+}

package/dist/control/IntersectionReferenceSystem.d.ts

@@ -1,96 +1,96 @@
-import { CurveInterpolator } from 'curve-interpolator';
-import { Interpolators, Trajectory, MDPoint } from '../interfaces';
-import { ExtendedCurveInterpolator } from './ExtendedCurveInterpolator';
-export interface ReferenceSystemOptions {
-    normalizedLength?: number;
-    arcDivisions?: number;
-    tension?: number;
-    trajectoryAngle?: number;
-    calculateDisplacementFromBottom?: boolean;
-    curveInterpolator?: ExtendedCurveInterpolator;
-    trajectoryInterpolator?: ExtendedCurveInterpolator;
-    curtainInterpolator?: ExtendedCurveInterpolator;
-    approxT?: boolean;
-    quickT?: boolean;
-}
-export declare class IntersectionReferenceSystem {
-    options: ReferenceSystemOptions;
-    path: number[][];
-    projectedPath: number[][];
-    projectedTrajectory: number[][];
-    private _offset;
-    displacement: number;
-    depthReference: number;
-    wellboreId: number;
-    trajectoryOffset: number;
-    interpolators: Interpolators;
-    startVector: number[];
-    endVector: number[];
-    _curtainPathCache: MDPoint[];
-    /**
-     * Creates a common reference system that layers and other components can use
-     * @param path (required) array of 3d coordinates: [x, y, z]
-     * @param options (optional)
-     * @param options.trajectoryAngle (optional) - trajectory angle in degrees, overrides the calculated value
-     * @param options.calculateDisplacementFromBottom - (optional) specify if the path is passed from bottom up
-     */
-    constructor(path: number[][], options?: ReferenceSystemOptions);
-    private setPath;
-    /**
-     * Map a length along the curve to intersection coordinates
-     * @param length length along the curve
-     */
-    project(length: number): number[];
-    curtainTangent(length: number): number[];
-    /**
-     * Returns as resampled version of the projected path between start and end
-     * Samples are picked from the beginning of the path at every CURTAIN_SAMPLING_INTERVAL meters
-     * If the angle between two consecutive segments is close to 180 degrees depending on CURTAIN_SAMPLING_ANGLE_THRESHOLD,
-     * a sample in between is discarded.
-     *
-     * The start and the end are not guaranteed to be part of the returned set of points
-     * @param startMd in MD
-     * @param endMd in MD
-     * @param includeStartEnd guarantee to include the starting and end points
-     */
-    getCurtainPath(startMd: number, endMd: number, includeStartEnd?: boolean): MDPoint[];
-    /**
-     * Map a displacement back to length along the curve
-     */
-    unproject(displacement: number): number;
-    /**
-     * Get the normalized displacement [0 - 1] of a specific length along the curve
-     */
-    getProjectedLength(length: number): number;
-    /**
-     * Get the trajectory position at a length along the curve
-     */
-    getPosition(length: number): number[];
-    /**
-     * Generate a set of coordinates along the trajectory of the curve
-     */
-    getTrajectory(steps: number, from?: number, to?: number): Trajectory;
-    /**
-     * Generate a set of coordinates along the trajectory of the curve
-     */
-    getExtendedTrajectory(numPoints: number, startExtensionLength?: number, endExtensionLength?: number): Trajectory;
-    getTrajectoryVector(): number[];
-    /**
-     * Perform a curtain projection on a set of points in 3D
-     * @param points
-     * @param origin
-     * @param offset
-     * @returns {array}
-     */
-    static toDisplacement(points: number[][], offset?: number): number[][];
-    /**
-     * returns a normalized vector
-     * @param interpolator interpolated curve
-     * @param from number between 0 and 1
-     * @param to number between 0 and 1
-     */
-    static getDirectionVector(interpolator: CurveInterpolator, from: number, to: number): number[];
-    get length(): number;
-    get offset(): number;
-    set offset(offset: number);
-}
+import { CurveInterpolator } from 'curve-interpolator';
+import { Interpolators, Trajectory, MDPoint } from '../interfaces';
+import { ExtendedCurveInterpolator } from './ExtendedCurveInterpolator';
+export interface ReferenceSystemOptions {
+    normalizedLength?: number;
+    arcDivisions?: number;
+    tension?: number;
+    trajectoryAngle?: number;
+    calculateDisplacementFromBottom?: boolean;
+    curveInterpolator?: ExtendedCurveInterpolator;
+    trajectoryInterpolator?: ExtendedCurveInterpolator;
+    curtainInterpolator?: ExtendedCurveInterpolator;
+    approxT?: boolean;
+    quickT?: boolean;
+}
+export declare class IntersectionReferenceSystem {
+    options: ReferenceSystemOptions;
+    path: number[][];
+    projectedPath: number[][];
+    projectedTrajectory: number[][];
+    private _offset;
+    displacement: number;
+    depthReference: number;
+    wellboreId: number;
+    trajectoryOffset: number;
+    interpolators: Interpolators;
+    startVector: number[];
+    endVector: number[];
+    _curtainPathCache: MDPoint[];
+    /**
+     * Creates a common reference system that layers and other components can use
+     * @param path (required) array of 3d coordinates: [x, y, z]
+     * @param options (optional)
+     * @param options.trajectoryAngle (optional) - trajectory angle in degrees, overrides the calculated value
+     * @param options.calculateDisplacementFromBottom - (optional) specify if the path is passed from bottom up
+     */
+    constructor(path: number[][], options?: ReferenceSystemOptions);
+    private setPath;
+    /**
+     * Map a length along the curve to intersection coordinates
+     * @param length length along the curve
+     */
+    project(length: number): number[];
+    curtainTangent(length: number): number[];
+    /**
+     * Returns as resampled version of the projected path between start and end
+     * Samples are picked from the beginning of the path at every CURTAIN_SAMPLING_INTERVAL meters
+     * If the angle between two consecutive segments is close to 180 degrees depending on CURTAIN_SAMPLING_ANGLE_THRESHOLD,
+     * a sample in between is discarded.
+     *
+     * The start and the end are not guaranteed to be part of the returned set of points
+     * @param startMd in MD
+     * @param endMd in MD
+     * @param includeStartEnd guarantee to include the starting and end points
+     */
+    getCurtainPath(startMd: number, endMd: number, includeStartEnd?: boolean): MDPoint[];
+    /**
+     * Map a displacement back to length along the curve
+     */
+    unproject(displacement: number): number;
+    /**
+     * Get the normalized displacement [0 - 1] of a specific length along the curve
+     */
+    getProjectedLength(length: number): number;
+    /**
+     * Get the trajectory position at a length along the curve
+     */
+    getPosition(length: number): number[];
+    /**
+     * Generate a set of coordinates along the trajectory of the curve
+     */
+    getTrajectory(steps: number, from?: number, to?: number): Trajectory;
+    /**
+     * Generate a set of coordinates along the trajectory of the curve
+     */
+    getExtendedTrajectory(numPoints: number, startExtensionLength?: number, endExtensionLength?: number): Trajectory;
+    getTrajectoryVector(): number[];
+    /**
+     * Perform a curtain projection on a set of points in 3D
+     * @param points
+     * @param origin
+     * @param offset
+     * @returns {array}
+     */
+    static toDisplacement(points: number[][], offset?: number): number[][];
+    /**
+     * returns a normalized vector
+     * @param interpolator interpolated curve
+     * @param from number between 0 and 1
+     * @param to number between 0 and 1
+     */
+    static getDirectionVector(interpolator: CurveInterpolator, from: number, to: number): number[];
+    get length(): number;
+    get offset(): number;
+    set offset(offset: number);
+}

package/dist/control/LayerManager.d.ts

@@ -1,76 +1,76 @@
-import { ZoomPanHandler } from './ZoomPanHandler';
-import { Layer, LayerOptions } from '../layers';
-import { ScaleOptions } from '../interfaces';
-import { Axis } from '../components';
-import { IntersectionReferenceSystem } from './IntersectionReferenceSystem';
-import { AxisOptions } from './interfaces';
-export declare class LayerManager {
-    private container;
-    private layerContainer;
-    private _zoomPanHandler;
-    private layers;
-    private _axis;
-    private _svgContainer;
-    /**
-     * Handles layers and axis also holds a zoom and pan handler object
-     * @param container root container
-     * @param scaleOptions
-     * @param axisOptions
-     */
-    constructor(container: HTMLElement, scaleOptions?: ScaleOptions, axisOptions?: AxisOptions);
-    /**
-     * Adds and mounts an array of layers
-     * @param layers array of layers
-     */
-    addLayers(layers: Layer<unknown>[]): LayerManager;
-    /**
-     * Gets all layers currently mounted
-     */
-    getLayers(): Layer<unknown>[];
-    /**
-     * Clears data from all mounted layers
-     * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
-     */
-    clearAllData(includeReferenceSystem?: boolean): LayerManager;
-    /**
-     * Adds the layer to the manager, and mounts it
-     * @param layer Layer
-     * @param params extra params to pass to the onUpdate method
-     */
-    addLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
-    /**
-     * Remove and unmount layer from manager
-     * @param layerId name of layer
-     */
-    removeLayer(layerId: string): LayerManager;
-    /**
-     * Remove and unmount all layers from manager
-     */
-    removeAllLayers(): LayerManager;
-    getLayer(layerId: string): Layer<unknown>;
-    initLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
-    showLayer(layerId: string): LayerManager;
-    hideLayer(layerId: string): LayerManager;
-    /**
-     * Adjust layers, axis, and zoom according to inputted dimensions
-     * @param width (required)
-     * @param height (required)
-     */
-    adjustToSize(width: number, height: number): void;
-    setReferenceSystem(irs: IntersectionReferenceSystem): void;
-    showAxis(): LayerManager;
-    hideAxis(): LayerManager;
-    showAxisLabels(): LayerManager;
-    hideAxisLabels(): LayerManager;
-    setAxisOffset(x: number, y: number): LayerManager;
-    setXAxisOffset(x: number): LayerManager;
-    setYAxisOffset(y: number): LayerManager;
-    setZoomLevelBoundary(zoomlevels: [number, number]): LayerManager;
-    setMaxZoomLevel(zoomlevel: number): LayerManager;
-    setMinZoomLevel(zoomlevel: number): LayerManager;
-    destroy(): LayerManager;
-    get zoomPanHandler(): ZoomPanHandler;
-    get axis(): Axis;
-    private rescale;
-    private createAxis;
-}
+import { ZoomPanHandler } from './ZoomPanHandler';
+import { Layer, LayerOptions } from '../layers';
+import { ScaleOptions } from '../interfaces';
+import { Axis } from '../components';
+import { IntersectionReferenceSystem } from './IntersectionReferenceSystem';
+import { AxisOptions } from './interfaces';
+export declare class LayerManager {
+    private container;
+    private layerContainer;
+    private _zoomPanHandler;
+    private layers;
+    private _axis;
+    private _svgContainer;
+    /**
+     * Handles layers and axis also holds a zoom and pan handler object
+     * @param container root container
+     * @param scaleOptions
+     * @param axisOptions
+     */
+    constructor(container: HTMLElement, scaleOptions?: ScaleOptions, axisOptions?: AxisOptions);
+    /**
+     * Adds and mounts an array of layers
+     * @param layers array of layers
+     */
+    addLayers(layers: Layer<unknown>[]): LayerManager;
+    /**
+     * Gets all layers currently mounted
+     */
+    getLayers(): Layer<unknown>[];
+    /**
+     * Clears data from all mounted layers
+     * @param includeReferenceSystem - (optional) if true also removes reference system, default is true
+     */
+    clearAllData(includeReferenceSystem?: boolean): LayerManager;
+    /**
+     * Adds the layer to the manager, and mounts it
+     * @param layer Layer
+     * @param params extra params to pass to the onUpdate method
+     */
+    addLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
+    /**
+     * Remove and unmount layer from manager
+     * @param layerId name of layer
+     */
+    removeLayer(layerId: string): LayerManager;
+    /**
+     * Remove and unmount all layers from manager
+     */
+    removeAllLayers(): LayerManager;
+    getLayer(layerId: string): Layer<unknown>;
+    initLayer(layer: Layer<unknown>, params?: LayerOptions<unknown>): LayerManager;
+    showLayer(layerId: string): LayerManager;
+    hideLayer(layerId: string): LayerManager;
+    /**
+     * Adjust layers, axis, and zoom according to inputted dimensions
+     * @param width (required)
+     * @param height (required)
+     */
+    adjustToSize(width: number, height: number): void;
+    setReferenceSystem(irs: IntersectionReferenceSystem): void;
+    showAxis(): LayerManager;
+    hideAxis(): LayerManager;
+    showAxisLabels(): LayerManager;
+    hideAxisLabels(): LayerManager;
+    setAxisOffset(x: number, y: number): LayerManager;
+    setXAxisOffset(x: number): LayerManager;
+    setYAxisOffset(y: number): LayerManager;
+    setZoomLevelBoundary(zoomlevels: [number, number]): LayerManager;
+    setMaxZoomLevel(zoomlevel: number): LayerManager;
+    setMinZoomLevel(zoomlevel: number): LayerManager;
+    destroy(): LayerManager;
+    get zoomPanHandler(): ZoomPanHandler;
+    get axis(): Axis;
+    private rescale;
+    private createAxis;
+}