@unovis/angular 1.7.0-Phoenix.0 → 1.7.0-csp.1

package/dist/lib/index.d.ts

@@ -0,0 +1,3878 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, SimpleChanges, AfterContentInit, OnDestroy, ElementRef, QueryList } from '@angular/core';
+import { ComponentCore, ContainerCore, XYComponentCore, XYContainer, TooltipConfigInterface, Position, Tooltip, AnnotationsConfigInterface, VisEventType, VisEventCallback, AnnotationItem, Annotations, ContinuousScale, Direction, Spacing, ColorFunction, XYContainerConfigInterface, Sizing, SingleContainer, SingleContainerConfigInterface, AreaConfigInterface, NumericAccessor, ColorAccessor, GenericAccessor, FillPatternType, CurveType, StringAccessor, LinePatternType, Area, AxisConfigInterface, AxisType, FitMode, TrimMode, TextAlign, Axis, BoxplotConfigInterface, Boxplot, BrushConfigInterface, Arrangement, Brush, ChordInputNode, ChordInputLink, ChordDiagramConfigInterface, ChordNodeDatum, ChordLinkDatum, ChordLabelAlignment, ChordDiagram, CrosshairConfigInterface, CrosshairSnapMode, CrosshairCircle, Crosshair, DonutConfigInterface, Donut, FreeBrushConfigInterface, FreeBrushMode, FreeBrushSelection, FreeBrush, GraphInputNode, GraphInputLink, GraphConfigInterface, GraphFitViewAlignment, GraphLayoutType, GraphForceLayoutSettings, GraphDagreLayoutSetting, GraphElkLayoutSettings, GraphNode, GraphLinkStyle, GraphLinkArrowStyle, BooleanAccessor, GraphCircleLabel, GraphLink, GraphNodeShape, GraphNodeSelectionHighlightMode, GraphPanelConfig, GraphInputData, GraphDataModel, Graph, GroupedBarConfigInterface, Orientation, GroupedBar, HeatmapConfigInterface, HeatmapLayoutType, Heatmap, LineConfigInterface, Line, NestedDonutConfigInterface, NestedDonutDirection, NestedDonutSegment, NestedDonutLayerSettings, NestedDonut, PlotlineConfigInterface, PlotlineLineStylePresets, PlotlineLabelPosition, PlotlineLabelOrientation, Plotline, SankeyInputNode, SankeyInputLink, SankeyConfigInterface, SankeyZoomMode, SankeyExitTransitionType, SankeyEnterTransitionType, SankeyNode, SankeyLink, SankeyNodeAlign, VerticalAlign, SankeySubLabelPlacement, Sankey, RadialBarConfigInterface, RadialBar, ScatterConfigInterface, SymbolType, Scatter, StackedBarConfigInterface, StackedBar, TimelineConfigInterface, TimelineRowLabel, TimelineRowIcon, TimelineArrow, TimelineLineRenderState, Timeline, XYLabelsConfigInterface, XYLabelPositioning, XYLabel, XYLabels, TopoJSONMapConfigInterface, MapPointLabelPosition, TopoJSONMapClusterDatum, TopoJSONMapPointStyles, TopoJSONMap, TreemapConfigInterface, TreemapNode, TreemapTileFunction, TreemapDatum, Treemap, PlotbandConfigInterface, PlotbandLabelPosition, PlotbandLabelOrientation, Plotband, GenericDataRecord, LeafletMapConfigInterface, Bounds, MapLibreStyleSpecs, LeafletMapRenderer, MapZoomState, LeafletMapPointShape, LeafletMapPointDatum, LeafletMapClusterDatum, LeafletMapPointStyles, LeafletMap, LeafletFlowMapConfigInterface, LeafletFlowMap, BulletLegendConfigInterface, BulletLegendItemInterface, BulletShape, BulletLegendOrientation, BulletLegend, FlowLegendConfigInterface, FlowLegend, RollingPinLegendConfigInterface, RollingPinLegendItem, RollingPinLegend } from '@unovis/ts';
+import { D3BrushEvent } from 'd3-brush';
+import { ElkShape } from 'elkjs';
+import { Selection } from 'd3-selection';
+import { D3DragEvent } from 'd3-drag';
+import { D3ZoomEvent, ZoomTransform } from 'd3-zoom';
+import { GeoProjection } from 'd3-geo';
+
+declare class VisGenericComponent {
+    component: any;
+}
+
+declare class VisCoreComponent extends VisGenericComponent {
+    component: ComponentCore<any>;
+    componentContainer: ContainerCore;
+}
+
+declare class VisXYComponent extends VisCoreComponent {
+    component: XYComponentCore<any>;
+    componentContainer: XYContainer<any>;
+}
+
+declare class VisTooltipComponent implements TooltipConfigInterface, AfterViewInit {
+    /** An array of visualization components to interact with. Default: `[]` */
+    components?: ComponentCore<unknown>[];
+    /** Container to where the Tooltip component should be inserted. Default: `undefined` */
+    container?: HTMLElement;
+    /** Follow the mouse cursor. Default: `true` */
+    followCursor?: boolean;
+    /** Allow the tooltip to be hovered over and interacted with. Default: `false` */
+    allowHover?: boolean;
+    /** Horizontal placement of the tooltip. Default: `Position.Auto` */
+    horizontalPlacement?: Position | string | undefined;
+    /** Horizontal shift of the tooltip in pixels. Works only with
+     * `horizontalPlacement` set to `Position.Left` or `Position.Right`.
+     * Default: `0` */
+    horizontalShift?: number;
+    /** Vertical placement of the tooltip. Default: `Position.Top` */
+    verticalPlacement?: Position | string | undefined;
+    /** Vertical shift of the tooltip in pixels. Works only with
+     * `verticalPlacement` set to `Position.Top` or `Position.Bottom`.
+     * Default: `0` */
+    verticalShift?: number;
+    /** Defines the content of the tooltip and hovering over which elements should trigger it.
+     * An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: (d: unknown) => string | HTMLElement
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: (d: AreaDatum[]) => `<div>${d.value.toString()}</div>
+     * }
+     * ``` */
+    triggers?: {
+        [selector: string]: ((data: any, i: number, elements: (HTMLElement | SVGElement)[]) => string | HTMLElement | undefined | null | void) | undefined | null;
+    };
+    /** Custom DOM attributes for the tooltip. Useful when you need to refer to a specific tooltip instance
+     * by using a CSS selector. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[attributeName]: attribute value
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \'type': 'area-tooltip',
+     * \'value': 42
+     * }
+     * ``` */
+    attributes?: {
+        [attr: string]: string | number | boolean;
+    };
+    /** Custom class name for the tooltip. Default: `undefined` */
+    className?: string;
+    /** Hide delay in milliseconds. Default: `undefined` */
+    hideDelay?: number;
+    /** Show delay in milliseconds. Default: `undefined` */
+    showDelay?: number;
+    component: Tooltip | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisTooltipComponent, "vis-tooltip", never, { "components": { "alias": "components"; "required": false; }; "container": { "alias": "container"; "required": false; }; "followCursor": { "alias": "followCursor"; "required": false; }; "allowHover": { "alias": "allowHover"; "required": false; }; "horizontalPlacement": { "alias": "horizontalPlacement"; "required": false; }; "horizontalShift": { "alias": "horizontalShift"; "required": false; }; "verticalPlacement": { "alias": "verticalPlacement"; "required": false; }; "verticalShift": { "alias": "verticalShift"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "className": { "alias": "className"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; "showDelay": { "alias": "showDelay"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisAnnotationsComponent implements AnnotationsConfigInterface, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Legend items. Array of `AnnotationItem`:
+     * ```
+     * {
+     *  content: string | UnovisText | UnovisText[];
+     *  subject?: AnnotationSubject;
+     *  x?: LengthUnit;
+     *  y?: LengthUnit;
+     *  width?: LengthUnit;
+     *  height?: LengthUnit;
+     * }
+     * ```
+     * To learn more, see our docs https://unovis.dev/docs/components/Annotations/
+     * Default: `[]` */
+    items: AnnotationItem[] | undefined;
+    /** Debug option to render bounding boxes around text elements. Default: `false` */
+    renderTextBoundingBoxes?: boolean;
+    component: Annotations | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAnnotationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisAnnotationsComponent, "vis-annotations", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "items": { "alias": "items"; "required": false; }; "renderTextBoundingBoxes": { "alias": "renderTextBoundingBoxes"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisXYContainerComponent<Datum> implements AfterViewInit, AfterContentInit, OnDestroy {
+    containerRef: ElementRef;
+    visComponents: QueryList<VisXYComponent>;
+    tooltipComponent: VisTooltipComponent;
+    annotationsComponent: VisAnnotationsComponent;
+    /** Width in pixels or in CSS units.
+     * Percentage units `"%"` are not supported here. If you want to set `width` as a percentage, do it via `style` or `class`
+     * of the corresponding DOM element.
+     * Default: `undefined`
+    */
+    width?: number;
+    /** Height in pixels or in CSS units.
+     * Percentage units `"%"` are not supported here. If you want to set `height` as a percentage, do it via `style` or `class`
+     * of the corresponding DOM element.
+     * Default: `undefined`
+    */
+    height?: number;
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). Default: `Scale.scaleLinear()` */
+    xScale?: ContinuousScale;
+    /** Scale domain (data extent) for X dimension. By default this value is calculated automatically based on data. */
+    xDomain?: [number | undefined, number | undefined];
+    /** Constraint the minimum value of the X scale domain. Useful when the data is plotted along the X axis.
+     * For example, imagine that you have a chart with dynamic data that has negative values. When values are small
+     * (let's say in the range of [-0.01, 0]), you might still want the chart to display some meaningful value range (e.g. [-1, 0]). That can
+     * be achieved by setting `xDomainMinConstraint` to `[undefined, -1]`. In addition to that, if you want to cut off the
+     * values that are too low (let's say lower than -100), you can set the constraint to `[-100, -1]`
+     * Default: `undefined` */
+    xDomainMinConstraint?: [number | undefined, number | undefined];
+    /** Constraint the minimum value of the X scale domain. Useful when the data is plotted along the X axis.
+     * For example, imagine that you have a chart with dynamic data. When values are small
+     * (let's say < 0.01), you might still want the chart to display some meaningful value range (e.g. [0, 1]). That can
+     * be achieved by setting `xDomainMaxConstraint` to `[1, undefined]`. In addition to that, if you want to cut off the
+     * values that are too high (let's say higher than 100), you can set the constraint to `[1, 100]`
+     * Default: `undefined` */
+    xDomainMaxConstraint?: [number | undefined, number | undefined];
+    /** Force set the X scale range (in the screen space). By default the range is calculated automatically based on the
+     * chart's set up */
+    xRange?: [number, number];
+    /** Scale for Y dimension, e.g. Scale.ScaleLinear. Default: `Scale.ScaleLinear()` */
+    yScale?: ContinuousScale;
+    /** Scale domain (data extent) for Y dimension. By default this value is calculated automatically based on data. */
+    yDomain?: [number | undefined, number | undefined];
+    /** Constraint the minimum value of the Y scale domain.
+     * For example, imagine that you have a chart with dynamic data that has negative values. When values are small
+     * (let's say in the range of [-0.01, 0]), you might still want the chart to display some meaningful value range (e.g. [-1, 0]). That can
+     * be achieved by setting `yDomainMinConstraint` to `[undefined, -1]`. In addition to that, if you want to cut off the
+     * values that are too low (let's say lower than -100), you can set the constraint to `[-100, -1]`
+     * Default: `undefined` */
+    yDomainMinConstraint?: [number | undefined, number | undefined];
+    /** Constraint the minimum value of the Y scale domain.
+     * For example, imagine that you have a chart with dynamic data. When values are small
+     * (let's say < 0.01), you might still want the chart to display some meaningful value range (e.g. [0, 1]). That can
+     * be achieved by setting `yDomainMaxConstraint` to `[1, undefined]`. In addition to that, if you want to cut off the
+     * values that are too high (let's say higher than 100), you can set the constraint to `[1, 100]`
+     * Default: `undefined` */
+    yDomainMaxConstraint?: [number | undefined, number | undefined];
+    /** Force set the Y scale range (in the screen space). By default the range is calculated automatically based on the
+     * chart's set up */
+    yRange?: [number, number];
+    /** Y Axis direction. Default: `Direction.North` */
+    yDirection?: Direction.South | Direction.North | string;
+    /** Prevents the chart domain from being empty (when domain's min and max values are equal).
+     *  That usually happens when all the data values are the same or when there's no data.
+     *  Setting to `true` will automatically extend the domain by `+1` when needed.
+     *  Setting to `null` will extend the domain only when there's no data.
+     *  Setting to `false` will keep the domain as is.
+     *  Default: `null` */
+    preventEmptyDomain?: boolean | null;
+    /** Animation duration of all the components within the container. Default: `undefined` */
+    duration?: number;
+    /** Margins. Default: `{ top: 0, bottom: 0, left: 0, right: 0 }` */
+    margin?: Spacing;
+    /** Padding. Default: `{ top: 0, bottom: 0, left: 0, right: 0 }` */
+    padding?: Spacing;
+    /** Sets the Y scale domain based on the current X scale domain (not the whole dataset). Default: `false` */
+    scaleByDomain?: boolean;
+    /** Enables automatic calculation of chart margins based on the size of the axes. Default: `true` */
+    autoMargin?: boolean;
+    /** Override the automatically calculated bleed — the extra space (in pixels) the components request
+     * to fully fit into the container (e.g. half of the point diameter for Scatter), which gets subtracted
+     * from the scale ranges. Accepts a `Spacing` object or a function that receives the container's
+     * components (their individual bleed values are available via the `bleed` getter) and returns one.
+     * The sides you provide replace the calculated values, the sides left `undefined` fall back to them —
+     * pass `0` explicitly to remove the bleed on a side.
+     * Useful for synchronizing the scale ranges of multiple charts, since the final bleed is provided
+     * to the `onRenderComplete` callback. Default: `undefined` */
+    bleed?: Spacing | ((components: XYComponentCore<Datum>[]) => Spacing);
+    /** Alternative text description of the chart for accessibility purposes. It will be applied as an
+     * `aria-label` attribute to the div element containing your chart. Default: `undefined`.
+    */
+    ariaLabel?: string | null | undefined;
+    /** A custom color function to be used for all the components within the container.
+     * Maps indices or data color keys (when `colorKeys` are provided to components) to colors.
+     * Default: `undefined`
+    */
+    colorFunction?: ColorFunction;
+    /** Data to be passed to all child components. But if `data` is `undefined` it'll to be passed allowing components to
+     * have their individual data. Default: `undefined` */
+    data?: Datum[] | undefined;
+    chart: XYContainer<Datum>;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getConfig(): XYContainerConfigInterface<Datum>;
+    passContainerReferenceToChildren(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisXYContainerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisXYContainerComponent<any>, "vis-xy-container", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "xDomain": { "alias": "xDomain"; "required": false; }; "xDomainMinConstraint": { "alias": "xDomainMinConstraint"; "required": false; }; "xDomainMaxConstraint": { "alias": "xDomainMaxConstraint"; "required": false; }; "xRange": { "alias": "xRange"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "yDomain": { "alias": "yDomain"; "required": false; }; "yDomainMinConstraint": { "alias": "yDomainMinConstraint"; "required": false; }; "yDomainMaxConstraint": { "alias": "yDomainMaxConstraint"; "required": false; }; "yRange": { "alias": "yRange"; "required": false; }; "yDirection": { "alias": "yDirection"; "required": false; }; "preventEmptyDomain": { "alias": "preventEmptyDomain"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "scaleByDomain": { "alias": "scaleByDomain"; "required": false; }; "autoMargin": { "alias": "autoMargin"; "required": false; }; "bleed": { "alias": "bleed"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "colorFunction": { "alias": "colorFunction"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, ["tooltipComponent", "annotationsComponent", "visComponents"], ["*"], false, never>;
+}
+
+declare class VisXYContainerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisXYContainerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisXYContainerModule, [typeof VisXYContainerComponent], never, [typeof VisXYContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisXYContainerModule>;
+}
+
+declare class VisSingleContainerComponent<Data = unknown, C extends ComponentCore<Data> = ComponentCore<Data>> implements AfterViewInit, OnDestroy {
+    containerRef: ElementRef;
+    visComponent: VisCoreComponent;
+    tooltipComponent: VisTooltipComponent;
+    annotationsComponent: VisAnnotationsComponent;
+    /** Width in pixels or in CSS units.
+     * Percentage units `"%"` are not supported here. If you want to set `width` as a percentage, do it via `style` or `class`
+     * of the corresponding DOM element.
+     * Default: `undefined`
+    */
+    width?: number;
+    /** Height in pixels or in CSS units.
+     * Percentage units `"%"` are not supported here. If you want to set `height` as a percentage, do it via `style` or `class`
+     * of the corresponding DOM element.
+     * Default: `undefined`
+    */
+    height?: number;
+    /** Margins. Default: `{ top: 0, bottom: 0, left: 0, right: 0 }` */
+    margin?: Spacing;
+    /** Animation duration of all the components within the container. Default: `undefined` */
+    duration?: number;
+    /** Alternative text description of the chart for accessibility purposes. It will be applied as an
+     * `aria-label` attribute to the div element containing your chart. Default: `undefined`.
+    */
+    ariaLabel?: string | null | undefined;
+    /** Custom SVG defs available to all the components within the container. Default: `undefined`. */
+    svgDefs?: string;
+    /** Defines whether components should fit into the container or the container should expand to fit to the component's size.
+     * Works with a limited set of components. Default: `Sizing.Fit` */
+    sizing?: Sizing | string;
+    /** A custom color function to be used for all the components within the container.
+     * Maps indices or data color keys (when `colorKeys` are provided to components) to colors.
+     * Default: `undefined`
+    */
+    colorFunction?: ColorFunction;
+    /** Data to be passed to the component. Default: `undefined`. */
+    data?: Data;
+    chart: SingleContainer<Data>;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getConfig(): SingleContainerConfigInterface<Data>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisSingleContainerComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisSingleContainerComponent<any, any>, "vis-single-container", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "svgDefs": { "alias": "svgDefs"; "required": false; }; "sizing": { "alias": "sizing"; "required": false; }; "colorFunction": { "alias": "colorFunction"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, ["visComponent", "tooltipComponent", "annotationsComponent"], ["*"], false, never>;
+}
+
+declare class VisSingleContainerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisSingleContainerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisSingleContainerModule, [typeof VisSingleContainerComponent], never, [typeof VisSingleContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisSingleContainerModule>;
+}
+
+declare class VisAreaComponent<Datum> implements AreaConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Area color accessor function. The whole data array will be passed as the first argument. Default: `undefined` */
+    color?: ColorAccessor<Datum[]>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Area fill pattern accessor. Resolves to a `FillPatternType`. The whole data array is passed as the first argument. Default: `undefined` */
+    pattern?: GenericAccessor<FillPatternType, Datum[]>;
+    /** Curve type from the CurveType enum. Default: `CurveType.MonotoneX` */
+    curveType?: CurveType | string;
+    /** Baseline value or accessor function. Default: `undefined` */
+    baseline?: NumericAccessor<Datum>;
+    /** Opacity value or accessor function. Default: `1` */
+    opacity?: NumericAccessor<Datum[]>;
+    /** Optional area cursor. String or accessor function. Default: `null` */
+    cursor?: StringAccessor<Datum[]>;
+    /** Display a line on the top of the area. Default: `false` */
+    line?: boolean;
+    /** Line color accessor function. The whole data array will be passed as the first argument. Default: `undefined` */
+    lineColor?: ColorAccessor<Datum[]>;
+    /** Line width in pixels. Default: `2` */
+    lineWidth?: number;
+    /** Line dash array, see SVG's stroke-dasharray. Default: `undefined` */
+    lineDashArray?: GenericAccessor<number[], Datum[]>;
+    /** Pattern accessor for the area's outline. Resolves to a `LinePatternType`. The whole data array is passed as the first argument. Default: `undefined` */
+    linePattern?: GenericAccessor<LinePatternType, Datum[]>;
+    /** If an area is smaller than 1px, extend it to have 1px height. Default: `false` */
+    minHeight1Px?: boolean;
+    /** Minimum height of the area, use carefully.
+     * This setting is useful when some of the area values are zeros or very small so visually they become
+     * practically invisible, but you want to show that the data behind them exists and they're not just empty segments.
+     * Default: `undefined` */
+    minHeight?: number;
+    /** Whether to stack min height areas or not. Default: `undefined` */
+    stackMinHeight?: boolean;
+    data: Datum[];
+    component: Area<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAreaComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisAreaComponent<any>, "vis-area", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "curveType": { "alias": "curveType"; "required": false; }; "baseline": { "alias": "baseline"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "line": { "alias": "line"; "required": false; }; "lineColor": { "alias": "lineColor"; "required": false; }; "lineWidth": { "alias": "lineWidth"; "required": false; }; "lineDashArray": { "alias": "lineDashArray"; "required": false; }; "linePattern": { "alias": "linePattern"; "required": false; }; "minHeight1Px": { "alias": "minHeight1Px"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "stackMinHeight": { "alias": "stackMinHeight"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisAreaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAreaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisAreaModule, [typeof VisAreaComponent], never, [typeof VisAreaComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisAreaModule>;
+}
+
+declare class VisAnnotationsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAnnotationsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisAnnotationsModule, [typeof VisAnnotationsComponent], never, [typeof VisAnnotationsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisAnnotationsModule>;
+}
+
+declare class VisAxisComponent<Datum> implements AxisConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Axis position: `Position.Top`, `Position.Bottom`, `Position.Right` or `Position.Left`. Default: `undefined` */
+    position?: Position | `${Position}`;
+    /** Axis type: `AxisType.X` or `AxisType.Y` */
+    type?: AxisType | `${AxisType}`;
+    /** Extend the axis domain line to be full width or full height. Default: `true` */
+    fullSize?: boolean;
+    /** Axis label. Default: `undefined` */
+    label?: string;
+    /** Font size of the axis label as CSS string. Default: `null` */
+    labelFontSize?: string | null;
+    /** Distance between the axis and the label in pixels. Default: `8` */
+    labelMargin?: number;
+    /** Label text fit mode: `FitMode.Wrap` or `FitMode.Trim`. Default: `FitMode.Wrap`. */
+    labelTextFitMode?: FitMode | `${FitMode}`;
+    /** Label text trim mode: `TrimMode.Start`, `TrimMode.Middle` or `TrimMode.End`. Default: `TrimMode.Middle` */
+    labelTextTrimType?: TrimMode | `${TrimMode}`;
+    /** Label text wrapping separator. String or array of strings. Default: `undefined` */
+    labelTextSeparator?: string | string[];
+    /** Font color of the axis label as CSS string. Default: `null` */
+    labelColor?: string | null;
+    /** Sets whether to draw the grid lines or not. Default: `true` */
+    gridLine?: boolean;
+    /** Sets whether to draw the tick lines or not. Default: `true` */
+    tickLine?: boolean;
+    /** Sets whether to draw the domain line or not. Default: `true` */
+    domainLine?: boolean;
+    /** Draw only the min and max axis ticks. Default: `false` */
+    minMaxTicksOnly?: boolean;
+    /** Show grid lines for the min and max axis ticks. Default: `false` */
+    minMaxTicksOnlyShowGridLines?: boolean;
+    /** Draw only the min and max axis ticks, when the chart width is less than the specified value.
+     * Has no effect when `tickTextAdaptiveSets` is enabled.
+     * Default: `250` */
+    minMaxTicksOnlyWhenWidthIsLess?: number;
+    /** Tick label formatter function. Default: `undefined` */
+    tickFormat?: ((tick: number | Date, i: number, ticks: number[] | Date[]) => string);
+    /** Explicitly set tick values. Default: `undefined` */
+    tickValues?: number[];
+    /** Set the approximate number of axis ticks (will be passed to D3's axis constructor). Default: `undefined` */
+    numTicks?: number;
+    /** Approximate spacing between ticks in pixels, used to derive the number of ticks
+     * when `numTicks` is not set. Only applies to the X axis. Default: `175` */
+    tickSpacing?: number;
+    /** Tick text fit mode: `FitMode.Wrap` or `FitMode.Trim`. Default: `FitMode.Wrap`. */
+    tickTextFitMode?: FitMode | `${FitMode}`;
+    /** Maximum width in pixels for the tick text to be wrapped or trimmed. Default: `undefined` */
+    tickTextWidth?: number;
+    /** Tick text wrapping separator. String or array of strings. Default: `undefined` */
+    tickTextSeparator?: string | string[];
+    /** Force word break for ticks when they don't fit. Default: `false` */
+    tickTextForceWordBreak?: boolean;
+    /** Tick text trim mode: `TrimMode.Start`, `TrimMode.Middle` or `TrimMode.End`. Default: `TrimMode.Middle` */
+    tickTextTrimType?: TrimMode | `${TrimMode}`;
+    /** Font size of the tick text as CSS string. Default: `null` */
+    tickTextFontSize?: string | null;
+    /** Text alignment for ticks: `TextAlign.Left`, `TextAlign.Center` or `TextAlign.Right`. Default: `undefined` */
+    tickTextAlign?: TextAlign | `${TextAlign}` | ((tickValue: number | Date, tickIndex: number, tickValues: number[] | Date[], tickPosition: [number, number], componentWidth: number, componentHeight: number) => TextAlign | `${TextAlign}`);
+    /** Font color of the tick text as CSS string. Default: `null` */
+    tickTextColor?: string | null;
+    /** Text rotation angle for ticks. Default: `undefined` */
+    tickTextAngle?: number;
+    /** Adaptively pick the number of ticks so that their labels don't overlap: the axis renders the
+     * largest "nice" tick set that fits (measured off-screen), degrading to smaller sets on narrow
+     * charts. `numTicks` (or its width-based default) acts as the upper bound. With explicit
+     * `tickValues`, every-k-th subsets of them are fitted instead.
+     * Has no effect when `minMaxTicksOnly` is set, and disables the width-based
+     * `minMaxTicksOnlyWhenWidthIsLess` fallback. Default: `undefined` */
+    tickTextAdaptiveSets?: boolean;
+    /** Hide tick labels that overlap with each other.
+     * To define overlapping, a simple bounding box collision detection algorithm is used.
+     * Which means the result won't be accurate when `tickTextAngle` is specified.
+     * Consider combining with `tickTextAdaptiveSets` to keep the shown ticks evenly spaced.
+     * Default: `undefined` */
+    tickTextHideOverlapping?: boolean;
+    /** The spacing in pixels between the tick and it's label. Default: `8` */
+    tickPadding?: number;
+    /** The size of the tick marks in pixels. Accepts a single number (applies to both inner and outer ticks)
+     * or a tuple `[innerTickSize, outerTickSize]`. Default: `6` */
+    tickSize?: number | [number, number];
+    data: Datum[];
+    component: Axis<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAxisComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisAxisComponent<any>, "vis-axis", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "position": { "alias": "position"; "required": false; }; "type": { "alias": "type"; "required": false; }; "fullSize": { "alias": "fullSize"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelFontSize": { "alias": "labelFontSize"; "required": false; }; "labelMargin": { "alias": "labelMargin"; "required": false; }; "labelTextFitMode": { "alias": "labelTextFitMode"; "required": false; }; "labelTextTrimType": { "alias": "labelTextTrimType"; "required": false; }; "labelTextSeparator": { "alias": "labelTextSeparator"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "gridLine": { "alias": "gridLine"; "required": false; }; "tickLine": { "alias": "tickLine"; "required": false; }; "domainLine": { "alias": "domainLine"; "required": false; }; "minMaxTicksOnly": { "alias": "minMaxTicksOnly"; "required": false; }; "minMaxTicksOnlyShowGridLines": { "alias": "minMaxTicksOnlyShowGridLines"; "required": false; }; "minMaxTicksOnlyWhenWidthIsLess": { "alias": "minMaxTicksOnlyWhenWidthIsLess"; "required": false; }; "tickFormat": { "alias": "tickFormat"; "required": false; }; "tickValues": { "alias": "tickValues"; "required": false; }; "numTicks": { "alias": "numTicks"; "required": false; }; "tickSpacing": { "alias": "tickSpacing"; "required": false; }; "tickTextFitMode": { "alias": "tickTextFitMode"; "required": false; }; "tickTextWidth": { "alias": "tickTextWidth"; "required": false; }; "tickTextSeparator": { "alias": "tickTextSeparator"; "required": false; }; "tickTextForceWordBreak": { "alias": "tickTextForceWordBreak"; "required": false; }; "tickTextTrimType": { "alias": "tickTextTrimType"; "required": false; }; "tickTextFontSize": { "alias": "tickTextFontSize"; "required": false; }; "tickTextAlign": { "alias": "tickTextAlign"; "required": false; }; "tickTextColor": { "alias": "tickTextColor"; "required": false; }; "tickTextAngle": { "alias": "tickTextAngle"; "required": false; }; "tickTextAdaptiveSets": { "alias": "tickTextAdaptiveSets"; "required": false; }; "tickTextHideOverlapping": { "alias": "tickTextHideOverlapping"; "required": false; }; "tickPadding": { "alias": "tickPadding"; "required": false; }; "tickSize": { "alias": "tickSize"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisAxisModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisAxisModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisAxisModule, [typeof VisAxisComponent], never, [typeof VisAxisComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisAxisModule>;
+}
+
+declare class VisBoxplotComponent<Datum> implements BoxplotConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Box fill color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Median accessor function. Defines the position of the median line inside the box.
+     * Default: `undefined` */
+    median?: NumericAccessor<Datum>;
+    /** Quartiles accessor function returning a `[q1, q3]` tuple. Defines the bottom and the top of the box.
+     * Default: `undefined` */
+    quartiles?: GenericAccessor<[number, number], Datum>;
+    /** Whiskers accessor function returning a `[min, max]` tuple. Defines the bottom and the top whisker ends.
+     * Default: `undefined` */
+    whiskers?: GenericAccessor<[number, number], Datum>;
+    /** Force set the box width in pixels. Default: `undefined` */
+    barWidth?: number;
+    /** Maximum box width for dynamic sizing. Default: `undefined` */
+    barMaxWidth?: number;
+    /** Expected step between the boxes in the X axis units. When the data has missing points the step
+     * can't be inferred reliably from the data, so set it explicitly here to size the boxes correctly.
+     * Default: `undefined` */
+    dataStep?: number;
+    /** Fractional padding between the boxes in the range of [0,1). Default: `0.25` */
+    barPadding?: number;
+    /** Rounded corners for the box. Boolean or number (to set the radius in pixels). Default: `2` */
+    roundedCorners?: number | boolean;
+    /** Configurable box cursor when hovering over. Default: `null` */
+    cursor?: StringAccessor<Datum>;
+    data: Datum[];
+    component: Boxplot<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBoxplotComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisBoxplotComponent<any>, "vis-boxplot", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "median": { "alias": "median"; "required": false; }; "quartiles": { "alias": "quartiles"; "required": false; }; "whiskers": { "alias": "whiskers"; "required": false; }; "barWidth": { "alias": "barWidth"; "required": false; }; "barMaxWidth": { "alias": "barMaxWidth"; "required": false; }; "dataStep": { "alias": "dataStep"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundedCorners": { "alias": "roundedCorners"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisBoxplotModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBoxplotModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisBoxplotModule, [typeof VisBoxplotComponent], never, [typeof VisBoxplotComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisBoxplotModule>;
+}
+
+declare class VisBrushComponent<Datum> implements BrushConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Callback function to be called on any Brush event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrush?: ((selection: [number, number] | undefined, event: D3BrushEvent<Datum>, userDriven: boolean) => void);
+    /** Callback function to be called on the Brush start event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrushStart?: ((selection: [number, number] | undefined, event: D3BrushEvent<Datum>, userDriven: boolean) => void);
+    /** Callback function to be called on the Brush move event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrushMove?: ((selection: [number, number] | undefined, event: D3BrushEvent<Datum>, userDriven: boolean) => void);
+    /** Callback function to be called on the Brush end event.
+     * Default: `(selection: [number, number], event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrushEnd?: ((selection: [number, number] | undefined, event: D3BrushEvent<Datum>, userDriven: boolean) => void);
+    /** Width of the Brush handle. Default: `1` */
+    handleWidth?: number;
+    /** Brush selection in the data space coordinates, can be used to control the selection. Default: `undefined` */
+    selection?: [number, number] | null;
+    /** Allow dragging the selected area as a whole in order to change the selected range. Default: `false` */
+    draggable?: boolean;
+    /** Position of the handle: `Arrangement.Inside` or `Arrangement.Outside`. Default: `Arrangement.Inside` */
+    handlePosition?: Arrangement.Inside | Arrangement.Outside | string;
+    /** Constraint Brush selection to a minimal length in data units. Default: `undefined` */
+    selectionMinLength?: number;
+    /** Extend the brush height by the specified number of pixels. This can be convenient when you have thick lines
+     * at the bottom of the chart and you want to ensure they stay fully covered by the brush. Default: `0` */
+    brushHeightExtend?: number;
+    data: Datum[];
+    component: Brush<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBrushComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisBrushComponent<any>, "vis-brush", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "onBrush": { "alias": "onBrush"; "required": false; }; "onBrushStart": { "alias": "onBrushStart"; "required": false; }; "onBrushMove": { "alias": "onBrushMove"; "required": false; }; "onBrushEnd": { "alias": "onBrushEnd"; "required": false; }; "handleWidth": { "alias": "handleWidth"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "handlePosition": { "alias": "handlePosition"; "required": false; }; "selectionMinLength": { "alias": "selectionMinLength"; "required": false; }; "brushHeightExtend": { "alias": "brushHeightExtend"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisBrushModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBrushModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisBrushModule, [typeof VisBrushComponent], never, [typeof VisBrushComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisBrushModule>;
+}
+
+declare class VisChordDiagramComponent<N extends ChordInputNode, L extends ChordInputLink> implements ChordDiagramConfigInterface<N, L>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Angular range of the diagram. Default: `[0, 2 * Math.PI]` */
+    angleRange?: [number, number];
+    /** Corner radius constant value or accessor function. Default: `2` */
+    cornerRadius?: NumericAccessor<ChordNodeDatum<N>>;
+    /** Node id or index to highlight. Overrides default hover behavior if supplied. Default: `undefined` */
+    highlightedNodeId?: number | string;
+    /** Link ids or index values to highlight. Overrides default hover behavior if supplied. Default: [] */
+    highlightedLinkIds?: (number | string)[];
+    /** Link color accessor function. Default: `var(--vis-chord-diagram-link-fill-color)` */
+    linkColor?: ColorAccessor<ChordLinkDatum<N, L>>;
+    /** Link fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    linkPattern?: GenericAccessor<FillPatternType, ChordLinkDatum<N, L>>;
+    /** Link value accessor function. Default: `l => l.value` */
+    linkValue?: NumericAccessor<ChordLinkDatum<N, L>>;
+    /** Array of node hierarchy levels. Data records are supposed to have corresponding properties, e.g. ['level1', 'level2']. Default: `[]` */
+    nodeLevels?: string[];
+    /** Node width in pixels. Default: `15` */
+    nodeWidth?: number;
+    /** Node color accessor function ot constant value. Default: `d => d.color` */
+    nodeColor?: ColorAccessor<ChordNodeDatum<N>>;
+    /** Node fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    nodePattern?: GenericAccessor<FillPatternType, ChordNodeDatum<N>>;
+    /** Node label accessor function. Default: `d => d.label ?? d.key` */
+    nodeLabel?: StringAccessor<ChordNodeDatum<N>>;
+    /** Node label color accessor function. Default: `undefined` */
+    nodeLabelColor?: StringAccessor<ChordNodeDatum<N>>;
+    /** Node label alignment. Default: `ChordLabelAlignment.Along` */
+    nodeLabelAlignment?: GenericAccessor<ChordLabelAlignment | string, ChordNodeDatum<N>>;
+    /** Pad angle in radians. Default: `0.02` */
+    padAngle?: number;
+    /** The exponent property of the radius scale. Default: `2` */
+    radiusScaleExponent?: number;
+    data: {
+        nodes: N[];
+        links?: L[];
+    };
+    component: ChordDiagram<N, L> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisChordDiagramComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisChordDiagramComponent<any, any>, "vis-chord-diagram", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "angleRange": { "alias": "angleRange"; "required": false; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; }; "highlightedNodeId": { "alias": "highlightedNodeId"; "required": false; }; "highlightedLinkIds": { "alias": "highlightedLinkIds"; "required": false; }; "linkColor": { "alias": "linkColor"; "required": false; }; "linkPattern": { "alias": "linkPattern"; "required": false; }; "linkValue": { "alias": "linkValue"; "required": false; }; "nodeLevels": { "alias": "nodeLevels"; "required": false; }; "nodeWidth": { "alias": "nodeWidth"; "required": false; }; "nodeColor": { "alias": "nodeColor"; "required": false; }; "nodePattern": { "alias": "nodePattern"; "required": false; }; "nodeLabel": { "alias": "nodeLabel"; "required": false; }; "nodeLabelColor": { "alias": "nodeLabelColor"; "required": false; }; "nodeLabelAlignment": { "alias": "nodeLabelAlignment"; "required": false; }; "padAngle": { "alias": "padAngle"; "required": false; }; "radiusScaleExponent": { "alias": "radiusScaleExponent"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisChordDiagramModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisChordDiagramModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisChordDiagramModule, [typeof VisChordDiagramComponent], never, [typeof VisChordDiagramComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisChordDiagramModule>;
+}
+
+declare class VisCrosshairComponent<Datum> implements CrosshairConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Optional accessor function for getting the values along the X axis. Default: `undefined` */
+    x?: NumericAccessor<Datum>;
+    /** Optional single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y?: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Optional color array or color accessor function for crosshair circles. Default: `d => d.color` */
+    color?: ColorAccessor<Datum>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Optional stroke color accessor function for crosshair circles. Default: `undefined` */
+    strokeColor?: ColorAccessor<Datum>;
+    /** Optional stroke width for crosshair circles. Default: `undefined` */
+    strokeWidth?: NumericAccessor<Datum>;
+    /** Radius of crosshair circles in pixels. Default: `3` */
+    circleRadius?: number;
+    /** When `true`, the Crosshair also renders a horizontal line. The line is placed at the Y position of the
+     * crosshair circle closest to the mouse pointer (i.e. the snapped data point), or follows the pointer
+     * when there are no circles to snap to (e.g. when `snapToData` is `false`). Default: `false` */
+    showHorizontalLine?: boolean;
+    /** Separate array of accessors for stacked components (eg StackedBar, Area). Default: `undefined` */
+    yStacked?: NumericAccessor<Datum>[];
+    /** Baseline accessor function for stacked values, useful with stacked areas. Default: `null` */
+    baseline?: NumericAccessor<Datum>;
+    /** An instance of the Tooltip component to be used with Crosshair. Default: `undefined` */
+    tooltip?: Tooltip | undefined;
+    /** Tooltip template accessor. The function is supposed to return either a valid HTML string or an HTMLElement.
+     * When `snapToData` is `false`, `datum` will be `undefined` but `data` and `leftNearestDatumIndex` will be provided.
+     * Default: `d => ''` */
+    template?: (datum: Datum, x: number | Date, data: Datum[], leftNearestDatumIndex?: number) => string | HTMLElement;
+    /** Hide Crosshair when the corresponding datum element is far from mouse pointer. Default: `true` */
+    hideWhenFarFromPointer?: boolean;
+    /** Distance in pixels to check in the hideWhenFarFromPointer condition. Default: `100` */
+    hideWhenFarFromPointerDistance?: number;
+    /** Snap to the nearest data point.
+     * If disabled, the tooltip template will receive only the horizontal position of the crosshair and you'll be responsible
+     * for getting the underlying data records and crosshair circles (see the `getCircles` configuration option).
+     * Default: `true` */
+    snapToData?: boolean;
+    /** When `snapToData` is enabled, controls how the nearest datum is found:
+     * - `CrosshairSnapMode.XY`: snap to the datum closest to the mouse pointer in both X and Y (measured in pixel space).
+     *  This is the right choice for Scatter charts where many points can share similar X values.
+     * - `CrosshairSnapMode.X`: snap to the datum closest along the X axis only. Best for time series / line / area
+     *  charts where the crosshair is a vertical line tracking the X position.
+     *
+     * Has no effect when `forceShowAt` is set (no pointer Y is available — it falls back to `CrosshairSnapMode.X`).
+     * Default: `CrosshairSnapMode.X` */
+    snapMode?: CrosshairSnapMode | `${CrosshairSnapMode}`;
+    /** Custom function for setting up the crosshair circles, usually needed when `snapToData` is set to `false`.
+     * The function receives the horizontal position of the crosshair (in the data space, not in pixels), the data array,
+     * the `yScale` instance to help you calculate the correct vertical position of the circles, and the nearest datum index.
+     * It has to return an array of the `CrosshairCircle` objects: `{ y: number; color: string; opacity?: number }[]`.
+     * Default: `undefined` */
+    getCircles?: (x: number | Date, data: Datum[], yScale: ContinuousScale, leftNearestDatumIndex?: number) => CrosshairCircle[];
+    /** Callback function that is called when the crosshair is moved:
+     * - `x` is the horizontal position of the crosshair in the data space;
+     * - `datum` is the nearest datum to the crosshair;
+     * - `datumIndex` is the index of the nearest datum.
+     * - `event` is the event that triggered the crosshair move (mouse or wheel).
+     *
+     * When the mouse goes out of the container and on wheel events, all the arguments are `undefined` except for `event`.
+     * Default: `undefined` */
+    onCrosshairMove?: (x?: number | Date, datum?: Datum, datumIndex?: number, event?: MouseEvent | WheelEvent) => void;
+    /** Force the crosshair to show at a specific position. Default: `undefined` */
+    forceShowAt?: number | Date;
+    /** Skip range checks for crosshair visibility. When true, crosshair will show regardless of position within chart bounds. Default: `false`
+     * This is useful for testing, especially when you only triggers mousemove event but does not have real mouse event. */
+    skipRangeCheck?: boolean;
+    /** Minimum fraction (`0` to `1`) of the container's area that must be visible in the
+     * viewport for the Crosshair (and its Tooltip) to be displayed. This prevents the
+     * Crosshair from showing when the chart is mostly scrolled out of view. Charts that are
+     * wider or taller than the viewport may never reach the default ratio, so lower this
+     * value (or set it to `0` to always show the Crosshair) for large charts. Default: `0.35` */
+    visibilityThreshold?: number;
+    data: Datum[];
+    component: Crosshair<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisCrosshairComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisCrosshairComponent<any>, "vis-crosshair", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "circleRadius": { "alias": "circleRadius"; "required": false; }; "showHorizontalLine": { "alias": "showHorizontalLine"; "required": false; }; "yStacked": { "alias": "yStacked"; "required": false; }; "baseline": { "alias": "baseline"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "template": { "alias": "template"; "required": false; }; "hideWhenFarFromPointer": { "alias": "hideWhenFarFromPointer"; "required": false; }; "hideWhenFarFromPointerDistance": { "alias": "hideWhenFarFromPointerDistance"; "required": false; }; "snapToData": { "alias": "snapToData"; "required": false; }; "snapMode": { "alias": "snapMode"; "required": false; }; "getCircles": { "alias": "getCircles"; "required": false; }; "onCrosshairMove": { "alias": "onCrosshairMove"; "required": false; }; "forceShowAt": { "alias": "forceShowAt"; "required": false; }; "skipRangeCheck": { "alias": "skipRangeCheck"; "required": false; }; "visibilityThreshold": { "alias": "visibilityThreshold"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisCrosshairModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisCrosshairModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisCrosshairModule, [typeof VisCrosshairComponent], never, [typeof VisCrosshairComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisCrosshairModule>;
+}
+
+declare class VisDonutComponent<Datum> implements DonutConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string | number);
+    /** Value accessor function. Default: `undefined` */
+    value: NumericAccessor<Datum>;
+    /** Diagram angle range. Default: `[0, 2 * Math.PI]` */
+    angleRange?: [number, number];
+    /** Pad angle. Default: `0` */
+    padAngle?: number;
+    /** Minimum angular sweep, in radians, for any segment with a positive value.
+     * Segments whose proportional sweep would be smaller are inflated to this angle,
+     * with the difference taken proportionally from the remaining segments.
+     * Guarantees a segment can survive the `padAngle` inset instead of collapsing
+     * to a zero-area path; a sensible setting is `minSegmentAngle >= 2 * padAngle`.
+     * Default: `undefined` */
+    minSegmentAngle?: number;
+    /** Custom sort function. Default: `undefined` */
+    sortFunction?: (a: Datum, b: Datum) => number;
+    /** Corner Radius. Default: `0` */
+    cornerRadius?: number;
+    /** Color accessor function. Default: `undefined` */
+    color?: ColorAccessor<Datum>;
+    /** Fill pattern accessor. Resolves to a `FillPatternType`.
+     * When unset and `theme-patterns` is active, a default pattern is applied by segment index. Default: `undefined` */
+    pattern?: GenericAccessor<FillPatternType, Datum>;
+    /** Explicitly set the donut outer radius. Default: `undefined` */
+    radius?: number;
+    /** Arc width in pixels. Set to `0` if you want to have a pie chart. Default: `20` */
+    arcWidth?: number;
+    /** Central label accessor function or text. Default: `undefined` */
+    centralLabel?: string;
+    /** Central sub-label accessor function or text. Default: `undefined` */
+    centralSubLabel?: string;
+    /** Enables wrapping for the sub-label. Default: `true` */
+    centralSubLabelWrap?: boolean;
+    /** When true, the component will display empty segments (the ones that have `0` values) as tiny slices.
+     * Default: `false` */
+    showEmptySegments?: boolean;
+    /** Angular size for empty segments in radians. Default: `0.5 * Math.PI / 180` */
+    emptySegmentAngle?: number;
+    /** Show donut background. The color is configurable via
+     * the `--vis-donut-background-color` and `--vis-dark-donut-background-color` CSS variables.
+     * Default: `true` */
+    showBackground?: boolean;
+    /** Background angle range. When undefined, the value will be taken from `angleRange`. Default: `undefined` */
+    backgroundAngleRange?: [number, number];
+    /** Central label and sub-label horizontal offset in pixels. Default: `undefined` */
+    centralLabelOffsetX?: number;
+    /** Central label and sub-label vertical offset in pixels. Default: `undefined` */
+    centralLabelOffsetY?: number;
+    data: Datum[];
+    component: Donut<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisDonutComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisDonutComponent<any>, "vis-donut", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "id": { "alias": "id"; "required": false; }; "value": { "alias": "value"; "required": false; }; "angleRange": { "alias": "angleRange"; "required": false; }; "padAngle": { "alias": "padAngle"; "required": false; }; "minSegmentAngle": { "alias": "minSegmentAngle"; "required": false; }; "sortFunction": { "alias": "sortFunction"; "required": false; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; }; "color": { "alias": "color"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "arcWidth": { "alias": "arcWidth"; "required": false; }; "centralLabel": { "alias": "centralLabel"; "required": false; }; "centralSubLabel": { "alias": "centralSubLabel"; "required": false; }; "centralSubLabelWrap": { "alias": "centralSubLabelWrap"; "required": false; }; "showEmptySegments": { "alias": "showEmptySegments"; "required": false; }; "emptySegmentAngle": { "alias": "emptySegmentAngle"; "required": false; }; "showBackground": { "alias": "showBackground"; "required": false; }; "backgroundAngleRange": { "alias": "backgroundAngleRange"; "required": false; }; "centralLabelOffsetX": { "alias": "centralLabelOffsetX"; "required": false; }; "centralLabelOffsetY": { "alias": "centralLabelOffsetY"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisDonutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisDonutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisDonutModule, [typeof VisDonutComponent], never, [typeof VisDonutComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisDonutModule>;
+}
+
+declare class VisFreeBrushComponent<Datum> implements FreeBrushConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Brush selection mode. X - horizontal, Y - vertical, XY - both. Default: `FreeBrushMode.X` */
+    mode?: FreeBrushMode;
+    /** Callback function to be called on any Brush event.
+     * Default: `(selection: FreeBrushSelection, event: D3BrushEvent<Datum>, userDriven: boolean): void => {}` */
+    onBrush?: ((selection: FreeBrushSelection | undefined, event: D3BrushEvent<unknown>, userDriven: boolean) => void);
+    /** Callback function to be called on the Brush start event.
+     * Default: `(selection: FreeBrushSelection, event: D3BrushEvent<unknown>, userDriven: boolean): void => {}` */
+    onBrushStart?: ((selection: FreeBrushSelection | undefined, event: D3BrushEvent<unknown>, userDriven: boolean) => void);
+    /** Callback function to be called on the Brush move event.
+     * Default: `(selection: FreeBrushSelection, event: D3BrushEvent<unknown>, userDriven: boolean): void => {}` */
+    onBrushMove?: ((selection: FreeBrushSelection | undefined, event: D3BrushEvent<unknown>, userDriven: boolean) => void);
+    /** Callback function to be called on the Brush end event.
+     * Default: `(selection: FreeBrushSelection, event: D3BrushEvent<unknown>, userDriven: boolean)L void => {}` */
+    onBrushEnd?: ((selection: FreeBrushSelection | undefined, event: D3BrushEvent<unknown>, userDriven: boolean) => void);
+    /** Width of the Brush handle. Default: `1` */
+    handleWidth?: number;
+    /** Brush selection in data space, can be used to force set the selection from outside.
+     * In case of two dimensional mode, the selection has the following format: `[[xMin, xMax], [yMin, yMax]]`.
+     * This config property gets updated on internal brush events. Default: `undefined` */
+    selection?: FreeBrushSelection | null | undefined;
+    /** Constraint Brush selection to a minimal length in data units. Default: `undefined` */
+    selectionMinLength?: number | [number, number];
+    /** Automatically hide the brush after selection. Default: `true` */
+    autoHide?: boolean;
+    data: Datum[];
+    component: FreeBrush<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisFreeBrushComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisFreeBrushComponent<any>, "vis-free-brush", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "onBrush": { "alias": "onBrush"; "required": false; }; "onBrushStart": { "alias": "onBrushStart"; "required": false; }; "onBrushMove": { "alias": "onBrushMove"; "required": false; }; "onBrushEnd": { "alias": "onBrushEnd"; "required": false; }; "handleWidth": { "alias": "handleWidth"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "selectionMinLength": { "alias": "selectionMinLength"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisFreeBrushModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisFreeBrushModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisFreeBrushModule, [typeof VisFreeBrushComponent], never, [typeof VisFreeBrushComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisFreeBrushModule>;
+}
+
+declare class VisGraphComponent<N extends GraphInputNode, L extends GraphInputLink> implements GraphConfigInterface<N, L>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Zoom level constraints. Default: [0.35, 1.25] */
+    zoomScaleExtent?: [number, number];
+    /** Disable zooming. Default: `false` */
+    disableZoom?: boolean;
+    /** Custom Zoom event filter to better control which actions should trigger zooming.
+     * Learn more: https://d3js.org/d3-zoom#zoom_filter.
+     * Default: `undefined` */
+    zoomEventFilter?: (event: PointerEvent) => boolean;
+    /** Disable node dragging. Default: `false` */
+    disableDrag?: boolean;
+    /** Disable brush for multiple node selection. Default: `false` */
+    disableBrush?: boolean;
+    /** Interval to re-render the graph when zooming. Default: `100` */
+    zoomThrottledUpdateNodeThreshold?: number;
+    /** Padding for the graph when fitting to container. Default: `50` */
+    fitViewPadding?: Spacing | number;
+    /** Default alignment when fitting the graph view. Default: `GraphFitViewAlignment.Center` */
+    fitViewAlign?: GraphFitViewAlignment;
+    /** Type of the graph layout. Default: `GraphLayoutType.Force` */
+    layoutType?: GraphLayoutType | string;
+    /** Fit the graph to container on data or config updates, or on container resize. Default: `true` */
+    layoutAutofit?: boolean;
+    /** Tolerance constant defining whether the graph should be fitted to container
+     * (on data or config update, or container resize) after a zoom / pan interaction or not.
+     * `0` — Stop fitting after any pan or zoom
+     * `Number.POSITIVE_INFINITY` — Always fit
+     * Default: `8.0` */
+    layoutAutofitTolerance?: number;
+    /** Place non-connected nodes at the bottom of the graph. Default: `false` */
+    layoutNonConnectedAside?: boolean;
+    /** Node group accessor function.
+     * Only for `GraphLayoutType.Parallel`, `GraphLayoutType.ParallelHorizontal` and `GraphLayoutType.Concentric` layouts.
+     * Default: `node => node.group` */
+    layoutNodeGroup?: StringAccessor<N>;
+    /** Order of the layout groups.
+     * Only for `GraphLayoutType.Parallel`, `GraphLayoutType.ParallelHorizontal` and `GraphLayoutType.Concentric` layouts.
+     * Default: `[]` */
+    layoutGroupOrder?: string[];
+    /** Sets the number of nodes in a sub-group after which they'll continue on the next column (or row if `layoutType` is
+     * `GraphLayoutType.ParallelHorizontal`).
+     * Only for `GraphLayoutType.Parallel` and `GraphLayoutType.ParallelHorizontal` layouts.
+     * Default: `6` */
+    layoutParallelNodesPerColumn?: number;
+    /** Node sub-group accessor function.
+     * Only for `GraphLayoutType.Parallel` and `GraphLayoutType.ParallelHorizontal` layouts.
+     * Default: `node => node.subgroup` */
+    layoutParallelNodeSubGroup?: StringAccessor<N>;
+    /** Number of sub-groups per row (or column if `layoutType` is `GraphLayoutType.ParallelHorizontal`) in a group.
+     * Only for `GraphLayoutType.Parallel` and `GraphLayoutType.ParallelHorizontal` layouts.
+     * Default: `1` */
+    layoutParallelSubGroupsPerRow?: number;
+    /** Spacing between nodes, dynamic by default.
+     * Only for `GraphLayoutType.Parallel` and `GraphLayoutType.ParallelHorizontal` layouts.
+     * Default: `undefined` */
+    layoutParallelNodeSpacing?: number | [number, number];
+    /** Spacing between sub-groups.
+     * Only for `GraphLayoutType.Parallel` and `GraphLayoutType.ParallelHorizontal` layouts.
+     * Default: `40` */
+    layoutParallelSubGroupSpacing?: number;
+    /** Spacing between groups.
+     * Only for `GraphLayoutType.Parallel` and `GraphLayoutType.ParallelHorizontal` layouts.
+     * Default: `undefined` */
+    layoutParallelGroupSpacing?: number;
+    /** Set a group by name to have priority in sorting the graph links.
+     * Only for `GraphLayoutType.Parallel` and `GraphLayoutType.ParallelHorizontal` layouts.
+     * Default: `undefined` */
+    layoutParallelSortConnectionsByGroup?: string;
+    /** Force Layout settings, see the `d3-force` package for more details */
+    forceLayoutSettings?: GraphForceLayoutSettings<N, L>;
+    /** Darge Layout settings, see the `dagrejs` package
+     * for more details: https://github.com/dagrejs/dagre/wiki#configuring-the-layout */
+    dagreLayoutSettings?: GraphDagreLayoutSetting;
+    /** ELK layout options, see the `elkjs` package for more details: https://github.com/kieler/elkjs.
+     * If you want to specify custom layout option for each node group, you can provide an accessor function that
+     * receives group name ('root' for the top-level configuration) as the first argument and returns an object containing
+     * layout options. Default: `undefined` */
+    layoutElkSettings?: GenericAccessor<GraphElkLayoutSettings, string> | undefined;
+    /** Array of accessor functions to define nested node groups for the ELK Layered layout.
+     * E.g.: `[n => n.group, n => n.subGroup]`.
+     * Default: `undefined` */
+    layoutElkNodeGroups?: StringAccessor<N>[];
+    /** A function to be called per graph node to get the ELK shape object.
+     * This enables you to provide custom node dimensions (through the `width` and `height` properties)
+     * and coordinates (through the `x` and `y` properties) if needed.
+     * Default: `undefined` */
+    layoutElkGetNodeShape?: (d: GraphNode<N, L>, i: number) => ElkShape;
+    /** Link width accessor function ot constant value. Default: `1` */
+    linkWidth?: NumericAccessor<L>;
+    /** Link style accessor function or constant value. Default: `GraphLinkStyle.Solid` */
+    linkStyle?: GenericAccessor<GraphLinkStyle, L>;
+    /** Link band width accessor function or constant value. Default: `0` */
+    linkBandWidth?: NumericAccessor<L>;
+    /** Link arrow accessor function or constant value. Default: `undefined` */
+    linkArrow?: GenericAccessor<GraphLinkArrowStyle | string | boolean, L> | undefined;
+    /** Link stroke color accessor function or constant value. Default: `undefined` */
+    linkStroke?: ColorAccessor<L>;
+    /** Link disabled state accessor function or constant value. Default: `false` */
+    linkDisabled?: BooleanAccessor<L>;
+    /** Link flow animation accessor function or constant value. Default: `false` */
+    linkFlow?: BooleanAccessor<L>;
+    /** Animation duration of the flow (traffic) circles in milliseconds. If `linkFlowParticleSpeed` is provided,
+     * this duration will be calculated based on the link length and particle speed. Default: `20000` */
+    linkFlowAnimDuration?: NumericAccessor<L>;
+    /** Size of the moving particles that represent traffic flow. Default: `2` */
+    linkFlowParticleSize?: NumericAccessor<L>;
+    /** Speed of the moving particles in pixels per second. This property takes precedence over `linkFlowAnimDuration`. Default: `undefined` */
+    linkFlowParticleSpeed?: NumericAccessor<L>;
+    /** Link label accessor function or constant value. Default: `undefined` */
+    linkLabel?: GenericAccessor<GraphCircleLabel | GraphCircleLabel[], L> | undefined;
+    /** Shift label along the link center a little bit to avoid overlap with the link arrow. Default: `true` */
+    linkLabelShiftFromCenter?: BooleanAccessor<L>;
+    /** Spacing between neighboring links. Default: `8` */
+    linkNeighborSpacing?: number;
+    /** Curvature of the link. Recommended value range: [0:1.5].
+     * `0` - straight line,
+     * `1` - nice curvature,
+     * `1.5` - very curve.
+     * Default: `0` */
+    linkCurvature?: NumericAccessor<L>;
+    /** Highlight links on hover. Default: `true` */
+    linkHighlightOnHover?: boolean;
+    /** Offset [x,y] in pixels from the source node's center point where the link should start. Default: `undefined` */
+    linkSourcePointOffset?: GenericAccessor<[number, number], GraphLink<N, L>>;
+    /** Offset [x,y] in pixels from the target node's center point where the link should end. Default: `undefined` */
+    linkTargetPointOffset?: GenericAccessor<[number, number], GraphLink<N, L>>;
+    /** Set selected link by its unique id. Default: `undefined` */
+    selectedLinkId?: number | string;
+    /** Node size accessor function or constant value. Default: `30` */
+    nodeSize?: NumericAccessor<N>;
+    /** Node stroke width accessor function or constant value. Default: `3` */
+    nodeStrokeWidth?: NumericAccessor<N>;
+    /** Node shape accessor function or constant value. Default: `GraphNodeShape.Circle` */
+    nodeShape?: GenericAccessor<GraphNodeShape | string, N>;
+    /** Node gauge outline accessor function or constant value in the range [0,100]. Default: `0` */
+    nodeGaugeValue?: NumericAccessor<N>;
+    /** Node gauge outline fill color accessor function or constant value. Default: `undefined` */
+    nodeGaugeFill?: ColorAccessor<N>;
+    /** Animation duration of the node gauge outline. Default: `1500` */
+    nodeGaugeAnimDuration?: number;
+    /** Node central icon accessor function or constant value. Default: `node => node.icon` */
+    nodeIcon?: StringAccessor<N>;
+    /** Node central icon size accessor function or constant value. Default: `undefined` */
+    nodeIconSize?: NumericAccessor<N>;
+    /** Node label accessor function or constant value. Default: `node => node.label` */
+    nodeLabel?: StringAccessor<N>;
+    /** Defines whether to trim the node labels or not. Default: `true` */
+    nodeLabelTrim?: BooleanAccessor<N>;
+    /** Node label trimming mode. Default: `TrimMode.Middle` */
+    nodeLabelTrimMode?: GenericAccessor<TrimMode | string, N>;
+    /** Node label maximum allowed text length above which the label will be trimmed. Default: `15` */
+    nodeLabelTrimLength?: NumericAccessor<N>;
+    /** Node label fit mode: `FitMode.Trim` or `FitMode.Wrap`. The trim settings apply only in `FitMode.Trim` mode. Default: `FitMode.Trim` */
+    nodeLabelFitMode?: GenericAccessor<FitMode | string, N>;
+    /** Maximum node label width in pixels for wrapping when the fit mode is `FitMode.Wrap`. When not provided, a width derived from the node size will be used. Default: `undefined` */
+    nodeLabelWidth?: NumericAccessor<N>;
+    /** Node label text wrapping separator. String or array of strings. Default: `undefined` */
+    nodeLabelSeparator?: string | string[];
+    /** Force word break for node labels when they don't fit. Default: `false` */
+    nodeLabelForceWordBreak?: boolean;
+    /** Node sub-label accessor function or constant value: Default: `''` */
+    nodeSubLabel?: StringAccessor<N>;
+    /** Defines whether to trim the node sub-labels or not. Default: `true` */
+    nodeSubLabelTrim?: BooleanAccessor<N>;
+    /** Node sub-label trimming mode. Default: `TrimMode.Middle` */
+    nodeSubLabelTrimMode?: GenericAccessor<TrimMode | string, N>;
+    /** Node sub-label maximum allowed text length above which the label will be trimmed. Default: `15` */
+    nodeSubLabelTrimLength?: NumericAccessor<N>;
+    /** Node sub-label fit mode: `FitMode.Trim` or `FitMode.Wrap`. The trim settings apply only in `FitMode.Trim` mode. Default: `FitMode.Trim` */
+    nodeSubLabelFitMode?: GenericAccessor<FitMode | string, N>;
+    /** Maximum node sub-label width in pixels for wrapping when the fit mode is `FitMode.Wrap`. When not provided, a width derived from the node size will be used. Default: `undefined` */
+    nodeSubLabelWidth?: NumericAccessor<N>;
+    /** Node sub-label text wrapping separator. String or array of strings. Default: `undefined` */
+    nodeSubLabelSeparator?: string | string[];
+    /** Force word break for node sub-labels when they don't fit. Default: `false` */
+    nodeSubLabelForceWordBreak?: boolean;
+    /** Node circular side labels accessor function. The function should return an array of GraphCircleLabel objects. Default: `undefined` */
+    nodeSideLabels?: GenericAccessor<GraphCircleLabel[], N>;
+    /** Node bottom icon accessor function. Default: `undefined` */
+    nodeBottomIcon?: StringAccessor<N>;
+    /** Node disabled state accessor function or constant value. Default: `false` */
+    nodeDisabled?: BooleanAccessor<N>;
+    /** Node fill color accessor function or constant value. Default: `node => node.fill` */
+    nodeFill?: ColorAccessor<N>;
+    /** Node stroke color accessor function or constant value. Default: `node => node.stroke` */
+    nodeStroke?: ColorAccessor<N>;
+    /** Sorting function to determine node placement. Default: `undefined` */
+    nodeSort?: ((a: N, b: N) => number);
+    /** Specify the initial position for entering nodes as [x, y]. Default: `undefined` */
+    nodeEnterPosition?: GenericAccessor<[number, number], N> | undefined;
+    /** Specify the initial scale for entering nodes in the range [0,1]. Default: `0.75` */
+    nodeEnterScale?: NumericAccessor<N> | undefined;
+    /** Specify the destination position for exiting nodes as [x, y]. Default: `undefined` */
+    nodeExitPosition?: GenericAccessor<[number, number], N> | undefined;
+    /** Specify the destination scale for exiting nodes in the range [0,1]. Default: `0.75` */
+    nodeExitScale?: NumericAccessor<N> | undefined;
+    /** Custom "enter" function for node rendering. Default: `undefined` */
+    nodeEnterCustomRenderFunction?: (datum: GraphNode<N, L>, nodeGroupElementSelection: Selection<SVGGElement, GraphNode<N, L>, null, unknown>, config: GraphConfigInterface<N, L>, duration: number, zoomLevel: number) => void;
+    /** Custom "update" function for node rendering. Default: `undefined` */
+    nodeUpdateCustomRenderFunction?: (datum: GraphNode<N, L>, nodeGroupElementSelection: Selection<SVGGElement, GraphNode<N, L>, null, unknown>, config: GraphConfigInterface<N, L>, duration: number, zoomLevel: number) => void;
+    /** Custom partial "update" function for node rendering which will be triggered after the following events:
+     * - Full node update (`nodeUpdateCustomRenderFunction`);
+     * - Background click;
+     * - Node and Link mouseover and mouseout;
+     * - Node brushing,
+     * Default: `undefined` */
+    nodePartialUpdateCustomRenderFunction?: (datum: GraphNode<N, L>, nodeGroupElementSelection: Selection<SVGGElement, GraphNode<N, L>, null, unknown>, config: GraphConfigInterface<N, L>, duration: number, zoomLevel: number) => void;
+    /** Custom "exit" function for node rendering. Default: `undefined` */
+    nodeExitCustomRenderFunction?: (datum: GraphNode<N, L>, nodeGroupElementSelection: Selection<SVGGElement, GraphNode<N, L>, null, unknown>, config: GraphConfigInterface<N, L>, duration: number, zoomLevel: number) => void;
+    /** Custom render function that will be called while zooming / panning the graph. Default: `undefined` */
+    nodeOnZoomCustomRenderFunction?: (datum: GraphNode<N, L>, nodeGroupElementSelection: Selection<SVGGElement, GraphNode<N, L>, null, unknown>, config: GraphConfigInterface<N, L>, zoomLevel: number) => void;
+    /** Define the mode for highlighting selected nodes in the graph. Default: `GraphNodeSelectionHighlightMode.GreyoutNonConnected` */
+    nodeSelectionHighlightMode?: GraphNodeSelectionHighlightMode;
+    /** Set selected node by unique id. Default: `undefined` */
+    selectedNodeId?: number | string;
+    /** Set selected nodes by unique id. Default: `undefined` */
+    selectedNodeIds?: number[] | string[];
+    /** Panels configuration. An array of `GraphPanelConfig` objects. Default: `[]` */
+    panels?: GraphPanelConfig[] | undefined;
+    /** Graph node drag start callback function. Default: `undefined` */
+    onNodeDragStart?: (n: GraphNode<N, L>, event: D3DragEvent<SVGGElement, GraphNode<N, L>, unknown>) => void | undefined;
+    /** Graph node drag callback function. Default: `undefined` */
+    onNodeDrag?: (n: GraphNode<N, L>, event: D3DragEvent<SVGGElement, GraphNode<N, L>, unknown>) => void | undefined;
+    /** Graph node drag end callback function. Default: `undefined` */
+    onNodeDragEnd?: (n: GraphNode<N, L>, event: D3DragEvent<SVGGElement, GraphNode<N, L>, unknown>) => void | undefined;
+    /** Zoom event callback. Default: `undefined` */
+    onZoom?: (zoomScale: number, zoomScaleExtent: [number, number], event: D3ZoomEvent<SVGGElement, unknown> | undefined, transform: ZoomTransform) => void;
+    /** Zoom start event callback. Default: `undefined` */
+    onZoomStart?: (zoomScale: number, zoomScaleExtent: [number, number], event: D3ZoomEvent<SVGGElement, unknown> | undefined, transform: ZoomTransform) => void;
+    /** Zoom end event callback. Default: `undefined` */
+    onZoomEnd?: (zoomScale: number, zoomScaleExtent: [number, number], event: D3ZoomEvent<SVGGElement, unknown> | undefined, transform: ZoomTransform) => void;
+    /** Callback function to be called when the graph layout is calculated. Default: `undefined` */
+    onLayoutCalculated?: (nodes: GraphNode<N, L>[], links: GraphLink<N, L>[]) => void;
+    /** Graph node selection brush callback function. Default: `undefined` */
+    onNodeSelectionBrush?: (selectedNodes: GraphNode<N, L>[], event: D3BrushEvent<SVGGElement> | undefined) => void;
+    /** Graph multiple node drag callback function. Default: `undefined` */
+    onNodeSelectionDrag?: (selectedNodes: GraphNode<N, L>[], event: D3DragEvent<SVGGElement, GraphNode<N, L>, unknown>) => void;
+    /** Callback function to be called when the graph rendering is complete. Default: `undefined` */
+    onRenderComplete?: (g: Selection<SVGGElement, unknown, null, undefined>, nodes: GraphNode<N, L>[], links: GraphLink<N, L>[], config: GraphConfigInterface<N, L>, duration: number, zoomLevel: number, width: number, height: number) => void;
+    /** Determines whether the component should update when new data is provided.
+     * This function takes the previous and new data as parameters and returns a boolean
+     * indicating whether the update should proceed. Useful for fine-grained control over
+     * update behavior when your data has a complex nested structure.
+     * By default the `isEqual` function from Unovis will be used to do the comparison. */
+    shouldDataUpdate?: (prevData: GraphInputData<N, L>, nextData: GraphInputData<N, L>, datamodel: GraphDataModel<N, L, GraphNode<N, L>, GraphLink<N, L>>) => boolean;
+    data: {
+        nodes: N[];
+        links?: L[];
+    };
+    component: Graph<N, L> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisGraphComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisGraphComponent<any, any>, "vis-graph", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "zoomScaleExtent": { "alias": "zoomScaleExtent"; "required": false; }; "disableZoom": { "alias": "disableZoom"; "required": false; }; "zoomEventFilter": { "alias": "zoomEventFilter"; "required": false; }; "disableDrag": { "alias": "disableDrag"; "required": false; }; "disableBrush": { "alias": "disableBrush"; "required": false; }; "zoomThrottledUpdateNodeThreshold": { "alias": "zoomThrottledUpdateNodeThreshold"; "required": false; }; "fitViewPadding": { "alias": "fitViewPadding"; "required": false; }; "fitViewAlign": { "alias": "fitViewAlign"; "required": false; }; "layoutType": { "alias": "layoutType"; "required": false; }; "layoutAutofit": { "alias": "layoutAutofit"; "required": false; }; "layoutAutofitTolerance": { "alias": "layoutAutofitTolerance"; "required": false; }; "layoutNonConnectedAside": { "alias": "layoutNonConnectedAside"; "required": false; }; "layoutNodeGroup": { "alias": "layoutNodeGroup"; "required": false; }; "layoutGroupOrder": { "alias": "layoutGroupOrder"; "required": false; }; "layoutParallelNodesPerColumn": { "alias": "layoutParallelNodesPerColumn"; "required": false; }; "layoutParallelNodeSubGroup": { "alias": "layoutParallelNodeSubGroup"; "required": false; }; "layoutParallelSubGroupsPerRow": { "alias": "layoutParallelSubGroupsPerRow"; "required": false; }; "layoutParallelNodeSpacing": { "alias": "layoutParallelNodeSpacing"; "required": false; }; "layoutParallelSubGroupSpacing": { "alias": "layoutParallelSubGroupSpacing"; "required": false; }; "layoutParallelGroupSpacing": { "alias": "layoutParallelGroupSpacing"; "required": false; }; "layoutParallelSortConnectionsByGroup": { "alias": "layoutParallelSortConnectionsByGroup"; "required": false; }; "forceLayoutSettings": { "alias": "forceLayoutSettings"; "required": false; }; "dagreLayoutSettings": { "alias": "dagreLayoutSettings"; "required": false; }; "layoutElkSettings": { "alias": "layoutElkSettings"; "required": false; }; "layoutElkNodeGroups": { "alias": "layoutElkNodeGroups"; "required": false; }; "layoutElkGetNodeShape": { "alias": "layoutElkGetNodeShape"; "required": false; }; "linkWidth": { "alias": "linkWidth"; "required": false; }; "linkStyle": { "alias": "linkStyle"; "required": false; }; "linkBandWidth": { "alias": "linkBandWidth"; "required": false; }; "linkArrow": { "alias": "linkArrow"; "required": false; }; "linkStroke": { "alias": "linkStroke"; "required": false; }; "linkDisabled": { "alias": "linkDisabled"; "required": false; }; "linkFlow": { "alias": "linkFlow"; "required": false; }; "linkFlowAnimDuration": { "alias": "linkFlowAnimDuration"; "required": false; }; "linkFlowParticleSize": { "alias": "linkFlowParticleSize"; "required": false; }; "linkFlowParticleSpeed": { "alias": "linkFlowParticleSpeed"; "required": false; }; "linkLabel": { "alias": "linkLabel"; "required": false; }; "linkLabelShiftFromCenter": { "alias": "linkLabelShiftFromCenter"; "required": false; }; "linkNeighborSpacing": { "alias": "linkNeighborSpacing"; "required": false; }; "linkCurvature": { "alias": "linkCurvature"; "required": false; }; "linkHighlightOnHover": { "alias": "linkHighlightOnHover"; "required": false; }; "linkSourcePointOffset": { "alias": "linkSourcePointOffset"; "required": false; }; "linkTargetPointOffset": { "alias": "linkTargetPointOffset"; "required": false; }; "selectedLinkId": { "alias": "selectedLinkId"; "required": false; }; "nodeSize": { "alias": "nodeSize"; "required": false; }; "nodeStrokeWidth": { "alias": "nodeStrokeWidth"; "required": false; }; "nodeShape": { "alias": "nodeShape"; "required": false; }; "nodeGaugeValue": { "alias": "nodeGaugeValue"; "required": false; }; "nodeGaugeFill": { "alias": "nodeGaugeFill"; "required": false; }; "nodeGaugeAnimDuration": { "alias": "nodeGaugeAnimDuration"; "required": false; }; "nodeIcon": { "alias": "nodeIcon"; "required": false; }; "nodeIconSize": { "alias": "nodeIconSize"; "required": false; }; "nodeLabel": { "alias": "nodeLabel"; "required": false; }; "nodeLabelTrim": { "alias": "nodeLabelTrim"; "required": false; }; "nodeLabelTrimMode": { "alias": "nodeLabelTrimMode"; "required": false; }; "nodeLabelTrimLength": { "alias": "nodeLabelTrimLength"; "required": false; }; "nodeLabelFitMode": { "alias": "nodeLabelFitMode"; "required": false; }; "nodeLabelWidth": { "alias": "nodeLabelWidth"; "required": false; }; "nodeLabelSeparator": { "alias": "nodeLabelSeparator"; "required": false; }; "nodeLabelForceWordBreak": { "alias": "nodeLabelForceWordBreak"; "required": false; }; "nodeSubLabel": { "alias": "nodeSubLabel"; "required": false; }; "nodeSubLabelTrim": { "alias": "nodeSubLabelTrim"; "required": false; }; "nodeSubLabelTrimMode": { "alias": "nodeSubLabelTrimMode"; "required": false; }; "nodeSubLabelTrimLength": { "alias": "nodeSubLabelTrimLength"; "required": false; }; "nodeSubLabelFitMode": { "alias": "nodeSubLabelFitMode"; "required": false; }; "nodeSubLabelWidth": { "alias": "nodeSubLabelWidth"; "required": false; }; "nodeSubLabelSeparator": { "alias": "nodeSubLabelSeparator"; "required": false; }; "nodeSubLabelForceWordBreak": { "alias": "nodeSubLabelForceWordBreak"; "required": false; }; "nodeSideLabels": { "alias": "nodeSideLabels"; "required": false; }; "nodeBottomIcon": { "alias": "nodeBottomIcon"; "required": false; }; "nodeDisabled": { "alias": "nodeDisabled"; "required": false; }; "nodeFill": { "alias": "nodeFill"; "required": false; }; "nodeStroke": { "alias": "nodeStroke"; "required": false; }; "nodeSort": { "alias": "nodeSort"; "required": false; }; "nodeEnterPosition": { "alias": "nodeEnterPosition"; "required": false; }; "nodeEnterScale": { "alias": "nodeEnterScale"; "required": false; }; "nodeExitPosition": { "alias": "nodeExitPosition"; "required": false; }; "nodeExitScale": { "alias": "nodeExitScale"; "required": false; }; "nodeEnterCustomRenderFunction": { "alias": "nodeEnterCustomRenderFunction"; "required": false; }; "nodeUpdateCustomRenderFunction": { "alias": "nodeUpdateCustomRenderFunction"; "required": false; }; "nodePartialUpdateCustomRenderFunction": { "alias": "nodePartialUpdateCustomRenderFunction"; "required": false; }; "nodeExitCustomRenderFunction": { "alias": "nodeExitCustomRenderFunction"; "required": false; }; "nodeOnZoomCustomRenderFunction": { "alias": "nodeOnZoomCustomRenderFunction"; "required": false; }; "nodeSelectionHighlightMode": { "alias": "nodeSelectionHighlightMode"; "required": false; }; "selectedNodeId": { "alias": "selectedNodeId"; "required": false; }; "selectedNodeIds": { "alias": "selectedNodeIds"; "required": false; }; "panels": { "alias": "panels"; "required": false; }; "onNodeDragStart": { "alias": "onNodeDragStart"; "required": false; }; "onNodeDrag": { "alias": "onNodeDrag"; "required": false; }; "onNodeDragEnd": { "alias": "onNodeDragEnd"; "required": false; }; "onZoom": { "alias": "onZoom"; "required": false; }; "onZoomStart": { "alias": "onZoomStart"; "required": false; }; "onZoomEnd": { "alias": "onZoomEnd"; "required": false; }; "onLayoutCalculated": { "alias": "onLayoutCalculated"; "required": false; }; "onNodeSelectionBrush": { "alias": "onNodeSelectionBrush"; "required": false; }; "onNodeSelectionDrag": { "alias": "onNodeSelectionDrag"; "required": false; }; "onRenderComplete": { "alias": "onRenderComplete"; "required": false; }; "shouldDataUpdate": { "alias": "shouldDataUpdate"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisGraphModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisGraphModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisGraphModule, [typeof VisGraphComponent], never, [typeof VisGraphComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisGraphModule>;
+}
+
+declare class VisGroupedBarComponent<Datum> implements GroupedBarConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Bar color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Bar fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    pattern?: GenericAccessor<FillPatternType, Datum>;
+    /** Force set the group width in pixels. Default: `undefined` */
+    groupWidth?: number;
+    /** Maximum group width for dynamic sizing. Limits the groupWidth property from the top. Default: `undefined` */
+    groupMaxWidth?: number;
+    /** Expected step between the bar groups in the X axis units.
+     * Needed to correctly calculate the width of the bar groups when there are gaps in the data.
+     * Default: `undefined` */
+    dataStep?: number;
+    /** Fractional padding between the groups in the range of [0,1). Default: `0.05` */
+    groupPadding?: number;
+    /** Fractional padding between the bars in the range of [0,1). Default: `0` */
+    barPadding?: number;
+    /** Rounded bar corners. Boolean or number (to set the radius in pixels explicitly). Default: `2` */
+    roundedCorners?: number | boolean;
+    /** Sets the minimum bar height for better visibility of small values. Default: `1` */
+    barMinHeight?: number;
+    /** Configurable bar cursor when hovering over. Default: `null` */
+    cursor?: StringAccessor<Datum>;
+    /** Chart orientation: `Orientation.Vertical` or `Orientation.Horizontal`. Default `Orientation.Vertical` */
+    orientation?: Orientation | string;
+    data: Datum[];
+    component: GroupedBar<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisGroupedBarComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisGroupedBarComponent<any>, "vis-grouped-bar", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "groupWidth": { "alias": "groupWidth"; "required": false; }; "groupMaxWidth": { "alias": "groupMaxWidth"; "required": false; }; "dataStep": { "alias": "dataStep"; "required": false; }; "groupPadding": { "alias": "groupPadding"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundedCorners": { "alias": "roundedCorners"; "required": false; }; "barMinHeight": { "alias": "barMinHeight"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisGroupedBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisGroupedBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisGroupedBarModule, [typeof VisGroupedBarComponent], never, [typeof VisGroupedBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisGroupedBarModule>;
+}
+
+declare class VisHeatmapComponent<Datum> implements HeatmapConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Value accessor function. Drives the cell color. Returning `null` or `undefined` renders an empty cell. Default: `undefined` */
+    value: NumericAccessor<Datum>;
+    /** Per-cell color accessor function. Takes precedence over `colorRange` when it resolves to a color. Default: `undefined` */
+    color?: ColorAccessor<Datum>;
+    /** A list of bucket colors used to build a quantized value → color scale when `color` is not set.
+     * When `undefined`, a default green sequence is used (configurable via the `--vis-heatmap-color-*` CSS variables). Default: `undefined` */
+    colorRange?: string[];
+    /** Explicit `[min, max]` domain for the `colorRange` scale. When `undefined`, the extent of the values is used. Default: `undefined` */
+    colorDomain?: [number, number];
+    /** Number of rows in the grid. When `layout` is `HeatmapLayoutType.Column` this is the primary (fixed) dimension. Default: `7` */
+    numRows?: number;
+    /** Number of columns in the grid. When `layout` is `HeatmapLayoutType.Row` this is the primary (fixed) dimension.
+     * When `undefined`, it's derived from the data length and the primary dimension. Default: `undefined` */
+    numColumns?: number;
+    /** Order in which the linear `data` array fills the grid:
+     * `HeatmapLayoutType.Column` fills each column top-to-bottom before moving to the next (GitHub-contributions style),
+     * `HeatmapLayoutType.Row` fills each row left-to-right. Default: `HeatmapLayoutType.Column` */
+    layout?: HeatmapLayoutType | `${HeatmapLayoutType}`;
+    /** Number of empty cells before the first datum. Useful for aligning the first datum to a specific row/column.
+     * Equivalent to prepending `offset` empty entries to `data`. Default: `0` */
+    offset?: number;
+    /** Fixed cell size in pixels. A single number renders square cells; `[width, height]` renders rectangular cells.
+     * When unset, cells stretch to fill the container.
+     * When set together with the container's `Sizing.Extend`, the component reports its own size. Default: `undefined` */
+    cellSize?: number | [number, number];
+    /** Gap between cells in pixels. Default: `2` */
+    cellPadding?: number;
+    /** Cell corner radius in pixels (or `true` for a default radius of `2`). Default: `2` */
+    cellCornerRadius?: number | boolean;
+    /** Cell cursor accessor function. Default: `null` */
+    cursor?: StringAccessor<Datum>;
+    /** Column label accessor, called per column index. Return `undefined` to skip a label. Labels are rendered above the grid. Default: `undefined` */
+    columnLabel?: (columnIndex: number) => string | null | undefined;
+    /** Row label accessor, called per row index. Return `undefined` to skip a label. Labels are rendered to the left of the grid. Default: `undefined` */
+    rowLabel?: (rowIndex: number) => string | null | undefined;
+    /** Hide row and column labels that overlap their neighbours. Collisions are resolved independently per axis,
+     * keeping the top-most row label and left-most column label of each overlapping group visible. Default: `true` */
+    labelHideOverlapping?: boolean;
+    data: Datum[];
+    component: Heatmap<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisHeatmapComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisHeatmapComponent<any>, "vis-heatmap", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "value": { "alias": "value"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorRange": { "alias": "colorRange"; "required": false; }; "colorDomain": { "alias": "colorDomain"; "required": false; }; "numRows": { "alias": "numRows"; "required": false; }; "numColumns": { "alias": "numColumns"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "cellSize": { "alias": "cellSize"; "required": false; }; "cellPadding": { "alias": "cellPadding"; "required": false; }; "cellCornerRadius": { "alias": "cellCornerRadius"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "columnLabel": { "alias": "columnLabel"; "required": false; }; "rowLabel": { "alias": "rowLabel"; "required": false; }; "labelHideOverlapping": { "alias": "labelHideOverlapping"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisHeatmapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisHeatmapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisHeatmapModule, [typeof VisHeatmapComponent], never, [typeof VisHeatmapComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisHeatmapModule>;
+}
+
+declare class VisLineComponent<Datum> implements LineConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Line color accessor function. The whole data array will be passed as the first argument. Default: `undefined` */
+    color?: ColorAccessor<Datum[]>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Line pattern accessor. Resolves to a `LinePatternType`. The whole data array is passed as the first argument. Default: `undefined` */
+    pattern?: GenericAccessor<LinePatternType, Datum[]>;
+    /** Curve type from the CurveType enum. Default: `CurveType.MonotoneX` */
+    curveType?: CurveType;
+    /** Line width in pixels. Default: `2` */
+    lineWidth?: number;
+    /** Line dash array, see SVG's stroke-dasharray. Default: `undefined` */
+    lineDashArray?: GenericAccessor<number[], Datum[]>;
+    /** When a data point has an `undefined`, `NaN`, or other no-data value, they'll be replaced with a value specified here.
+     * Setting this property to `undefined` will lead to having the line break when there's no data, and continue when
+     * the data appears again. If you set it to `null`, the values will be treated as numerical `0` values and the line
+     * won't break; however if the whole dataset consists of only `null`s, the line won't be displayed.
+     * Default: `undefined` */
+    fallbackValue?: number | undefined | null;
+    /** Highlight line on hover. Default: `false` */
+    highlightOnHover?: boolean;
+    /** Optional link cursor. Default: `null` */
+    cursor?: StringAccessor<Datum[]>;
+    /** Enable interpolated line where data points are missing or fallbackValue is used.
+     * You can customize the line's appearance with `--vis-line-gapfill-stroke-dasharray`
+     * and `--vis-line-gapfill-stroke-opacity` CSS variables.
+     * Default: `false` */
+    interpolateMissingData?: boolean;
+    data: Datum[];
+    component: Line<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisLineComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisLineComponent<any>, "vis-line", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "curveType": { "alias": "curveType"; "required": false; }; "lineWidth": { "alias": "lineWidth"; "required": false; }; "lineDashArray": { "alias": "lineDashArray"; "required": false; }; "fallbackValue": { "alias": "fallbackValue"; "required": false; }; "highlightOnHover": { "alias": "highlightOnHover"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "interpolateMissingData": { "alias": "interpolateMissingData"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisLineModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisLineModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisLineModule, [typeof VisLineComponent], never, [typeof VisLineComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisLineModule>;
+}
+
+declare class VisNestedDonutComponent<Datum> implements NestedDonutConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Diagram angle range. Default: `[0, 2 * Math.PI]` */
+    angleRange?: [number, number];
+    /** Direction of hierarchy flow from root to leaf.
+     * `NestedDonutDirection.Inwards` starts from the outer most radius and works towards center
+     * `NestedDonutDirection.Outwards` starts from the inner most radius the consecutive layers outward.
+     *  Default: `NestedDonutDirection.Inwards` */
+    direction?: NestedDonutDirection | string;
+    value?: NumericAccessor<Datum>;
+    /** Central label text. Default: `undefined` */
+    centralLabel?: string;
+    /** Central sub-label accessor function or text. Default: `undefined` */
+    centralSubLabel?: string;
+    /** Enables wrapping for the sub-label. Default: `true` */
+    centralSubLabelWrap?: boolean;
+    /** Show donut background. The color is configurable via
+     * the `--vis-nested-donut-background-color` and `--vis-dark-nested-donut-background-color` CSS variables.
+     * Default: `false` */
+    showBackground?: boolean;
+    /** Sort function for segments. Default `undefined` */
+    sort?: (a: NestedDonutSegment<Datum>, b: NestedDonutSegment<Datum>) => number;
+    /** Array of accessor functions to defined the nested groups. Default: `[]` */
+    layers: StringAccessor<Datum>[];
+    /** Configuration properties for individual layers. Accepts an accessor or constant of type:
+     * {
+     *   backgroundColor?: string;
+     *   labelAlignment?: NestedDonutSegmentLabelAlignment;
+     *   width?: number | string;
+     * } */
+    layerSettings?: GenericAccessor<NestedDonutLayerSettings, number>;
+    layerPadding?: number;
+    /** Corner Radius. Default: `0` */
+    cornerRadius?: number;
+    /** Angular size for empty segments in radians. Default: `Math.PI / 180` */
+    emptySegmentAngle?: number;
+    /** Hide segment labels when they don't fit. Default: `true` */
+    hideOverflowingSegmentLabels?: boolean;
+    /** Color accessor function for segments. Default: `undefined` */
+    segmentColor?: ColorAccessor<NestedDonutSegment<Datum>>;
+    /** Fill pattern accessor for segments. Resolves to a `FillPatternType`. Default: `undefined` */
+    segmentPattern?: GenericAccessor<FillPatternType, NestedDonutSegment<Datum>>;
+    /** Segment label accessor function. Default `undefined` */
+    segmentLabel?: StringAccessor<NestedDonutSegment<Datum>>;
+    /** Color accessor function for segment labels */
+    segmentLabelColor?: ColorAccessor<NestedDonutSegment<Datum>>;
+    /** When true, the component will display empty segments (the ones that have `0` values) as tiny slices.
+     * Default: `false` */
+    showEmptySegments?: boolean;
+    /** Show labels for individual segments. Default: `true` */
+    showSegmentLabels?: boolean;
+    data: Datum[];
+    component: NestedDonut<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisNestedDonutComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisNestedDonutComponent<any>, "vis-nested-donut", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "angleRange": { "alias": "angleRange"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "value": { "alias": "value"; "required": false; }; "centralLabel": { "alias": "centralLabel"; "required": false; }; "centralSubLabel": { "alias": "centralSubLabel"; "required": false; }; "centralSubLabelWrap": { "alias": "centralSubLabelWrap"; "required": false; }; "showBackground": { "alias": "showBackground"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "layers": { "alias": "layers"; "required": false; }; "layerSettings": { "alias": "layerSettings"; "required": false; }; "layerPadding": { "alias": "layerPadding"; "required": false; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; }; "emptySegmentAngle": { "alias": "emptySegmentAngle"; "required": false; }; "hideOverflowingSegmentLabels": { "alias": "hideOverflowingSegmentLabels"; "required": false; }; "segmentColor": { "alias": "segmentColor"; "required": false; }; "segmentPattern": { "alias": "segmentPattern"; "required": false; }; "segmentLabel": { "alias": "segmentLabel"; "required": false; }; "segmentLabelColor": { "alias": "segmentLabelColor"; "required": false; }; "showEmptySegments": { "alias": "showEmptySegments"; "required": false; }; "showSegmentLabels": { "alias": "showSegmentLabels"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisNestedDonutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisNestedDonutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisNestedDonutModule, [typeof VisNestedDonutComponent], never, [typeof VisNestedDonutComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisNestedDonutModule>;
+}
+
+declare class VisPlotlineComponent<Datum> implements PlotlineConfigInterface<Datum>, AfterViewInit {
+    /** Duration of the animation in milliseconds. */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Line width in pixels.
+     * Uses CSS variable: `--vis-plotline-width`. */
+    lineWidth?: number;
+    /** Plotline direction type.
+     * Should be either `AxisType.X` or `AxisType.Y`. */
+    axis?: AxisType | string;
+    /** Value to draw the plotline at. */
+    value?: number | null | undefined;
+    /** Line style of the plotline.
+     * Can be a named preset or an array of numbers representing `stroke-dasharray`.
+     * Uses CSS variable: `--vis-plotline-dasharray`. */
+    lineStyle?: PlotlineLineStylePresets | number[];
+    /** Label text to display on the plotline. */
+    labelText?: string;
+    /** Position of the label relative to the plotline. */
+    labelPosition?: PlotlineLabelPosition;
+    /** Horizontal offset of the label in pixels. */
+    labelOffsetX?: number;
+    /** Vertical offset of the label in pixels. */
+    labelOffsetY?: number;
+    /** Orientation of the label: horizontal or vertical. */
+    labelOrientation?: PlotlineLabelOrientation;
+    /** Color of the label text.
+     * Uses CSS variable: `--vis-plotline-label-color`. */
+    labelColor?: string;
+    /** Font size of the label text in pixels.
+     * Uses CSS variable: `--vis-plotline-label-font-size`. */
+    labelSize?: number;
+    component: Plotline<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisPlotlineComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisPlotlineComponent<any>, "vis-plotline", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "lineWidth": { "alias": "lineWidth"; "required": false; }; "axis": { "alias": "axis"; "required": false; }; "value": { "alias": "value"; "required": false; }; "lineStyle": { "alias": "lineStyle"; "required": false; }; "labelText": { "alias": "labelText"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "labelOffsetX": { "alias": "labelOffsetX"; "required": false; }; "labelOffsetY": { "alias": "labelOffsetY"; "required": false; }; "labelOrientation": { "alias": "labelOrientation"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "labelSize": { "alias": "labelSize"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisPlotlineModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisPlotlineModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisPlotlineModule, [typeof VisPlotlineComponent], never, [typeof VisPlotlineComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisPlotlineModule>;
+}
+
+declare class VisSankeyComponent<N extends SankeyInputNode, L extends SankeyInputLink> implements SankeyConfigInterface<N, L>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Node / Link id accessor function. Used for mapping of data updates to corresponding SVG objects. Default: `(d, i) => d.id ?? i.toString()` */
+    id?: (d: SankeyInputNode | SankeyInputLink, i: number, ...rest: any[]) => string;
+    /** Coefficient to scale the height of the diagram when the amount of links is low: `C * links.length`, clamped to `[height / 2, height]`. Default: `1/16` */
+    heightNormalizationCoeff?: number;
+    /** Horizontal and vertical scale factor applied to the computed layout (column spacing). Keeps node width intact. Default: `undefined` */
+    zoomScale?: [number, number];
+    /** Pan offset in pixels. Default: `undefined` */
+    zoomPan?: [number, number];
+    /** Enable interactive zoom/pan behavior. Default: `true` */
+    enableZoom?: boolean;
+    /** Allowed interactive zoom scale extent. Default: `[1, 5]` */
+    zoomExtent?: [number, number];
+    /** Zoom interaction mode. Default: `SankeyZoomMode.XY` */
+    zoomMode?: SankeyZoomMode | string;
+    /** Disable modifier keys. Has effect only for `SankeyZoomMode.XY` zoom mode. When `true`, zoom mode is not altered by modifier keys. Default: `false` */
+    disableZoomModifierKeys?: boolean;
+    /** Type of animation on removing nodes. Default: `ExitTransitionType.Default` */
+    exitTransitionType?: SankeyExitTransitionType;
+    /** Type of animation on creating nodes. Default: `EnterTransitionType.Default` */
+    enterTransitionType?: SankeyEnterTransitionType;
+    /** Highlight the corresponding subtree on node / link hover. Default: `false` */
+    highlightSubtreeOnHover?: boolean;
+    /** Highlight animation duration, ms. Default: `400` */
+    highlightDuration?: number;
+    /** Highlight delay, ms. Default: `1000` */
+    highlightDelay?: number;
+    /** Sankey algorithm iterations. Default: `32` */
+    iterations?: number;
+    /** Sankey node sorting function. Default: `undefined`.
+     * Node sorting is applied to nodes in one layer (column). Layer by layer.
+     * Options: `undefined` - the order is determined by the layout;
+     *          `null` - the order is fixed by the input;
+     *          sort function - the order is determined by the function. */
+    nodeSort?: ((node1: SankeyNode<N, L>, node2: SankeyNode<N, L>) => number) | null | undefined;
+    /** Sankey link sorting function. Default: `(link2, link1) => link1.value - link2.value`.
+     * Link sorting is applied to the source (exiting) links within one node.
+     * Options: `undefined` - the order is determined by the layout;
+     *          `null` - the order is fixed by the input;
+     *          sort function - the order is determined by the function. */
+    linkSort?: ((link1: SankeyLink<N, L>, link2: SankeyLink<N, L>) => number) | null | undefined;
+    /** Sankey node width in pixels */
+    nodeWidth?: number;
+    /** Sankey node alignment method */
+    nodeAlign?: SankeyNodeAlign;
+    /** Horizontal space between the nodes. Extended Sizing property only. Default: `150` */
+    nodeHorizontalSpacing?: number;
+    /** Minimum node height. Extended Sizing property only. Default: `20` */
+    nodeMinHeight?: number;
+    /** Maximum node height. Extended Sizing property only. Default: `100` */
+    nodeMaxHeight?: number;
+    /** Sankey vertical separation between nodes in pixels. Default: `2` */
+    nodePadding?: number;
+    /** Compress `nodePadding` when it doesn't fit the available height, so that node bodies
+     * always keep at least a third of it instead of collapsing to zero height.
+     * Applied only when `Sizing.Fit` is selected. Default: `false` */
+    nodeAdaptivePadding?: boolean;
+    /** Display the graph when data has just one element */
+    showSingleNode?: boolean;
+    /** Node cursor on hover. Default: `undefined` */
+    nodeCursor?: StringAccessor<SankeyNode<N, L>>;
+    /** Node icon accessor function or value. Default: `undefined` */
+    nodeIcon?: StringAccessor<SankeyNode<N, L>>;
+    /** Node color accessor function or value. Default: `undefined` */
+    nodeColor?: ColorAccessor<SankeyNode<N, L>>;
+    /** Node fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    nodePattern?: GenericAccessor<FillPatternType, SankeyNode<N, L>>;
+    /** Node `fixedValue` accessor function or constant. It defines the node value that will be used to calculate
+     * the height of the nodes by d3-sankey (by default the height will be based on aggregated `linkValue`).
+     * Default: `n => n.fixedValue` */
+    nodeFixedValue?: NumericAccessor<N>;
+    /** Icon color accessor function or value. Default: `undefined` */
+    nodeIconColor?: ColorAccessor<SankeyNode<N, L>>;
+    /** Link color accessor function or value. Default: `l => l.color` */
+    linkColor?: StringAccessor<SankeyLink<N, L>>;
+    /** Link fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    linkPattern?: GenericAccessor<FillPatternType, SankeyLink<N, L>>;
+    /** Link flow accessor function or value. Default: `l => l.value` */
+    linkValue?: NumericAccessor<L>;
+    /** Link cursor on hover. Default: `undefined` */
+    linkCursor?: StringAccessor<SankeyLink<N, L>>;
+    /** Node label accessor function or value. Default: `n => n.label` */
+    label?: StringAccessor<SankeyNode<N, L>>;
+    /** Node sub-label accessor function or value. Default: `undefined` */
+    subLabel?: StringAccessor<SankeyNode<N, L>>;
+    /** Label position relative to the Node. Default: `Position.AUTO` */
+    labelPosition?: GenericAccessor<Position.Auto | Position.Left | Position.Right | string, SankeyNode<N, L>>;
+    /** Label vertical alignment */
+    labelVerticalAlign?: VerticalAlign | string;
+    /** Label background */
+    labelBackground?: boolean;
+    /** Label fit mode (wrap or trim). Default: `FitMode.Trim` * */
+    labelFit?: FitMode;
+    /** Maximum label with in pixels. Default: `70` */
+    labelMaxWidth?: number;
+    /** Whether to take the available space for the label. This property is used only if `labelMaxWidth` is not provided. Default: `false` */
+    labelMaxWidthTakeAvailableSpace?: boolean;
+    /** Tolerance for the available space for the label. This property is used only if `labelMaxWidthTakeAvailableSpace` is `true`. Default: `undefined` (use label and sub-label font sizes) */
+    labelMaxWidthTakeAvailableSpaceTolerance?: number;
+    /** Expand trimmed label on hover. Default: `true` */
+    labelExpandTrimmedOnHover?: boolean;
+    /** Label trimming mode. Default: `TrimMode.Middle` */
+    labelTrimMode?: TrimMode;
+    /** Label font size in pixels. If not provided, the value of CSS variable `--vis-sankey-node-label-font-size` will be used. Default: `undefined` */
+    labelFontSize?: number;
+    /** Label text separators for wrapping. Default: `[' ', '-']` */
+    labelTextSeparator?: string[];
+    /** Label text decoration. Default: `undefined` */
+    labelTextDecoration?: StringAccessor<SankeyNode<N, L>>;
+    /** Force break words to fit long labels. Default: `true` */
+    labelForceWordBreak?: boolean;
+    /** Label color. Default: `undefined` */
+    labelColor?: ColorAccessor<SankeyNode<N, L>>;
+    /** Label cursor on hover. Default: `undefined` */
+    labelCursor?: StringAccessor<SankeyNode<N, L>>;
+    /** Custom function to set the label visibility. Default: `undefined` */
+    labelVisibility?: ((d: SankeyNode<N, L>, bbox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, hovered: boolean) => boolean) | undefined;
+    /** Sub-label font size in pixels. If not provided, the value of CSS variable `--vis-sankey-node-sublabel-font-size` will be used. Default: `undefined` */
+    subLabelFontSize?: number;
+    /** Sub-label color. Default: `undefined` */
+    subLabelColor?: ColorAccessor<SankeyNode<N, L>>;
+    /** Sub-label position. Default: `SankeySubLabelPlacement.Below` */
+    subLabelPlacement?: SankeySubLabelPlacement | string;
+    /** Sub-label text decoration. Default: `undefined` */
+    subLabelTextDecoration?: StringAccessor<SankeyNode<N, L>>;
+    /** Sub-label to label width ratio when `subLabelPlacement` is set to `SankeySubLabelPlacement.Inline`
+     * Default: `0.4`, which means that 40% of `labelMaxWidth` will be given to sub-label, and 60% to the main label. */
+    subLabelToLabelInlineWidthRatio?: number;
+    /** Zoom event callback. Default: `undefined` */
+    onZoom?: (horizontalScale: number, verticalScale: number, panX: number, panY: number, zoomExtent: [number, number], event: D3ZoomEvent<SVGGElement, unknown> | undefined) => void;
+    /** Callback function to be called when the graph layout is calculated. Default: `undefined` */
+    onLayoutCalculated?: (nodes: SankeyNode<N, L>[], links: SankeyLink<N, L>[], depth: number, width: number, height: number, bleed: Spacing) => void;
+    /** Set selected nodes by unique id. Default: `undefined` */
+    selectedNodeIds?: string[];
+    data: {
+        nodes: N[];
+        links?: L[];
+    };
+    component: Sankey<N, L> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisSankeyComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisSankeyComponent<any, any>, "vis-sankey", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "id": { "alias": "id"; "required": false; }; "heightNormalizationCoeff": { "alias": "heightNormalizationCoeff"; "required": false; }; "zoomScale": { "alias": "zoomScale"; "required": false; }; "zoomPan": { "alias": "zoomPan"; "required": false; }; "enableZoom": { "alias": "enableZoom"; "required": false; }; "zoomExtent": { "alias": "zoomExtent"; "required": false; }; "zoomMode": { "alias": "zoomMode"; "required": false; }; "disableZoomModifierKeys": { "alias": "disableZoomModifierKeys"; "required": false; }; "exitTransitionType": { "alias": "exitTransitionType"; "required": false; }; "enterTransitionType": { "alias": "enterTransitionType"; "required": false; }; "highlightSubtreeOnHover": { "alias": "highlightSubtreeOnHover"; "required": false; }; "highlightDuration": { "alias": "highlightDuration"; "required": false; }; "highlightDelay": { "alias": "highlightDelay"; "required": false; }; "iterations": { "alias": "iterations"; "required": false; }; "nodeSort": { "alias": "nodeSort"; "required": false; }; "linkSort": { "alias": "linkSort"; "required": false; }; "nodeWidth": { "alias": "nodeWidth"; "required": false; }; "nodeAlign": { "alias": "nodeAlign"; "required": false; }; "nodeHorizontalSpacing": { "alias": "nodeHorizontalSpacing"; "required": false; }; "nodeMinHeight": { "alias": "nodeMinHeight"; "required": false; }; "nodeMaxHeight": { "alias": "nodeMaxHeight"; "required": false; }; "nodePadding": { "alias": "nodePadding"; "required": false; }; "nodeAdaptivePadding": { "alias": "nodeAdaptivePadding"; "required": false; }; "showSingleNode": { "alias": "showSingleNode"; "required": false; }; "nodeCursor": { "alias": "nodeCursor"; "required": false; }; "nodeIcon": { "alias": "nodeIcon"; "required": false; }; "nodeColor": { "alias": "nodeColor"; "required": false; }; "nodePattern": { "alias": "nodePattern"; "required": false; }; "nodeFixedValue": { "alias": "nodeFixedValue"; "required": false; }; "nodeIconColor": { "alias": "nodeIconColor"; "required": false; }; "linkColor": { "alias": "linkColor"; "required": false; }; "linkPattern": { "alias": "linkPattern"; "required": false; }; "linkValue": { "alias": "linkValue"; "required": false; }; "linkCursor": { "alias": "linkCursor"; "required": false; }; "label": { "alias": "label"; "required": false; }; "subLabel": { "alias": "subLabel"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "labelVerticalAlign": { "alias": "labelVerticalAlign"; "required": false; }; "labelBackground": { "alias": "labelBackground"; "required": false; }; "labelFit": { "alias": "labelFit"; "required": false; }; "labelMaxWidth": { "alias": "labelMaxWidth"; "required": false; }; "labelMaxWidthTakeAvailableSpace": { "alias": "labelMaxWidthTakeAvailableSpace"; "required": false; }; "labelMaxWidthTakeAvailableSpaceTolerance": { "alias": "labelMaxWidthTakeAvailableSpaceTolerance"; "required": false; }; "labelExpandTrimmedOnHover": { "alias": "labelExpandTrimmedOnHover"; "required": false; }; "labelTrimMode": { "alias": "labelTrimMode"; "required": false; }; "labelFontSize": { "alias": "labelFontSize"; "required": false; }; "labelTextSeparator": { "alias": "labelTextSeparator"; "required": false; }; "labelTextDecoration": { "alias": "labelTextDecoration"; "required": false; }; "labelForceWordBreak": { "alias": "labelForceWordBreak"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "labelCursor": { "alias": "labelCursor"; "required": false; }; "labelVisibility": { "alias": "labelVisibility"; "required": false; }; "subLabelFontSize": { "alias": "subLabelFontSize"; "required": false; }; "subLabelColor": { "alias": "subLabelColor"; "required": false; }; "subLabelPlacement": { "alias": "subLabelPlacement"; "required": false; }; "subLabelTextDecoration": { "alias": "subLabelTextDecoration"; "required": false; }; "subLabelToLabelInlineWidthRatio": { "alias": "subLabelToLabelInlineWidthRatio"; "required": false; }; "onZoom": { "alias": "onZoom"; "required": false; }; "onLayoutCalculated": { "alias": "onLayoutCalculated"; "required": false; }; "selectedNodeIds": { "alias": "selectedNodeIds"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisSankeyModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisSankeyModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisSankeyModule, [typeof VisSankeyComponent], never, [typeof VisSankeyComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisSankeyModule>;
+}
+
+declare class VisRadialBarComponent<Datum> implements RadialBarConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string | number);
+    /** Value accessor function. Returning `null` or `undefined` marks the value as missing,
+     * and the corresponding bar will not be rendered. Default: `undefined` */
+    value: NumericAccessor<Datum>;
+    /** Maximum value accessor or an array of maximums (indexed by each datum's original position in `data` before sorting).
+     * Used to scale each bar's arc length: each bar fills `(value / maxValue) * (angleRange[1] - angleRange[0])`.
+     * When `undefined`, the maximum is derived from the data. Default: `undefined` */
+    maxValue?: NumericAccessor<Datum> | number[];
+    /** Diagram angle range. Default: `[0, 2 * Math.PI]` */
+    angleRange?: [number, number];
+    /** Pad angle in radians applied between the bar and its end. Default: `0` */
+    padAngle?: number;
+    /** Minimum bar angle in radians. Bars with small values, `0` included, will be extended to that angle,
+     * so that they remain visible. The value is clamped to the length of `angleRange`.
+     * Bars with missing values (see `value`) are not affected: they're never rendered.
+     * Set it to `0` to disable. Default: `0.01` (about 1 pixel wide on a ring of a 100 pixel radius) */
+    barMinAngle?: number;
+    /** Custom sort function. Default: `undefined` */
+    sortFunction?: (a: Datum, b: Datum) => number;
+    /** Corner Radius. Default: `0` */
+    cornerRadius?: number;
+    /** Color accessor function. Default: `undefined` */
+    color?: ColorAccessor<Datum>;
+    /** Explicitly set the outer radius of the outermost ring. Default: `undefined` */
+    radius?: number;
+    /** Width of each ring (track) in pixels. Default: `16` */
+    trackWidth?: number;
+    /** Gap between rings in pixels. Default: `4` */
+    trackPadding?: number;
+    /** When `true`, `data[0]` is the innermost ring instead of the outermost. Default: `false` */
+    reverseOrder?: boolean;
+    /** Central label text. Default: `undefined` */
+    centralLabel?: string;
+    /** Central sub-label text. Default: `undefined` */
+    centralSubLabel?: string;
+    /** Enables wrapping for the sub-label. Default: `true` */
+    centralSubLabelWrap?: boolean;
+    /** Central label and sub-label horizontal offset in pixels. Default: `undefined` */
+    centralLabelOffsetX?: number;
+    /** Central label and sub-label vertical offset in pixels. Default: `undefined` */
+    centralLabelOffsetY?: number;
+    /** Show a faded background track for each ring. The color is configurable via
+     * the `--vis-radial-bar-background-color` and `--vis-dark-radial-bar-background-color` CSS variables.
+     * Default: `true` */
+    showBackground?: boolean;
+    /** Background angle range. When `undefined`, the value will be taken from `angleRange`. Default: `undefined` */
+    backgroundAngleRange?: [number, number];
+    data: Datum[];
+    component: RadialBar<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisRadialBarComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisRadialBarComponent<any>, "vis-radial-bar", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "id": { "alias": "id"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; "angleRange": { "alias": "angleRange"; "required": false; }; "padAngle": { "alias": "padAngle"; "required": false; }; "barMinAngle": { "alias": "barMinAngle"; "required": false; }; "sortFunction": { "alias": "sortFunction"; "required": false; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; }; "color": { "alias": "color"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "trackWidth": { "alias": "trackWidth"; "required": false; }; "trackPadding": { "alias": "trackPadding"; "required": false; }; "reverseOrder": { "alias": "reverseOrder"; "required": false; }; "centralLabel": { "alias": "centralLabel"; "required": false; }; "centralSubLabel": { "alias": "centralSubLabel"; "required": false; }; "centralSubLabelWrap": { "alias": "centralSubLabelWrap"; "required": false; }; "centralLabelOffsetX": { "alias": "centralLabelOffsetX"; "required": false; }; "centralLabelOffsetY": { "alias": "centralLabelOffsetY"; "required": false; }; "showBackground": { "alias": "showBackground"; "required": false; }; "backgroundAngleRange": { "alias": "backgroundAngleRange"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisRadialBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisRadialBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisRadialBarModule, [typeof VisRadialBarComponent], never, [typeof VisRadialBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisRadialBarModule>;
+}
+
+declare class VisScatterComponent<Datum> implements ScatterConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Point color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Point fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    pattern?: GenericAccessor<FillPatternType, Datum>;
+    /** Size of the scatter plot marker (e.g. diameter if `SymbolType.Circle` is used for `shape`) in pixels.
+     * Can be a constant value or an accessor function. But if `sizeRange` is set, then the values will be treated
+     * as an input to `sizeScale`, and the resulting size will be different.
+     * Default: `10` */
+    size?: NumericAccessor<Datum>;
+    /** Size scale to be used if the `sizeRange` was set. Default: `Scale.scaleSqrt()` */
+    sizeScale?: ContinuousScale;
+    /** Size range in the format of `[number, number]` to rescale the input values. Default: `undefined` */
+    sizeRange?: [number, number];
+    /** Shape of the scatter point. Accessor function or constant value: `SymbolType.Circle`, `SymbolType.Cross`, `SymbolType.Diamond`, `SymbolType.Square`,
+     * `SymbolType.Star`, `SymbolType.Triangle` or `SymbolType.Wye`.
+     * Default: `SymbolType.Circle` */
+    shape?: ((d: Datum, i?: number, ...rest: any[]) => (SymbolType | string)) | SymbolType | string;
+    /** Label accessor function or string. Default: `undefined` */
+    label?: StringAccessor<Datum>;
+    /** Label color. Default: `undefined` */
+    labelColor?: ColorAccessor<Datum>;
+    /** Hide overlapping labels. Default: `true` */
+    labelHideOverlapping?: boolean;
+    /** Optional point cursor. Default: `null` */
+    cursor?: StringAccessor<Datum>;
+    /** Point color brightness ratio for switching between dark and light text label color. Default: `0.65` */
+    labelTextBrightnessRatio?: number;
+    /** Label position. Default: `Position.Bottom` */
+    labelPosition?: GenericAccessor<Position | string, Datum>;
+    /** Point stroke color. Default: `undefined` */
+    strokeColor?: ColorAccessor<Datum>;
+    /** Point stroke width. Default: `undefined` */
+    strokeWidth?: NumericAccessor<Datum>;
+    data: Datum[];
+    component: Scatter<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisScatterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisScatterComponent<any>, "vis-scatter", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "size": { "alias": "size"; "required": false; }; "sizeScale": { "alias": "sizeScale"; "required": false; }; "sizeRange": { "alias": "sizeRange"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "labelHideOverlapping": { "alias": "labelHideOverlapping"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "labelTextBrightnessRatio": { "alias": "labelTextBrightnessRatio"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisScatterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisScatterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisScatterModule, [typeof VisScatterComponent], never, [typeof VisScatterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisScatterModule>;
+}
+
+declare class VisStackedBarComponent<Datum> implements StackedBarConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** A single of multiple accessor functions for getting the values along the Y axis. Default: `undefined` */
+    y: NumericAccessor<Datum> | NumericAccessor<Datum>[];
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Bar color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Bar fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    pattern?: GenericAccessor<FillPatternType, Datum>;
+    /** The value each bar's stack starts from, instead of zero. Number or accessor function.
+     * Useful for floating bars and waterfall charts, where every bar starts where the previous one ended.
+     * Default: `undefined` */
+    baseline?: NumericAccessor<Datum>;
+    /** Force set bar width in pixels. Default: `undefined` */
+    barWidth?: number;
+    /** Maximum bar width for dynamic sizing. Default: `undefined` */
+    barMaxWidth?: number;
+    /** Expected step between the bars in the X axis units.
+     * Needed to correctly calculate the width of the bars when there are gaps in the data.
+     * Default: `undefined` */
+    dataStep?: number;
+    /** Fractional padding between the bars in the range of [0,1). Default: `0` */
+    barPadding?: number;
+    /** Rounded corners for top bars. Boolean or number (to set the radius in pixels). Default: `2` */
+    roundedCorners?: number | boolean;
+    /** Configurable bar cursor when hovering over. Default: `null` */
+    cursor?: StringAccessor<Datum>;
+    /** Sets the minimum bar height to 1 pixel for better visibility of small values. Default: `false` */
+    barMinHeight1Px?: boolean;
+    /** Base value to test data existence when `barMinHeight1Px` is set to `true`.
+     * Everything equal to barMinHeightZeroValue will not be rendered on the chart.
+     * Default: `null` */
+    barMinHeightZeroValue?: any;
+    /** Chart orientation: `Orientation.Vertical` or `Orientation.Horizontal`. Default `Orientation.Vertical` */
+    orientation?: Orientation | string;
+    data: Datum[];
+    component: StackedBar<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisStackedBarComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisStackedBarComponent<any>, "vis-stacked-bar", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "baseline": { "alias": "baseline"; "required": false; }; "barWidth": { "alias": "barWidth"; "required": false; }; "barMaxWidth": { "alias": "barMaxWidth"; "required": false; }; "dataStep": { "alias": "dataStep"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundedCorners": { "alias": "roundedCorners"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "barMinHeight1Px": { "alias": "barMinHeight1Px"; "required": false; }; "barMinHeightZeroValue": { "alias": "barMinHeightZeroValue"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisStackedBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisStackedBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisStackedBarModule, [typeof VisStackedBarComponent], never, [typeof VisStackedBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisStackedBarModule>;
+}
+
+declare class VisTimelineComponent<Datum> implements TimelineConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Timeline item color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /**  */
+    type?: StringAccessor<Datum>;
+    /**  */
+    length?: NumericAccessor<Datum>;
+    /**  */
+    cursor?: StringAccessor<Datum>;
+    /** Timeline item row accessor function. Records with the `lineRow` will be plotted in one row. Default: `undefined` */
+    lineRow?: StringAccessor<Datum>;
+    /** Timeline item duration accessor function. Default: `undefined`. Falls back to the deprecated `length` property */
+    lineDuration?: NumericAccessor<Datum>;
+    /** Timeline item fill pattern accessor. Resolves to a `FillPatternType`. Default: `undefined` */
+    pattern?: GenericAccessor<FillPatternType, Datum>;
+    /** Width of the timeline items. Default: `8` */
+    lineWidth?: NumericAccessor<Datum>;
+    /** Display rounded ends for timeline items. Default: `true` */
+    lineCap?: boolean;
+    /** Provide a href to an SVG defined in container's `svgDefs` to display an icon at the start of the line. Default: undefined */
+    lineStartIcon?: StringAccessor<Datum>;
+    /** Line start icon color accessor function. Default: `undefined` */
+    lineStartIconColor?: StringAccessor<Datum>;
+    /** Line start icon size accessor function. Default: `undefined` */
+    lineStartIconSize?: NumericAccessor<Datum>;
+    /** Line start icon arrangement configuration. Controls how the icon is positioned relative to the line.
+     * Accepts values from the Arrangement enum: `Arrangement.Start`, `Arrangement.Middle`, `Arrangement.End` or a string equivalent.
+     * Default: `Arrangement.Inside` */
+    lineStartIconArrangement?: GenericAccessor<Arrangement | `${Arrangement}`, Datum>;
+    /** Provide a href to an SVG defined in container's `svgDefs` to display an icon at the end of the line. Default: undefined */
+    lineEndIcon?: StringAccessor<Datum>;
+    /** Line end icon color accessor function. Default: `undefined` */
+    lineEndIconColor?: StringAccessor<Datum>;
+    /** Line end icon size accessor function. Default: `undefined` */
+    lineEndIconSize?: NumericAccessor<Datum>;
+    /** Line end icon arrangement configuration. Controls how the icon is positioned relative to the line.
+     * Accepts values from the Arrangement enum: `Arrangement.Start`, `Arrangement.Middle`, `Arrangement.End` or a string equivalent.
+     * Default: `Arrangement.Inside` */
+    lineEndIconArrangement?: GenericAccessor<Arrangement | `${Arrangement}`, Datum>;
+    /** Configurable Timeline item cursor when hovering over. Default: `undefined` */
+    lineCursor?: StringAccessor<Datum>;
+    /** Sets the minimum line length to 1 pixel for better visibility of small values.
+     * When `lineCap` is set to `true`, the segment will be rendered as a circle.
+     * Default: `false` */
+    showEmptySegments?: boolean;
+    /** Center small segments when `showEmptySegments` and `lineCap` are set to `true`.
+     * Default: `true` */
+    showEmptySegmentsCorrectPosition?: boolean;
+    /** Timeline row height. Default: `22` */
+    rowHeight?: number;
+    /** Alternating row colors. Default: `true` */
+    alternatingRowColors?: boolean;
+    /**  */
+    showLabels?: boolean;
+    /**  */
+    labelWidth?: number;
+    /**  */
+    maxLabelWidth?: number;
+    /** Show row labels when set to `true`. Default: `false`. Falls back to deprecated `showLabels` */
+    showRowLabels?: boolean;
+    /** Row label style as an object with the `{ [property-name]: value }` format. Default: `undefined` */
+    rowLabelStyle?: GenericAccessor<Record<string, string>, TimelineRowLabel<Datum>>;
+    /** Row label formatter function. Default: `undefined` */
+    rowLabelFormatter?: (key: string, items: Datum[], i: number) => string;
+    /** Provide an icon href to be displayed before the row label. Default: `undefined` */
+    rowIcon?: (key: string, items: Datum[], i: number) => TimelineRowIcon | undefined;
+    /** Fixed label width in pixels. Labels longer than the specified value will be trimmed. Default: `undefined`. Falls back to deprecated `labelWidth`. */
+    rowLabelWidth?: number;
+    /** Maximum label width in pixels. Labels longer than the specified value will be trimmed. Default: `undefined`. Falls back to deprecated `maxLabelWidth`. */
+    rowMaxLabelWidth?: number;
+    /** Text alignment for labels: `TextAlign.Left`, `TextAlign.Center` or `TextAlign.Right`. Default: `TextAlign.Right` */
+    rowLabelTextAlign?: TextAlign | `${TextAlign}`;
+    /** Row label trim mode when width is limited: `TrimMode.Start`, `TrimMode.Middle` or `TrimMode.End`. Default: `TrimMode.Middle` */
+    rowLabelTrimMode?: TrimMode | `${TrimMode}`;
+    /** Row label margin in pixels. Can be a single number or a `[left, right]` tuple. Default: `[0, 5]` */
+    rowLabelMargin?: number | [number, number];
+    /** When component height is larger than the height of all rows, render rows to fill empty space */
+    rowFillEmptySpace?: boolean;
+    arrows?: TimelineArrow[];
+    /** Control the animation by specify the initial position for new lines as [x, y]. Default: `undefined` */
+    animationLineEnterPosition?: [number | undefined | null, number | undefined | null] | ((d: Datum & TimelineLineRenderState, i: number, data: (Datum & TimelineLineRenderState)[]) => [number | undefined, number | undefined]) | undefined;
+    /** Control the animation by specify the destination position for exiting lines as [x, y]. Default: `undefined` */
+    animationLineExitPosition?: [number | undefined | null, number | undefined | null] | ((d: Datum & TimelineLineRenderState, i: number, data: (Datum & TimelineLineRenderState)[]) => [number | undefined, number | undefined]) | undefined;
+    /** Scrolling callback function: `(scrollTop: number) => void`. Default: `undefined` */
+    onScroll?: (scrollTop: number) => void;
+    data: Datum[];
+    component: Timeline<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTimelineComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisTimelineComponent<any>, "vis-timeline", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "type": { "alias": "type"; "required": false; }; "length": { "alias": "length"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "lineRow": { "alias": "lineRow"; "required": false; }; "lineDuration": { "alias": "lineDuration"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "lineWidth": { "alias": "lineWidth"; "required": false; }; "lineCap": { "alias": "lineCap"; "required": false; }; "lineStartIcon": { "alias": "lineStartIcon"; "required": false; }; "lineStartIconColor": { "alias": "lineStartIconColor"; "required": false; }; "lineStartIconSize": { "alias": "lineStartIconSize"; "required": false; }; "lineStartIconArrangement": { "alias": "lineStartIconArrangement"; "required": false; }; "lineEndIcon": { "alias": "lineEndIcon"; "required": false; }; "lineEndIconColor": { "alias": "lineEndIconColor"; "required": false; }; "lineEndIconSize": { "alias": "lineEndIconSize"; "required": false; }; "lineEndIconArrangement": { "alias": "lineEndIconArrangement"; "required": false; }; "lineCursor": { "alias": "lineCursor"; "required": false; }; "showEmptySegments": { "alias": "showEmptySegments"; "required": false; }; "showEmptySegmentsCorrectPosition": { "alias": "showEmptySegmentsCorrectPosition"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "alternatingRowColors": { "alias": "alternatingRowColors"; "required": false; }; "showLabels": { "alias": "showLabels"; "required": false; }; "labelWidth": { "alias": "labelWidth"; "required": false; }; "maxLabelWidth": { "alias": "maxLabelWidth"; "required": false; }; "showRowLabels": { "alias": "showRowLabels"; "required": false; }; "rowLabelStyle": { "alias": "rowLabelStyle"; "required": false; }; "rowLabelFormatter": { "alias": "rowLabelFormatter"; "required": false; }; "rowIcon": { "alias": "rowIcon"; "required": false; }; "rowLabelWidth": { "alias": "rowLabelWidth"; "required": false; }; "rowMaxLabelWidth": { "alias": "rowMaxLabelWidth"; "required": false; }; "rowLabelTextAlign": { "alias": "rowLabelTextAlign"; "required": false; }; "rowLabelTrimMode": { "alias": "rowLabelTrimMode"; "required": false; }; "rowLabelMargin": { "alias": "rowLabelMargin"; "required": false; }; "rowFillEmptySpace": { "alias": "rowFillEmptySpace"; "required": false; }; "arrows": { "alias": "arrows"; "required": false; }; "animationLineEnterPosition": { "alias": "animationLineEnterPosition"; "required": false; }; "animationLineExitPosition": { "alias": "animationLineExitPosition"; "required": false; }; "onScroll": { "alias": "onScroll"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisTimelineModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTimelineModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisTimelineModule, [typeof VisTimelineComponent], never, [typeof VisTimelineComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisTimelineModule>;
+}
+
+declare class VisXYLabelsComponent<Datum> implements XYLabelsConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Accessor function for getting the values along the X axis. Default: `undefined` */
+    x: NumericAccessor<Datum>;
+    /** Single Y accessor function. Default: `undefined` */
+    y: NumericAccessor<Datum>;
+    /** Accessor function for getting the unique data record id. Used for more persistent data updates. Default: `(d, i) => d.id ?? i` */
+    id?: ((d: Datum, i: number, ...rest: any[]) => string);
+    /** Label color accessor function. Default: `d => d.color` */
+    color?: ColorAccessor<Datum>;
+    /** Array of data color keys. Use to map data keys to colors.
+     * Expected to the same length as the `y` accessors array.
+     * Default: `undefined` */
+    colorKeys?: string[];
+    /** Scale for X dimension, e.g. Scale.scaleLinear(). If you set xScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    xScale?: ContinuousScale;
+    /** Scale for Y dimension, e.g. Scale.scaleLinear(). If you set yScale you'll be responsible for setting it's `domain` and `range` as well.
+     * Only continuous scales are supported.
+     * Default: `undefined` */
+    yScale?: ContinuousScale;
+    /** Identifies whether the component should be excluded from overall X and Y domain calculations or not.
+     * This property can be useful when you want pass individual data to a component and you don't want it to affect
+     * the scales of the chart.
+     * Default: `false` */
+    excludeFromDomainCalculation?: boolean;
+    /** Defines how to position the label horizontally: in data space or in screen space. Default: `XYLabelPositioning.DataSpace` */
+    xPositioning?: GenericAccessor<XYLabelPositioning | string, Datum>;
+    /** Defines how to position the label vertically: in data space or in screen space. Default: `XYLabelPositioning.DataSpace` */
+    yPositioning?: GenericAccessor<XYLabelPositioning | string, Datum>;
+    /** Font size accessor function or constant value in pixels. If not provided, the value of CSS variable `--vis-xy-label-font-size` will be used. Default: `undefined` */
+    labelFontSize?: NumericAccessor<Datum>;
+    /** Label accessor function or string. Default: `undefined` */
+    label?: StringAccessor<Datum>;
+    /** Label color. Default: `undefined` */
+    backgroundColor?: ColorAccessor<Datum>;
+    /** Optional label cursor. Default: `null` */
+    cursor?: StringAccessor<Datum>;
+    /** Label color brightness ratio for switching between dark and light text label color. Default: `0.65` */
+    labelTextBrightnessRatio?: number;
+    /** Enable label clustering. Default: `true` */
+    clustering?: boolean;
+    /** Label accessor for clusters. Default: `undefined` */
+    clusterLabel?: StringAccessor<XYLabel<Datum>[]>;
+    /** Font size accessor for clusters, the value is in pixels. If not provided, the value of CSS variable `--vis-xy-label-cluster-font-size` will be used. Default: `undefined` */
+    clusterFontSize?: NumericAccessor<XYLabel<Datum>[]>;
+    /** Background color accessor for clusters. Default: `undefined` */
+    clusterBackgroundColor?: ColorAccessor<XYLabel<Datum>[]>;
+    /** Optional cluster cursor. Default: `null` */
+    clusterCursor?: StringAccessor<XYLabel<Datum>[]>;
+    /** Cluster label color accessor function. Default: `null` */
+    clusterLabelColor?: ColorAccessor<XYLabel<Datum>[]>;
+    data: Datum[];
+    component: XYLabels<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisXYLabelsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisXYLabelsComponent<any>, "vis-xy-labels", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colorKeys": { "alias": "colorKeys"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "excludeFromDomainCalculation": { "alias": "excludeFromDomainCalculation"; "required": false; }; "xPositioning": { "alias": "xPositioning"; "required": false; }; "yPositioning": { "alias": "yPositioning"; "required": false; }; "labelFontSize": { "alias": "labelFontSize"; "required": false; }; "label": { "alias": "label"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "cursor": { "alias": "cursor"; "required": false; }; "labelTextBrightnessRatio": { "alias": "labelTextBrightnessRatio"; "required": false; }; "clustering": { "alias": "clustering"; "required": false; }; "clusterLabel": { "alias": "clusterLabel"; "required": false; }; "clusterFontSize": { "alias": "clusterFontSize"; "required": false; }; "clusterBackgroundColor": { "alias": "clusterBackgroundColor"; "required": false; }; "clusterCursor": { "alias": "clusterCursor"; "required": false; }; "clusterLabelColor": { "alias": "clusterLabelColor"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisXYLabelsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisXYLabelsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisXYLabelsModule, [typeof VisXYLabelsComponent], never, [typeof VisXYLabelsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisXYLabelsModule>;
+}
+
+declare class VisTopoJSONMapComponent<AreaDatum, PointDatum, LinkDatum> implements TopoJSONMapConfigInterface<AreaDatum, PointDatum, LinkDatum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** MapProjection (aka D3's GeoProjection) instance. Default: `MapProjection.Kavrayskiy7()` */
+    projection?: GeoProjection;
+    /** Map data in the TopoJSON topology format. Default: `undefined` */
+    topojson?: TopoJSON.Topology;
+    /** Name of the map features to be displayed, e.g. 'countries' or 'counties'. Default: `countries` */
+    mapFeatureName?: string;
+    /** Set initial map fit to points instead of topojson features. Default: `false` */
+    mapFitToPoints?: boolean;
+    /** Initial zoom level. Default: `undefined` */
+    zoomFactor?: number;
+    /** Zoom to a specific location. When set, the map will zoom to the specified coordinates at the given zoom level.
+     * Format: `{ coordinates: [longitude, latitude], zoomLevel: number, expandCluster?: boolean }`
+     * When `expandCluster` is true, the cluster at or nearest to the coordinates will be expanded.
+     * Default: `undefined` */
+    zoomToLocation?: {
+        coordinates: [number, number];
+        zoomLevel: number;
+        expandCluster?: boolean;
+    };
+    /** Disable pan / zoom interactions. Default: `false` */
+    disableZoom?: boolean;
+    /** Zoom extent. Default: `[0.5, 6]` */
+    zoomExtent?: number[];
+    /** Zoom animation duration. Default: `400` */
+    zoomDuration?: number;
+    /** Link width value or accessor function. Default: `d => d.width ?? 1` */
+    linkWidth?: NumericAccessor<LinkDatum>;
+    /** Link color value or accessor function. Default: `d => d.color ?? null` */
+    linkColor?: ColorAccessor<LinkDatum>;
+    /** Link cursor value or accessor function. Default: `null` */
+    linkCursor?: StringAccessor<LinkDatum>;
+    /** Link id accessor function. Default: `d => d.id` */
+    linkId?: StringAccessor<LinkDatum>;
+    /** Link source accessor function. Default: `d => d.source` */
+    linkSource?: ((l: LinkDatum) => number | string | PointDatum);
+    /** Link target accessor function. Default: `d => d.target` */
+    linkTarget?: ((l: LinkDatum) => number | string | PointDatum);
+    /** Flow source point longitude accessor function or value. Default: `f => f.sourceLongitude` */
+    sourceLongitude?: NumericAccessor<LinkDatum>;
+    /** Flow source point latitude accessor function or value. Default: `f => f.sourceLatitude` */
+    sourceLatitude?: NumericAccessor<LinkDatum>;
+    /** Flow target point longitude accessor function or value. Default: `f => f.targetLongitude` */
+    targetLongitude?: NumericAccessor<LinkDatum>;
+    /** Flow target point latitude accessor function or value. Default: `f => f.targetLatitude` */
+    targetLatitude?: NumericAccessor<LinkDatum>;
+    /** Flow source point radius accessor function or value. Default: `3` */
+    sourcePointRadius?: NumericAccessor<LinkDatum>;
+    /** Source point color accessor function or value. Default: `'#88919f'` */
+    sourcePointColor?: ColorAccessor<LinkDatum>;
+    /** Flow particle color accessor function or value. Default: `'#949dad'` */
+    flowParticleColor?: ColorAccessor<LinkDatum>;
+    /** Flow particle radius accessor function or value. Default: `1.1` */
+    flowParticleRadius?: NumericAccessor<LinkDatum>;
+    /** Flow particle speed accessor function or value. The unit is arbitrary, recommended range is 0 – 0.2. Default: `0.07` */
+    flowParticleSpeed?: NumericAccessor<LinkDatum>;
+    /** Flow particle density accessor function or value on the range of [0, 1]. Default: `0.6` */
+    flowParticleDensity?: NumericAccessor<LinkDatum>;
+    /** Enable flow animations. When true, shows animated particles along links. Default: `false` */
+    enableFlowAnimation?: boolean;
+    /** Flow source point click callback function. Default: `undefined` */
+    onSourcePointClick?: (f: LinkDatum, x: number, y: number, event: MouseEvent) => void;
+    /** Flow source point mouse over callback function. Default: `undefined` */
+    onSourcePointMouseEnter?: (f: LinkDatum, x: number, y: number, event: MouseEvent) => void;
+    /** Flow source point mouse leave callback function. Default: `undefined` */
+    onSourcePointMouseLeave?: (f: LinkDatum, event: MouseEvent) => void;
+    /** Area id accessor function corresponding to the feature id from TopoJSON. Default: `d => d.id ?? ''` */
+    areaId?: StringAccessor<AreaDatum>;
+    /** Area color value or accessor function. Default: `d => d.color ?? null` */
+    areaColor?: ColorAccessor<AreaDatum>;
+    /** Area cursor value or accessor function. Default: `null` */
+    areaCursor?: StringAccessor<AreaDatum>;
+    /** Area label accessor function. Default: `undefined` */
+    areaLabel?: StringAccessor<AreaDatum>;
+    /** Point color accessor. Default: `d => d.color ?? null` */
+    pointColor?: ColorAccessor<PointDatum>;
+    /** Point radius accessor. Default: `d => d.radius ?? 8` */
+    pointRadius?: NumericAccessor<PointDatum>;
+    /** Point stroke width accessor. Default: `d => d.strokeWidth ?? null` */
+    pointStrokeWidth?: NumericAccessor<PointDatum>;
+    /** Point shape accessor. Default: `TopoJSONMapPointShape.Circle` */
+    pointShape?: StringAccessor<PointDatum>;
+    /** Point ring width for ring-shaped points. Default: `2` */
+    pointRingWidth?: NumericAccessor<PointDatum>;
+    /** Point cursor constant value or accessor function. Default: `null` */
+    pointCursor?: StringAccessor<PointDatum>;
+    /** Point longitude accessor function. Default: `d => d.longitude ?? null` */
+    longitude?: NumericAccessor<PointDatum>;
+    /** Point latitude accessor function. Default: `d => d.latitude ?? null` */
+    latitude?: NumericAccessor<PointDatum>;
+    /** Point inner label accessor function. Default: `undefined` */
+    pointLabel?: StringAccessor<PointDatum>;
+    /** Point inner label color accessor function or constant value.
+     * By default, the label color will be set, depending on the point brightness, either to
+     * `--vis-map-point-label-text-color-dark` or to `--vis-map-point-label-text-color-light` CSS variable.
+     * Default: `undefined` */
+    pointLabelColor?: ColorAccessor<PointDatum>;
+    /** Point label position. Default: `MapPointLabelPosition.Center` */
+    pointLabelPosition?: MapPointLabelPosition;
+    /** Point bottom label accessor function. Default: `undefined` */
+    pointBottomLabel?: StringAccessor<PointDatum>;
+    /** Point color brightness ratio for switching between dark and light text label color. Default: `0.65` */
+    pointLabelTextBrightnessRatio?: number;
+    /** Point id accessor function. Default: `d => d.id` */
+    pointId?: ((d: PointDatum, i: number) => string);
+    /** Cluster color accessor function or constant value. Default: `undefined` */
+    clusterColor?: ColorAccessor<TopoJSONMapClusterDatum<PointDatum>>;
+    /** Cluster radius accessor function or constant value. Default: `undefined` */
+    clusterRadius?: NumericAccessor<TopoJSONMapClusterDatum<PointDatum>>;
+    /** Cluster inner label accessor function. Default: `d => d.pointCount` */
+    clusterLabel?: StringAccessor<TopoJSONMapClusterDatum<PointDatum>>;
+    /** Cluster inner label color accessor function or constant value. Default: `undefined` */
+    clusterLabelColor?: StringAccessor<TopoJSONMapClusterDatum<PointDatum>>;
+    /** Cluster bottom label accessor function. Default: `''` */
+    clusterBottomLabel?: StringAccessor<TopoJSONMapClusterDatum<PointDatum>>;
+    /** The width of the cluster point ring. Default: `2` */
+    clusterRingWidth?: number;
+    /** When cluster is expanded, show a background circle to better separate points from the base map. Default: `true` */
+    clusterBackground?: boolean;
+    /** Defines whether the cluster should expand on click or not. Default: `true` */
+    clusterExpandOnClick?: boolean;
+    /** Clustering distance in pixels. Default: `55` */
+    clusteringDistance?: number;
+    /** Enable point clustering. Default: `false` */
+    clustering?: boolean;
+    /** Enables blur and blending between neighbouring points. Default: `false` */
+    heatmapMode?: boolean;
+    /** Heatmap blur filter stdDeviation value. Default: `10` */
+    heatmapModeBlurStdDeviation?: number;
+    /** Zoom level at which the heatmap mode will be disabled. Default: `2.5` */
+    heatmapModeZoomLevelThreshold?: number;
+    /** A single map point can have multiple properties displayed as a small pie chart.
+     * By setting the colorMap configuration you can specify data properties that should be mapped to various pie / donut segments.
+     *
+     * ```
+     * {
+     *  [key in keyof PointDatum]?: { color: string, className?: string }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     *  healthy: { color: 'green' },
+     *  warning: { color: 'orange' },
+     *  critical: { color: 'red' }
+     * }
+     * ```
+     * where every data point has the `healthy`, `warning` and `critical` numerical or boolean property.
+     * Note: Properties with 0 or falsy values will not be displayed in the pie chart.
+     * Default: `{}` */
+    colorMap?: TopoJSONMapPointStyles<PointDatum>;
+    data: {
+        areas?: AreaDatum[];
+        points?: PointDatum[];
+        links?: LinkDatum[];
+    };
+    component: TopoJSONMap<AreaDatum, PointDatum, LinkDatum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTopoJSONMapComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisTopoJSONMapComponent<any, any, any>, "vis-topojson-map", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "projection": { "alias": "projection"; "required": false; }; "topojson": { "alias": "topojson"; "required": false; }; "mapFeatureName": { "alias": "mapFeatureName"; "required": false; }; "mapFitToPoints": { "alias": "mapFitToPoints"; "required": false; }; "zoomFactor": { "alias": "zoomFactor"; "required": false; }; "zoomToLocation": { "alias": "zoomToLocation"; "required": false; }; "disableZoom": { "alias": "disableZoom"; "required": false; }; "zoomExtent": { "alias": "zoomExtent"; "required": false; }; "zoomDuration": { "alias": "zoomDuration"; "required": false; }; "linkWidth": { "alias": "linkWidth"; "required": false; }; "linkColor": { "alias": "linkColor"; "required": false; }; "linkCursor": { "alias": "linkCursor"; "required": false; }; "linkId": { "alias": "linkId"; "required": false; }; "linkSource": { "alias": "linkSource"; "required": false; }; "linkTarget": { "alias": "linkTarget"; "required": false; }; "sourceLongitude": { "alias": "sourceLongitude"; "required": false; }; "sourceLatitude": { "alias": "sourceLatitude"; "required": false; }; "targetLongitude": { "alias": "targetLongitude"; "required": false; }; "targetLatitude": { "alias": "targetLatitude"; "required": false; }; "sourcePointRadius": { "alias": "sourcePointRadius"; "required": false; }; "sourcePointColor": { "alias": "sourcePointColor"; "required": false; }; "flowParticleColor": { "alias": "flowParticleColor"; "required": false; }; "flowParticleRadius": { "alias": "flowParticleRadius"; "required": false; }; "flowParticleSpeed": { "alias": "flowParticleSpeed"; "required": false; }; "flowParticleDensity": { "alias": "flowParticleDensity"; "required": false; }; "enableFlowAnimation": { "alias": "enableFlowAnimation"; "required": false; }; "onSourcePointClick": { "alias": "onSourcePointClick"; "required": false; }; "onSourcePointMouseEnter": { "alias": "onSourcePointMouseEnter"; "required": false; }; "onSourcePointMouseLeave": { "alias": "onSourcePointMouseLeave"; "required": false; }; "areaId": { "alias": "areaId"; "required": false; }; "areaColor": { "alias": "areaColor"; "required": false; }; "areaCursor": { "alias": "areaCursor"; "required": false; }; "areaLabel": { "alias": "areaLabel"; "required": false; }; "pointColor": { "alias": "pointColor"; "required": false; }; "pointRadius": { "alias": "pointRadius"; "required": false; }; "pointStrokeWidth": { "alias": "pointStrokeWidth"; "required": false; }; "pointShape": { "alias": "pointShape"; "required": false; }; "pointRingWidth": { "alias": "pointRingWidth"; "required": false; }; "pointCursor": { "alias": "pointCursor"; "required": false; }; "longitude": { "alias": "longitude"; "required": false; }; "latitude": { "alias": "latitude"; "required": false; }; "pointLabel": { "alias": "pointLabel"; "required": false; }; "pointLabelColor": { "alias": "pointLabelColor"; "required": false; }; "pointLabelPosition": { "alias": "pointLabelPosition"; "required": false; }; "pointBottomLabel": { "alias": "pointBottomLabel"; "required": false; }; "pointLabelTextBrightnessRatio": { "alias": "pointLabelTextBrightnessRatio"; "required": false; }; "pointId": { "alias": "pointId"; "required": false; }; "clusterColor": { "alias": "clusterColor"; "required": false; }; "clusterRadius": { "alias": "clusterRadius"; "required": false; }; "clusterLabel": { "alias": "clusterLabel"; "required": false; }; "clusterLabelColor": { "alias": "clusterLabelColor"; "required": false; }; "clusterBottomLabel": { "alias": "clusterBottomLabel"; "required": false; }; "clusterRingWidth": { "alias": "clusterRingWidth"; "required": false; }; "clusterBackground": { "alias": "clusterBackground"; "required": false; }; "clusterExpandOnClick": { "alias": "clusterExpandOnClick"; "required": false; }; "clusteringDistance": { "alias": "clusteringDistance"; "required": false; }; "clustering": { "alias": "clustering"; "required": false; }; "heatmapMode": { "alias": "heatmapMode"; "required": false; }; "heatmapModeBlurStdDeviation": { "alias": "heatmapModeBlurStdDeviation"; "required": false; }; "heatmapModeZoomLevelThreshold": { "alias": "heatmapModeZoomLevelThreshold"; "required": false; }; "colorMap": { "alias": "colorMap"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisTopoJSONMapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTopoJSONMapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisTopoJSONMapModule, [typeof VisTopoJSONMapComponent], never, [typeof VisTopoJSONMapComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisTopoJSONMapModule>;
+}
+
+declare class VisTreemapComponent<Datum> implements TreemapConfigInterface<Datum>, AfterViewInit {
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    id?: ((d: Datum, i: number) => string | number);
+    value?: NumericAccessor<Datum>;
+    /** Array of accessor functions to defined the nested groups. Default: `[]` */
+    layers: StringAccessor<Datum>[];
+    /**  */
+    numberFormat?: (value: number) => string;
+    /** Function to generate the label text for each tile. Receives the `TreemapNode` and returns a `string`.
+     * Default: shows key and formatted value (e.g., "label: value"). */
+    tileLabel?: (node: TreemapNode<Datum>) => string;
+    /** Color accessor function for tiles. Default: `undefined` */
+    tileColor?: ColorAccessor<TreemapNode<Datum>>;
+    /** D3 tile function (e.g. `treemapSquarify`, `treemapDice` from `d3-hierarchy`). Default: `undefined`. */
+    tileFunction?: TreemapTileFunction<TreemapDatum<Datum>>;
+    /** Comparator for sorting hierarchy nodes before layout. Receives two `HierarchyNode`s. Default: `undefined`. */
+    tileSort?: ((a: TreemapNode<Datum>, b: TreemapNode<Datum>) => number) | null;
+    /** Padding passed to D3 treemap layout. Default: `2` */
+    tilePadding?: number;
+    /** Top padding passed to D3 treemap layout.
+     * Useful to make room for internal node labels.
+     * Default: `undefined` */
+    tilePaddingTop?: number;
+    /** Append SVG `<title>` element to tile rects. It will be shown when hovering over the tile. Default: `false` */
+    tileShowHtmlTooltip?: boolean;
+    /** Label internal nodes. Default: `false` */
+    labelInternalNodes?: boolean;
+    /** Label offset in the X direction. Default: `4` */
+    labelOffsetX?: number;
+    /** Label offset in the Y direction. Default: `4` */
+    labelOffsetY?: number;
+    /** How labels should fit within tiles: wrap or trim. Applicable only for leaf nodes. Default: `FitMode.Wrap` */
+    labelFit?: FitMode;
+    /** Label trimming mode. Default: `TrimMode.Middle` */
+    labelTrimMode?: TrimMode;
+    /** Border radius of the tiles in pixels. Default: `2` */
+    tileBorderRadius?: number;
+    /** Minimum fraction of width for border radius. Default: `1/8` */
+    tileBorderRadiusFactor?: number;
+    /** Enable lightness variance for sibling tiles. Default: `false` */
+    enableLightnessVariance?: boolean;
+    /** Enable font size variation for leaf node labels based on value. Default: `false` */
+    enableTileLabelFontSizeVariation?: boolean;
+    /** Small font size for leaf labels (used when `enableTileLabelFontSizeVariation` is `true`). Default: `8` */
+    tileLabelSmallFontSize?: number;
+    /** Medium font size for leaf labels (used when `enableTileLabelFontSizeVariation` is `true`). Default: `12` */
+    tileLabelMediumFontSize?: number;
+    /** Large font size for leaf labels (used when `enableTileLabelFontSizeVariation` is `true`). Default: `24` */
+    tileLabelLargeFontSize?: number;
+    /** Flag for showing cursor:pointer to indicate leaf tiles are clickable. Default: `undefined` */
+    showTileClickAffordance?: boolean;
+    /** Amount of lightness variation applied to sibling tiles when `enableLightnessVariance` is `true`. Default: `0.08` */
+    lightnessVariationAmount?: number;
+    /** Minimum size for labels in pixels. Default: `20` */
+    minTileSizeForLabel?: number;
+    data: Datum[];
+    component: Treemap<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTreemapComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisTreemapComponent<any>, "vis-treemap", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "id": { "alias": "id"; "required": false; }; "value": { "alias": "value"; "required": false; }; "layers": { "alias": "layers"; "required": false; }; "numberFormat": { "alias": "numberFormat"; "required": false; }; "tileLabel": { "alias": "tileLabel"; "required": false; }; "tileColor": { "alias": "tileColor"; "required": false; }; "tileFunction": { "alias": "tileFunction"; "required": false; }; "tileSort": { "alias": "tileSort"; "required": false; }; "tilePadding": { "alias": "tilePadding"; "required": false; }; "tilePaddingTop": { "alias": "tilePaddingTop"; "required": false; }; "tileShowHtmlTooltip": { "alias": "tileShowHtmlTooltip"; "required": false; }; "labelInternalNodes": { "alias": "labelInternalNodes"; "required": false; }; "labelOffsetX": { "alias": "labelOffsetX"; "required": false; }; "labelOffsetY": { "alias": "labelOffsetY"; "required": false; }; "labelFit": { "alias": "labelFit"; "required": false; }; "labelTrimMode": { "alias": "labelTrimMode"; "required": false; }; "tileBorderRadius": { "alias": "tileBorderRadius"; "required": false; }; "tileBorderRadiusFactor": { "alias": "tileBorderRadiusFactor"; "required": false; }; "enableLightnessVariance": { "alias": "enableLightnessVariance"; "required": false; }; "enableTileLabelFontSizeVariation": { "alias": "enableTileLabelFontSizeVariation"; "required": false; }; "tileLabelSmallFontSize": { "alias": "tileLabelSmallFontSize"; "required": false; }; "tileLabelMediumFontSize": { "alias": "tileLabelMediumFontSize"; "required": false; }; "tileLabelLargeFontSize": { "alias": "tileLabelLargeFontSize"; "required": false; }; "showTileClickAffordance": { "alias": "showTileClickAffordance"; "required": false; }; "lightnessVariationAmount": { "alias": "lightnessVariationAmount"; "required": false; }; "minTileSizeForLabel": { "alias": "minTileSizeForLabel"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisTreemapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTreemapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisTreemapModule, [typeof VisTreemapComponent], never, [typeof VisTreemapComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisTreemapModule>;
+}
+
+declare class VisPlotbandComponent<Datum> implements PlotbandConfigInterface<Datum>, AfterViewInit {
+    /** Duration of the animation in milliseconds. */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Axis to draw the plotband on. */
+    axis?: AxisType;
+    /** Start coordinate for the plotband. */
+    from?: number | null | undefined;
+    /** End coordinate for the plotband. */
+    to?: number | null | undefined;
+    /** Optional text to display on the plotband */
+    labelText?: string;
+    /** Position of the label relative to the plotband area (e.g., 'top-left-outside').
+     * Can be customized with a string. */
+    labelPosition?: PlotbandLabelPosition;
+    /** Horizontal offset (in pixels) for positioning the label. */
+    labelOffsetX?: number;
+    /** Vertical offset (in pixels) for positioning the label. */
+    labelOffsetY?: number;
+    /** Orientation of the label text. */
+    labelOrientation?: PlotbandLabelOrientation;
+    /** Optional color for the label text */
+    labelColor?: string;
+    /** Font size (in pixels) for the label text.
+     * Uses the CSS variable `--vis-plotband-label-font-size` by default, which resolves to `12px`. */
+    labelSize?: number;
+    component: Plotband<Datum> | undefined;
+    componentContainer: ContainerCore | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisPlotbandComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisPlotbandComponent<any>, "vis-plotband", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "axis": { "alias": "axis"; "required": false; }; "from": { "alias": "from"; "required": false; }; "to": { "alias": "to"; "required": false; }; "labelText": { "alias": "labelText"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "labelOffsetX": { "alias": "labelOffsetX"; "required": false; }; "labelOffsetY": { "alias": "labelOffsetY"; "required": false; }; "labelOrientation": { "alias": "labelOrientation"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "labelSize": { "alias": "labelSize"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisPlotbandModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisPlotbandModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisPlotbandModule, [typeof VisPlotbandComponent], never, [typeof VisPlotbandComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisPlotbandModule>;
+}
+
+declare class VisLeafletMapComponent<Datum extends GenericDataRecord> implements LeafletMapConfigInterface<Datum>, AfterViewInit {
+    containerRef: ElementRef;
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Width in pixels or in CSS units. By default, the map will automatically fit to the size of the parent element. Default: `undefined`. */
+    width?: number | string;
+    /** Height in pixels or in CSS units. By default, the map will automatically fit to the size of the parent element. Default: `undefined`. */
+    height?: number | string;
+    /** Animation duration when the map is automatically panning or zooming to a point or area. Default: `1500` ms */
+    flyToDuration?: number;
+    /** Padding to be used when the `fitView` function has been called. The value is in pixels, [topLeft, bottomRight]. Default: `[150, 150]` */
+    fitViewPadding?: [number, number];
+    /** Animation duration for the `setZoom` function. Default: `800` ms */
+    zoomDuration?: number;
+    /** Default bounds that will be applied on the first map render if the bounds property is not set. Default: `undefined` */
+    initialBounds?: Bounds;
+    /** Force set map bounds on config and data updates. Default: `undefined` */
+    fitBoundsOnUpdate?: Bounds;
+    /** Fit the view to contain the data points on map initialization. Default: `true` */
+    fitViewOnInit?: boolean;
+    /** Fit the view to contain the data points on map config and data updates. Default: `false` */
+    fitViewOnUpdate?: boolean;
+    /** MapLibre `StyleSpecification` settings, or a URL to it. When renderer is set to`LeafletMapRenderer.Raster`, provide a template URL. Default: `undefined` */
+    style: MapLibreStyleSpecs | string | undefined;
+    /** MapLibre `StyleSpecification` settings or URL for dark theme. Default: `undefined` */
+    styleDarkTheme?: MapLibreStyleSpecs | string | undefined;
+    /** Tile server access token or API key. Default: `''` */
+    accessToken?: string;
+    /** Array of attribution labels. Default: `['<a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap contributors</a>']` */
+    attribution?: string[];
+    /** Rendering mode for map's tile layer. For raster files, use `LeafletMapRenderer.Raster`. Default: `LeafletMapRenderer.MapLibre` */
+    renderer?: LeafletMapRenderer | string;
+    /** Function to be called after the map's async initialization is done. Default: `undefined` */
+    onMapInitialized?: (() => void);
+    /** Map Move / Zoom unified callback function. Default: `undefined` */
+    onMapMoveZoom?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Move Start callback function. Default: `undefined` */
+    onMapMoveStart?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Move End callback function. Default: `undefined` */
+    onMapMoveEnd?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Zoom Start callback function. Default: `undefined` */
+    onMapZoomStart?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Zoom End callback function. Default: `undefined` */
+    onMapZoomEnd?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Zoom Click callback function. Default: `undefined` */
+    onMapClick?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Point longitude accessor function. Default: `d => d.longitude` */
+    pointLongitude?: NumericAccessor<Datum>;
+    /** Point latitude accessor function. Default: `d => d.latitude` */
+    pointLatitude?: NumericAccessor<Datum>;
+    /** Point id accessor function or constant value. Default: `d => d.id` */
+    pointId?: StringAccessor<Datum>;
+    /** Point shape accessor function or constant value. Default: `d => d.shape` */
+    pointShape?: GenericAccessor<LeafletMapPointShape | string, Datum>;
+    /** Point color accessor function or constant value. Default: `d => d.color` */
+    pointColor?: ColorAccessor<LeafletMapPointDatum<Datum>>;
+    /** Point radius accessor function or constant value. Default: `undefined` */
+    pointRadius?: NumericAccessor<LeafletMapPointDatum<Datum>>;
+    /** Point inner label accessor function. Default: `undefined` */
+    pointLabel?: StringAccessor<LeafletMapPointDatum<Datum>>;
+    /** Point inner label color accessor function or constant value.
+     * By default, the label color will be set, depending on the point brightness, either to
+     * `--vis-map-point-inner-label-text-color-light` or to `--vis-map-point-inner-label-text-color-dark` CSS variable.
+     * Default: `undefined` */
+    pointLabelColor?: StringAccessor<LeafletMapPointDatum<Datum>>;
+    /** Point bottom label accessor function. Default: `''` */
+    pointBottomLabel?: StringAccessor<LeafletMapPointDatum<Datum>>;
+    /** Point cursor value or accessor function. Default: `null` */
+    pointCursor?: StringAccessor<LeafletMapPointDatum<Datum>>;
+    /** The width of the ring when a point has a `LeafletMapPointShape.Ring` shape. Default: `1.25` */
+    pointRingWidth?: number;
+    /** Set selected point by its unique id. Default: `undefined` */
+    selectedPointId?: string;
+    /** Cluster color accessor function or constant value. Default: `undefined` */
+    clusterColor?: ColorAccessor<LeafletMapClusterDatum<Datum>>;
+    /** Cluster radius accessor function or constant value. Default: `undefined` */
+    clusterRadius?: NumericAccessor<LeafletMapClusterDatum<Datum>>;
+    /** Cluster inner label accessor function. Default: `d => d.point_count` */
+    clusterLabel?: StringAccessor<LeafletMapClusterDatum<Datum>>;
+    /** Cluster inner label color accessor function or constant value.
+     * By default, the label color will be set, depending on the point brightness, either to
+     * `--vis-map-cluster-inner-label-text-color-light` or to `--vis-map-cluster-inner-label-text-color-dark` CSS variable.
+     * Default: `undefined` */
+    clusterLabelColor?: StringAccessor<LeafletMapClusterDatum<Datum>>;
+    /** Cluster bottom label accessor function. Default: `''` */
+    clusterBottomLabel?: StringAccessor<LeafletMapClusterDatum<Datum>>;
+    /** The width of the cluster point ring. Default: `1.25` */
+    clusterRingWidth?: number;
+    /** When cluster is expanded, show a background circle to better separate points from the base map. Default: `true` */
+    clusterBackground?: boolean;
+    /** Defines whether the cluster should expand on click or not. Default: `true` */
+    clusterExpandOnClick?: boolean;
+    /** Clustering distance in pixels. This value will be passed to Supercluster as the `radius` property https://github.com/mapbox/supercluster. Default: `55` */
+    clusteringDistance?: number;
+    /** A single map point can have multiple properties displayed as a small pie chart (or a donut chart for a cluster of points).
+     * By setting the colorMap configuration you can specify data properties that should be mapped to various pie / donut segments.
+     *
+     * ```
+     * {
+     * \[key in keyof Datum]?: { color: string, className?: string }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \healthy: { color: 'green' },
+     * \warning: { color: 'orange' },
+     * \danger: { color: 'red' }
+     * }
+     * ```
+     * where every data point has the `healthy`, `warning` and `danger` numerical or boolean property. */
+    colorMap?: LeafletMapPointStyles<Datum>;
+    /** A TopoJSON Geometry layer to be displayed on top of the map. Supports fill and stroke */
+    topoJSONLayer?: {
+        sources: any;
+        featureName?: string;
+        fillProperty?: string;
+        strokeProperty?: string;
+        fillOpacity?: number;
+        strokeOpacity?: number;
+        strokeWidth?: number;
+    };
+    /** Tooltip component. Default: `undefined` */
+    tooltip?: Tooltip;
+    /** Alternative text description of the chart for accessibility purposes. It will be applied as an
+     * `aria-label` attribute to the div element containing your chart. Default: `undefined`. */
+    ariaLabel?: string | null | undefined;
+    data: Datum[];
+    component: LeafletMap<Datum> | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisLeafletMapComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisLeafletMapComponent<any>, "vis-leaflet-map", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "flyToDuration": { "alias": "flyToDuration"; "required": false; }; "fitViewPadding": { "alias": "fitViewPadding"; "required": false; }; "zoomDuration": { "alias": "zoomDuration"; "required": false; }; "initialBounds": { "alias": "initialBounds"; "required": false; }; "fitBoundsOnUpdate": { "alias": "fitBoundsOnUpdate"; "required": false; }; "fitViewOnInit": { "alias": "fitViewOnInit"; "required": false; }; "fitViewOnUpdate": { "alias": "fitViewOnUpdate"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleDarkTheme": { "alias": "styleDarkTheme"; "required": false; }; "accessToken": { "alias": "accessToken"; "required": false; }; "attribution": { "alias": "attribution"; "required": false; }; "renderer": { "alias": "renderer"; "required": false; }; "onMapInitialized": { "alias": "onMapInitialized"; "required": false; }; "onMapMoveZoom": { "alias": "onMapMoveZoom"; "required": false; }; "onMapMoveStart": { "alias": "onMapMoveStart"; "required": false; }; "onMapMoveEnd": { "alias": "onMapMoveEnd"; "required": false; }; "onMapZoomStart": { "alias": "onMapZoomStart"; "required": false; }; "onMapZoomEnd": { "alias": "onMapZoomEnd"; "required": false; }; "onMapClick": { "alias": "onMapClick"; "required": false; }; "pointLongitude": { "alias": "pointLongitude"; "required": false; }; "pointLatitude": { "alias": "pointLatitude"; "required": false; }; "pointId": { "alias": "pointId"; "required": false; }; "pointShape": { "alias": "pointShape"; "required": false; }; "pointColor": { "alias": "pointColor"; "required": false; }; "pointRadius": { "alias": "pointRadius"; "required": false; }; "pointLabel": { "alias": "pointLabel"; "required": false; }; "pointLabelColor": { "alias": "pointLabelColor"; "required": false; }; "pointBottomLabel": { "alias": "pointBottomLabel"; "required": false; }; "pointCursor": { "alias": "pointCursor"; "required": false; }; "pointRingWidth": { "alias": "pointRingWidth"; "required": false; }; "selectedPointId": { "alias": "selectedPointId"; "required": false; }; "clusterColor": { "alias": "clusterColor"; "required": false; }; "clusterRadius": { "alias": "clusterRadius"; "required": false; }; "clusterLabel": { "alias": "clusterLabel"; "required": false; }; "clusterLabelColor": { "alias": "clusterLabelColor"; "required": false; }; "clusterBottomLabel": { "alias": "clusterBottomLabel"; "required": false; }; "clusterRingWidth": { "alias": "clusterRingWidth"; "required": false; }; "clusterBackground": { "alias": "clusterBackground"; "required": false; }; "clusterExpandOnClick": { "alias": "clusterExpandOnClick"; "required": false; }; "clusteringDistance": { "alias": "clusteringDistance"; "required": false; }; "colorMap": { "alias": "colorMap"; "required": false; }; "topoJSONLayer": { "alias": "topoJSONLayer"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisLeafletMapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisLeafletMapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisLeafletMapModule, [typeof VisLeafletMapComponent], never, [typeof VisLeafletMapComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisLeafletMapModule>;
+}
+
+declare class VisLeafletFlowMapComponent<PointDatum extends GenericDataRecord, FlowDatum extends GenericDataRecord> implements LeafletFlowMapConfigInterface<PointDatum, FlowDatum>, AfterViewInit {
+    containerRef: ElementRef;
+    /** Animation duration of the data update transitions in milliseconds. Default: `600` */
+    duration?: number;
+    /** Events configuration. An object containing properties in the following format:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[eventType]: callbackFunction
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    click: (d) => console.log("Clicked Area", d)
+     *  }
+     * }
+     * ``` */
+    events?: {
+        [selector: string]: {
+            [eventType in VisEventType]?: VisEventCallback;
+        };
+    };
+    /** You can set every SVG and HTML visualization object to have a custom DOM attributes, which is useful
+     * when you want to do unit or end-to-end testing. Attributes configuration object has the following structure:
+     *
+     * ```
+     * {
+     * \[selectorString]: {
+     *     \[attributeName]: attribute constant value or accessor function
+     *  }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \[Area.selectors.area]: {
+     *    "test-value": d => d.value
+     *  }
+     * }
+     * ``` */
+    attributes?: {
+        [selector: string]: {
+            [attr: string]: string | number | boolean | ((datum: any) => string | number | boolean);
+        };
+    };
+    /** Width in pixels or in CSS units. By default, the map will automatically fit to the size of the parent element. Default: `undefined`. */
+    width?: number | string;
+    /** Height in pixels or in CSS units. By default, the map will automatically fit to the size of the parent element. Default: `undefined`. */
+    height?: number | string;
+    /** Animation duration when the map is automatically panning or zooming to a point or area. Default: `1500` ms */
+    flyToDuration?: number;
+    /** Padding to be used when the `fitView` function has been called. The value is in pixels, [topLeft, bottomRight]. Default: `[150, 150]` */
+    fitViewPadding?: [number, number];
+    /** Animation duration for the `setZoom` function. Default: `800` ms */
+    zoomDuration?: number;
+    /** Default bounds that will be applied on the first map render if the bounds property is not set. Default: `undefined` */
+    initialBounds?: Bounds;
+    /** Force set map bounds on config and data updates. Default: `undefined` */
+    fitBoundsOnUpdate?: Bounds;
+    /** Fit the view to contain the data points on map initialization. Default: `true` */
+    fitViewOnInit?: boolean;
+    /** Fit the view to contain the data points on map config and data updates. Default: `false` */
+    fitViewOnUpdate?: boolean;
+    /** MapLibre `StyleSpecification` settings, or a URL to it. When renderer is set to`LeafletMapRenderer.Raster`, provide a template URL. Default: `undefined` */
+    style: MapLibreStyleSpecs | string | undefined;
+    /** MapLibre `StyleSpecification` settings or URL for dark theme. Default: `undefined` */
+    styleDarkTheme?: MapLibreStyleSpecs | string | undefined;
+    /** Tile server access token or API key. Default: `''` */
+    accessToken?: string;
+    /** Array of attribution labels. Default: `['<a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap contributors</a>']` */
+    attribution?: string[];
+    /** Rendering mode for map's tile layer. For raster files, use `LeafletMapRenderer.Raster`. Default: `LeafletMapRenderer.MapLibre` */
+    renderer?: LeafletMapRenderer | string;
+    /** Function to be called after the map's async initialization is done. Default: `undefined` */
+    onMapInitialized?: (() => void);
+    /** Map Move / Zoom unified callback function. Default: `undefined` */
+    onMapMoveZoom?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Move Start callback function. Default: `undefined` */
+    onMapMoveStart?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Move End callback function. Default: `undefined` */
+    onMapMoveEnd?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Zoom Start callback function. Default: `undefined` */
+    onMapZoomStart?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Zoom End callback function. Default: `undefined` */
+    onMapZoomEnd?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Map Zoom Click callback function. Default: `undefined` */
+    onMapClick?: (({ mapCenter, zoomLevel, bounds }: MapZoomState) => void);
+    /** Point longitude accessor function. Default: `d => d.longitude` */
+    pointLongitude?: NumericAccessor<PointDatum>;
+    /** Point latitude accessor function. Default: `d => d.latitude` */
+    pointLatitude?: NumericAccessor<PointDatum>;
+    /** Point id accessor function or constant value. Default: `d => d.id` */
+    pointId?: StringAccessor<PointDatum>;
+    /** Point shape accessor function or constant value. Default: `d => d.shape` */
+    pointShape?: GenericAccessor<LeafletMapPointShape | string, PointDatum>;
+    /** Point color accessor function or constant value. Default: `d => d.color` */
+    pointColor?: ColorAccessor<LeafletMapPointDatum<PointDatum>>;
+    /** Point radius accessor function or constant value. Default: `undefined` */
+    pointRadius?: NumericAccessor<LeafletMapPointDatum<PointDatum>>;
+    /** Point inner label accessor function. Default: `undefined` */
+    pointLabel?: StringAccessor<LeafletMapPointDatum<PointDatum>>;
+    /** Point inner label color accessor function or constant value.
+     * By default, the label color will be set, depending on the point brightness, either to
+     * `--vis-map-point-inner-label-text-color-light` or to `--vis-map-point-inner-label-text-color-dark` CSS variable.
+     * Default: `undefined` */
+    pointLabelColor?: StringAccessor<LeafletMapPointDatum<PointDatum>>;
+    /** Point bottom label accessor function. Default: `''` */
+    pointBottomLabel?: StringAccessor<LeafletMapPointDatum<PointDatum>>;
+    /** Point cursor value or accessor function. Default: `null` */
+    pointCursor?: StringAccessor<LeafletMapPointDatum<PointDatum>>;
+    /** The width of the ring when a point has a `LeafletMapPointShape.Ring` shape. Default: `1.25` */
+    pointRingWidth?: number;
+    /** Set selected point by its unique id. Default: `undefined` */
+    selectedPointId?: string;
+    /** Cluster color accessor function or constant value. Default: `undefined` */
+    clusterColor?: ColorAccessor<LeafletMapClusterDatum<PointDatum>>;
+    /** Cluster radius accessor function or constant value. Default: `undefined` */
+    clusterRadius?: NumericAccessor<LeafletMapClusterDatum<PointDatum>>;
+    /** Cluster inner label accessor function. Default: `d => d.point_count` */
+    clusterLabel?: StringAccessor<LeafletMapClusterDatum<PointDatum>>;
+    /** Cluster inner label color accessor function or constant value.
+     * By default, the label color will be set, depending on the point brightness, either to
+     * `--vis-map-cluster-inner-label-text-color-light` or to `--vis-map-cluster-inner-label-text-color-dark` CSS variable.
+     * Default: `undefined` */
+    clusterLabelColor?: StringAccessor<LeafletMapClusterDatum<PointDatum>>;
+    /** Cluster bottom label accessor function. Default: `''` */
+    clusterBottomLabel?: StringAccessor<LeafletMapClusterDatum<PointDatum>>;
+    /** The width of the cluster point ring. Default: `1.25` */
+    clusterRingWidth?: number;
+    /** When cluster is expanded, show a background circle to better separate points from the base map. Default: `true` */
+    clusterBackground?: boolean;
+    /** Defines whether the cluster should expand on click or not. Default: `true` */
+    clusterExpandOnClick?: boolean;
+    /** Clustering distance in pixels. This value will be passed to Supercluster as the `radius` property https://github.com/mapbox/supercluster. Default: `55` */
+    clusteringDistance?: number;
+    /** A single map point can have multiple properties displayed as a small pie chart (or a donut chart for a cluster of points).
+     * By setting the colorMap configuration you can specify data properties that should be mapped to various pie / donut segments.
+     *
+     * ```
+     * {
+     * \[key in keyof Datum]?: { color: string, className?: string }
+     * }
+     * ```
+     * e.g.:
+     * ```
+     * {
+     * \healthy: { color: 'green' },
+     * \warning: { color: 'orange' },
+     * \danger: { color: 'red' }
+     * }
+     * ```
+     * where every data point has the `healthy`, `warning` and `danger` numerical or boolean property. */
+    colorMap?: LeafletMapPointStyles<PointDatum>;
+    /** A TopoJSON Geometry layer to be displayed on top of the map. Supports fill and stroke */
+    topoJSONLayer?: {
+        sources: any;
+        featureName?: string;
+        fillProperty?: string;
+        strokeProperty?: string;
+        fillOpacity?: number;
+        strokeOpacity?: number;
+        strokeWidth?: number;
+    };
+    /** Tooltip component. Default: `undefined` */
+    tooltip?: Tooltip;
+    /** Alternative text description of the chart for accessibility purposes. It will be applied as an
+     * `aria-label` attribute to the div element containing your chart. Default: `undefined`. */
+    ariaLabel?: string | null | undefined;
+    /** Flow source point longitude accessor function or value. Default:.`f => f.sourceLongitude` */
+    sourceLongitude?: NumericAccessor<FlowDatum>;
+    /** Flow source point latitude accessor function or value. Default: `f => f.sourceLatitude` */
+    sourceLatitude?: NumericAccessor<FlowDatum>;
+    /** Flow target point longitude accessor function or value. Default: `f => f.targetLongitude` */
+    targetLongitude?: NumericAccessor<FlowDatum>;
+    /** Flow target point latitude accessor function or value. Default: `f => f.targetLatitude` */
+    targetLatitude?: NumericAccessor<FlowDatum>;
+    /** Flow source point radius accessor function or value. Default: `3` */
+    sourcePointRadius?: NumericAccessor<FlowDatum>;
+    /** Source point color accessor function or value. Default: `'#88919f'` */
+    sourcePointColor?: ColorAccessor<FlowDatum>;
+    /** Flow particle color accessor function or value. Default: `'#949dad'` */
+    flowParticleColor?: ColorAccessor<FlowDatum>;
+    /** Flow particle radius accessor function or value. Default: `1.1` */
+    flowParticleRadius?: NumericAccessor<FlowDatum>;
+    /** Flow particle speed accessor function or value. The unit is arbitrary, recommended range is 0 – 0.2. Default: `0.07` */
+    flowParticleSpeed?: NumericAccessor<FlowDatum>;
+    /** Flow particle density accessor function or value on the range of [0, 1]. Default: `0.6` */
+    flowParticleDensity?: NumericAccessor<FlowDatum>;
+    /** Flow source point click callback function. Default: `undefined` */
+    onSourcePointClick?: (f: FlowDatum, x: number, y: number, event: MouseEvent) => void;
+    /** Flow source point mouse over callback function. Default: `undefined` */
+    onSourcePointMouseEnter?: (f: FlowDatum, x: number, y: number, event: MouseEvent) => void;
+    /** Flow source point mouse leave callback function. Default: `undefined` */
+    onSourcePointMouseLeave?: (f: FlowDatum, event: MouseEvent) => void;
+    data: {
+        points: PointDatum[];
+        flows?: FlowDatum[];
+    };
+    component: LeafletFlowMap<PointDatum, FlowDatum> | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisLeafletFlowMapComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisLeafletFlowMapComponent<any, any>, "vis-leaflet-flow-map", never, { "duration": { "alias": "duration"; "required": false; }; "events": { "alias": "events"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "flyToDuration": { "alias": "flyToDuration"; "required": false; }; "fitViewPadding": { "alias": "fitViewPadding"; "required": false; }; "zoomDuration": { "alias": "zoomDuration"; "required": false; }; "initialBounds": { "alias": "initialBounds"; "required": false; }; "fitBoundsOnUpdate": { "alias": "fitBoundsOnUpdate"; "required": false; }; "fitViewOnInit": { "alias": "fitViewOnInit"; "required": false; }; "fitViewOnUpdate": { "alias": "fitViewOnUpdate"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleDarkTheme": { "alias": "styleDarkTheme"; "required": false; }; "accessToken": { "alias": "accessToken"; "required": false; }; "attribution": { "alias": "attribution"; "required": false; }; "renderer": { "alias": "renderer"; "required": false; }; "onMapInitialized": { "alias": "onMapInitialized"; "required": false; }; "onMapMoveZoom": { "alias": "onMapMoveZoom"; "required": false; }; "onMapMoveStart": { "alias": "onMapMoveStart"; "required": false; }; "onMapMoveEnd": { "alias": "onMapMoveEnd"; "required": false; }; "onMapZoomStart": { "alias": "onMapZoomStart"; "required": false; }; "onMapZoomEnd": { "alias": "onMapZoomEnd"; "required": false; }; "onMapClick": { "alias": "onMapClick"; "required": false; }; "pointLongitude": { "alias": "pointLongitude"; "required": false; }; "pointLatitude": { "alias": "pointLatitude"; "required": false; }; "pointId": { "alias": "pointId"; "required": false; }; "pointShape": { "alias": "pointShape"; "required": false; }; "pointColor": { "alias": "pointColor"; "required": false; }; "pointRadius": { "alias": "pointRadius"; "required": false; }; "pointLabel": { "alias": "pointLabel"; "required": false; }; "pointLabelColor": { "alias": "pointLabelColor"; "required": false; }; "pointBottomLabel": { "alias": "pointBottomLabel"; "required": false; }; "pointCursor": { "alias": "pointCursor"; "required": false; }; "pointRingWidth": { "alias": "pointRingWidth"; "required": false; }; "selectedPointId": { "alias": "selectedPointId"; "required": false; }; "clusterColor": { "alias": "clusterColor"; "required": false; }; "clusterRadius": { "alias": "clusterRadius"; "required": false; }; "clusterLabel": { "alias": "clusterLabel"; "required": false; }; "clusterLabelColor": { "alias": "clusterLabelColor"; "required": false; }; "clusterBottomLabel": { "alias": "clusterBottomLabel"; "required": false; }; "clusterRingWidth": { "alias": "clusterRingWidth"; "required": false; }; "clusterBackground": { "alias": "clusterBackground"; "required": false; }; "clusterExpandOnClick": { "alias": "clusterExpandOnClick"; "required": false; }; "clusteringDistance": { "alias": "clusteringDistance"; "required": false; }; "colorMap": { "alias": "colorMap"; "required": false; }; "topoJSONLayer": { "alias": "topoJSONLayer"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "sourceLongitude": { "alias": "sourceLongitude"; "required": false; }; "sourceLatitude": { "alias": "sourceLatitude"; "required": false; }; "targetLongitude": { "alias": "targetLongitude"; "required": false; }; "targetLatitude": { "alias": "targetLatitude"; "required": false; }; "sourcePointRadius": { "alias": "sourcePointRadius"; "required": false; }; "sourcePointColor": { "alias": "sourcePointColor"; "required": false; }; "flowParticleColor": { "alias": "flowParticleColor"; "required": false; }; "flowParticleRadius": { "alias": "flowParticleRadius"; "required": false; }; "flowParticleSpeed": { "alias": "flowParticleSpeed"; "required": false; }; "flowParticleDensity": { "alias": "flowParticleDensity"; "required": false; }; "onSourcePointClick": { "alias": "onSourcePointClick"; "required": false; }; "onSourcePointMouseEnter": { "alias": "onSourcePointMouseEnter"; "required": false; }; "onSourcePointMouseLeave": { "alias": "onSourcePointMouseLeave"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisLeafletFlowMapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisLeafletFlowMapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisLeafletFlowMapModule, [typeof VisLeafletFlowMapComponent], never, [typeof VisLeafletFlowMapComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisLeafletFlowMapModule>;
+}
+
+declare class VisBulletLegendComponent implements BulletLegendConfigInterface, AfterViewInit {
+    containerRef: ElementRef;
+    /** Legend items. Array of `BulletLegendItemInterface`:
+     * ```
+     * {
+     *  name: string | number;
+     *  color?: string;
+     *  shape?: BulletShape;
+     *  inactive?: boolean;
+     *  hidden?: boolean;
+     *  pointer?: boolean;
+     *  colorKey?: string;
+     * }
+     * ```
+     * Default: `[]` */
+    items: BulletLegendItemInterface[];
+    /** Apply a specific class to the labels. Default: `''` */
+    labelClassName?: string;
+    /** Callback function for the legend item click. Default: `undefined` */
+    onLegendItemClick?: ((d: BulletLegendItemInterface, i: number) => void);
+    /** Label text (<span> element) font-size CSS. Default: `null` */
+    labelFontSize?: string | null;
+    /** Label text (<span> element) max-width CSS property. Default: `null` */
+    labelMaxWidth?: string | null;
+    /** Bullet shape size, mapped to the width and height CSS properties. Default: `null` */
+    bulletSize?: string | null;
+    /** Spacing between multiple bullet symbols in pixels. Default: `4` */
+    bulletSpacing?: number;
+    /** Bullet shape enum value or accessor function. Default: `d => d.shape ?? BulletShape.Circle */
+    bulletShape?: GenericAccessor<BulletShape, BulletLegendItemInterface>;
+    /** Legend orientation. When set to `BulletLegendOrientation.Vertical`, each legend item will
+     * start on a new line. Default: `BulletLegendOrientation.Horizontal` */
+    orientation?: BulletLegendOrientation | string;
+    /** Color function. Default: `undefined` */
+    colorFunction?: ColorFunction;
+    component: BulletLegend | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBulletLegendComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisBulletLegendComponent, "vis-bullet-legend", never, { "items": { "alias": "items"; "required": false; }; "labelClassName": { "alias": "labelClassName"; "required": false; }; "onLegendItemClick": { "alias": "onLegendItemClick"; "required": false; }; "labelFontSize": { "alias": "labelFontSize"; "required": false; }; "labelMaxWidth": { "alias": "labelMaxWidth"; "required": false; }; "bulletSize": { "alias": "bulletSize"; "required": false; }; "bulletSpacing": { "alias": "bulletSpacing"; "required": false; }; "bulletShape": { "alias": "bulletShape"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "colorFunction": { "alias": "colorFunction"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisBulletLegendModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisBulletLegendModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisBulletLegendModule, [typeof VisBulletLegendComponent], never, [typeof VisBulletLegendComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisBulletLegendModule>;
+}
+
+declare class VisFlowLegendComponent implements FlowLegendConfigInterface, AfterViewInit {
+    containerRef: ElementRef;
+    /** Margin around the legend. Default: `undefined` */
+    margin?: Spacing;
+    /** Custom width of the component.  Default: `undefined` */
+    customWidth?: number;
+    /** Legend items array as string[]. Default: `[]` */
+    items?: string[];
+    /** Spacing between legend items and the arrows in pixels. Default: `undefined` (fit to container width) */
+    spacing?: number;
+    /** Color of the flow line. Default: `undefined` */
+    lineColor?: string;
+    /** Color of the flow label. Default: `undefined` */
+    labelColor?: string;
+    /** Font size of flow labels in pixels. Default: `12` */
+    labelFontSize?: number;
+    /** Arrow symbol. Default: `'▶'` */
+    arrowSymbol?: string;
+    /** Color of the arrow. Default: `undefined` */
+    arrowColor?: string;
+    /** Offset of the arrow symbol vertically in pixels. Default: `undefined` */
+    arrowSymbolYOffset?: number;
+    /** Callback function for the legend item click. Default: `undefined` */
+    onLegendItemClick?: ((label?: string, i?: number) => void);
+    component: FlowLegend | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisFlowLegendComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisFlowLegendComponent, "vis-flow-legend", never, { "margin": { "alias": "margin"; "required": false; }; "customWidth": { "alias": "customWidth"; "required": false; }; "items": { "alias": "items"; "required": false; }; "spacing": { "alias": "spacing"; "required": false; }; "lineColor": { "alias": "lineColor"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "labelFontSize": { "alias": "labelFontSize"; "required": false; }; "arrowSymbol": { "alias": "arrowSymbol"; "required": false; }; "arrowColor": { "alias": "arrowColor"; "required": false; }; "arrowSymbolYOffset": { "alias": "arrowSymbolYOffset"; "required": false; }; "onLegendItemClick": { "alias": "onLegendItemClick"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisFlowLegendModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisFlowLegendModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisFlowLegendModule, [typeof VisFlowLegendComponent], never, [typeof VisFlowLegendComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisFlowLegendModule>;
+}
+
+declare class VisRollingPinLegendComponent implements RollingPinLegendConfigInterface, AfterViewInit {
+    containerRef: ElementRef;
+    /** Rects forming a legend. Array of `string`, representing colors.
+     *
+     * Default: `[]` */
+    rects: RollingPinLegendItem[];
+    /** Label on the left side of the legend. Default: `undefined` */
+    leftLabelText?: string;
+    /** Label on the right side of the legend. Default: `undefined` */
+    rightLabelText?: string;
+    /** Apply a specific class to the labels. Default: `''` */
+    labelClassName?: string;
+    /** Label text (<span> element) font-size CSS. Default: `null` */
+    labelFontSize?: string | null;
+    component: RollingPinLegend | undefined;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private getConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisRollingPinLegendComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisRollingPinLegendComponent, "vis-rolling-pin-legend", never, { "rects": { "alias": "rects"; "required": false; }; "leftLabelText": { "alias": "leftLabelText"; "required": false; }; "rightLabelText": { "alias": "rightLabelText"; "required": false; }; "labelClassName": { "alias": "labelClassName"; "required": false; }; "labelFontSize": { "alias": "labelFontSize"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class VisRollingPinLegendModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisRollingPinLegendModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisRollingPinLegendModule, [typeof VisRollingPinLegendComponent], never, [typeof VisRollingPinLegendComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisRollingPinLegendModule>;
+}
+
+declare class VisTooltipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisTooltipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisTooltipModule, [typeof VisTooltipComponent], never, [typeof VisTooltipComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisTooltipModule>;
+}
+
+export { VisAnnotationsComponent, VisAnnotationsModule, VisAreaComponent, VisAreaModule, VisAxisComponent, VisAxisModule, VisBoxplotComponent, VisBoxplotModule, VisBrushComponent, VisBrushModule, VisBulletLegendComponent, VisBulletLegendModule, VisChordDiagramComponent, VisChordDiagramModule, VisCoreComponent, VisCrosshairComponent, VisCrosshairModule, VisDonutComponent, VisDonutModule, VisFlowLegendComponent, VisFlowLegendModule, VisFreeBrushComponent, VisFreeBrushModule, VisGenericComponent, VisGraphComponent, VisGraphModule, VisGroupedBarComponent, VisGroupedBarModule, VisHeatmapComponent, VisHeatmapModule, VisLeafletFlowMapComponent, VisLeafletFlowMapModule, VisLeafletMapComponent, VisLeafletMapModule, VisLineComponent, VisLineModule, VisNestedDonutComponent, VisNestedDonutModule, VisPlotbandComponent, VisPlotbandModule, VisPlotlineComponent, VisPlotlineModule, VisRadialBarComponent, VisRadialBarModule, VisRollingPinLegendComponent, VisRollingPinLegendModule, VisSankeyComponent, VisSankeyModule, VisScatterComponent, VisScatterModule, VisSingleContainerComponent, VisSingleContainerModule, VisStackedBarComponent, VisStackedBarModule, VisTimelineComponent, VisTimelineModule, VisTooltipComponent, VisTooltipModule, VisTopoJSONMapComponent, VisTopoJSONMapModule, VisTreemapComponent, VisTreemapModule, VisXYComponent, VisXYContainerComponent, VisXYContainerModule, VisXYLabelsComponent, VisXYLabelsModule };