@visuallyjs/browser-ui 1.0.0

package/types/browser-ui/svg-element-connector.d.ts

@@ -0,0 +1,16 @@
+import { BrowserUI } from "./browser-visuallyjs-instance";
+import { PaintStyle, Connector, Connection } from "../ui";
+export declare function paintSvgConnector(instance: BrowserUI, connection: Connection<any>, paintStyle: PaintStyle): void;
+/**
+ * @internal
+ */
+export interface SvgConnector extends Connector {
+    canvas: SVGElement;
+    path?: SVGElement;
+    bgPath?: SVGElement;
+    classesToAddWhenRendered?: Array<string>;
+    sourceZone: SVGElement;
+    targetZone: SVGElement;
+    gradient?: SVGLinearGradientElement;
+}
+export declare function getConnectorElement(instance: BrowserUI, connection: Connection<any>): SVGElement;

package/types/browser-ui/svg-element-overlay.d.ts

@@ -0,0 +1,55 @@
+import { LabelOverlay, PaintStyle, Overlay, OverlayPaintParams, SimpleShapeOverlay } from "../ui";
+import { Extents, PointXY } from "../core";
+import { BrowserUI } from "./browser-visuallyjs-instance";
+/**
+ * @internal
+ */
+export interface SvgOverlayPaintParams<EL> extends Extents, PaintStyle, OverlayPaintParams {
+}
+export interface SvgSimpleShapeOverlayPaintParams<EL> extends SvgOverlayPaintParams<EL> {
+    paintStyle: {
+        stroke: string;
+        fill: string;
+        "stroke-width": number;
+    };
+    atts: Array<Record<string, any>>;
+}
+/**
+ * @internal
+ */
+export interface SVGLabelOverlayPaintParams extends OverlayPaintParams {
+    d: {
+        loc: PointXY;
+    };
+}
+/**
+ * Paints an overlay like arrow, dot, circle etc.
+ * @internal
+ * @param o
+ * @param params
+ */
+export declare function paintSimpleShapeOverlay<EL>(instance: BrowserUI, o: SimpleShapeOverlay<EL>, params: SvgSimpleShapeOverlayPaintParams<EL>, parentOrigin: PointXY): void;
+/**
+ * @internal
+ */
+export declare function ensureSVGContentElements(instance: BrowserUI, o: SimpleShapeOverlay<any>): Array<SVGElement>;
+/**
+ * @internal
+ */
+export declare function ensureSVGLabelElements(instance: BrowserUI, o: SVGLabelOverlay<any>): Array<SVGElement>;
+/**
+ * @internal
+ */
+export declare function paintSVGLabelOverlay(instance: BrowserUI, o: SVGLabelOverlay<any>, params: SVGLabelOverlayPaintParams, parentOrigin: PointXY): void;
+/**
+ * @internal
+ */
+export declare function destroySVGOverlay(o: SVGElementOverlay<any>, force?: boolean): void;
+export declare abstract class SVGElementOverlay<EL> extends Overlay<EL> {
+    contentElements: Array<SVGElement>;
+    backgroundContentElements: Array<SVGElement>;
+}
+export interface SVGLabelOverlay<EL> extends SVGElementOverlay<EL>, LabelOverlay<EL> {
+    textElement: SVGTextElement;
+    bgElement: SVGRectElement;
+}

package/types/browser-ui/svg-export/definitions.d.ts

@@ -0,0 +1,153 @@
+import { PointXY } from "../../core";
+/**
+ * Options for an SVG export.
+ */
+export interface SvgExportOptions {
+    /**
+     * Optional margin to set around the content. Defaults to 50px in x and y
+     */
+    margins?: PointXY;
+    /**
+     * Whether or not to show the grid in the export (the UI itself has to be showing a grid for the export to have one). Defaults to true.
+     */
+    showGrid?: boolean;
+    /**
+     * Optional width to set on the SVG output. Defaults to unset, meaning the SVG will adapt to whatever its container's width is.
+     */
+    width?: number;
+    /**
+     * Optional height to set on the SVG output. Defaults to unset, meaning the SVG will adapt to whatever its container's height is.
+     */
+    height?: number;
+    /**
+     * Optional style to set in a `style` element in the SVG header. You can provide the CSS for the style element as a string, or you can provide a JS object.
+     */
+    style?: string | Record<string, any>;
+}
+/**
+ * Options for the {@link SvgExportUI}
+ * @group Components
+ * @category SVG/PNG/JPG Export
+ */
+export interface SvgExportUIOptions extends SvgExportOptions {
+    /**
+     * Optional filename to use - defaults to `visuallyjs-export`.  You do not need to provide the extension.
+     */
+    filename?: string;
+    /**
+     * Optional label to use on the download button. Defaults to "Download".
+     */
+    downloadButtonLabel?: string;
+}
+/**
+ * Options for an {@link ImageExporter}
+ * @group Components
+ * @category SVG/PNG/JPG Export
+ */
+export interface ImageExportOptions extends SvgExportOptions {
+    /**
+     * Content type for the export. Defaults to `image/png`. Most modern browsers also support `image/jpeg`.
+     */
+    type?: string;
+    /**
+     * Optional quality of the resulting image - only used for jpeg.  Defaults to 1.0.
+     */
+    quality?: number;
+    /**
+     * Optional width for the export. The exported image's aspect ratio will always be honoured so if you provide both this and `height`, height will be ignored. If you don't provide this the natural width of the underlying SVG will be used.
+     */
+    width?: number;
+    /**
+     * Optional height for the export. The exported image's aspect ratio will always be honoured so if you provide both this and `width`, this will be ignored. If you don't provide this the natural height of the underlying SVG will be used.
+     */
+    height?: number;
+}
+/**
+ * Options for an {@link ImageExportUI}
+ * @group Components
+ * @category SVG/PNG/JPG Export
+ */
+export interface ImageExportUIOptions extends ImageExportOptions {
+    /**
+     * Optional filename to use - defaults to `visuallyjs-export`.  You do not need to provide the extension.
+     */
+    filename?: string;
+    /**
+     * Optional label to use on the download button. Defaults to "Download".
+     */
+    downloadButtonLabel?: string;
+    /**
+     * Optional function to invoke after the UI has been displayed.
+     * @param el
+     */
+    onShow?: (el: Element, width: number, height: number, url: string) => any;
+    /**
+     * Optional list of dimensions
+     */
+    dimensions?: Array<{
+        width?: number;
+        height?: number;
+    }>;
+    /**
+     * Optional function to invoke when the user changes the selected dimensions.
+     * @param width
+     * @param height
+     * @param url
+     */
+    onDimensionsChanged?: (width: number, height: number, url: string) => any;
+}
+/**
+ * Defines a function callback from an image exporter.
+ * @group Components
+ * @category SVG/PNG/JPG Export
+ */
+export type ImageReadyFunction = (result: {
+    url: string;
+    width: number;
+    height: number;
+    contentType: string;
+    element: SVGElement;
+}) => any;
+/**
+ * The modal backing element for SVG/PNG/JPG export dialog
+ * @cssClass
+ * @context svg-png-jpg-export
+ */
+export declare const CLASS_EXPORT_UNDERLAY = "vjs-export-underlay";
+/**
+ * Content element for SVG/PNG/JPG export dialog
+ * @cssClass
+ * @context svg-png-jpg-export
+ */
+export declare const CLASS_EXPORT_OVERLAY = "vjs-export-overlay";
+/**
+ * Class assigned to the cancel button on an export dialog
+ * @cssClass
+ * @context svg-png-jpg-export
+ */
+export declare const CLASS_EXPORT_CANCEL = "vjs-export-cancel";
+/**
+ * Class assigned to the dimensions drop down in an export dialog
+ * @cssClass
+ * @context svg-png-jpg-export
+ */
+export declare const CLASS_EXPORT_DIMENSIONS = "vjs-export-dimensions";
+/**
+ * Class assigned to the element containing buttons and dimensions picker on an export dialog
+ * @cssClass
+ * @context svg-png-jpg-export
+ */
+export declare const CLASS_EXPORT_DOWNLOAD_TOOLS = "vjs-export-download-tools";
+export declare const DEFAULT_EXPORT_FILENAME = "visuallyjs-export";
+export declare const DEFAULT_DOWNLOAD_BUTTON_LABEL = "Download";
+export declare const CONTENT_TYPES: {
+    png: string;
+    svg: string;
+    jpeg: string;
+};
+/** @internal */
+export declare const TYPE_SVG = "svg";
+/** @internal */
+export declare const TYPE_PNG = "png";
+/** @internal */
+export declare const TYPE_JPG = "jpg";

package/types/browser-ui/svg-export/image-export-ui.d.ts

@@ -0,0 +1,20 @@
+import { ImageExportUIOptions } from "./definitions";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+export declare class ImageExportUI {
+    private ui;
+    underlay: HTMLElement;
+    overlay: HTMLElement;
+    closeButton: HTMLElement;
+    constructor(ui: BrowserUI);
+    private _cancel;
+    private _export;
+    export(options?: ImageExportUIOptions): void;
+    /**
+     * @internal
+     * @param options
+     * @param onready
+     * @param width
+     * @private
+     */
+    private _actuallyDoExport;
+}

package/types/browser-ui/svg-export/image-exporter.d.ts

@@ -0,0 +1,15 @@
+import { ImageExportOptions, ImageReadyFunction } from "./definitions";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+import { RectangleXY } from "../../core";
+/**
+ * Export the given UI as an image.
+ * @param ui
+ * @param options
+ * @param onready
+ */
+export declare function exportImage(ui: BrowserUI, options: ImageExportOptions, onready: ImageReadyFunction): void;
+export declare function $doImageExport(svgElementInfo: {
+    element: SVGElement;
+    extents: RectangleXY;
+    svg: string;
+}, options: ImageExportOptions, onready: ImageReadyFunction): void;

package/types/browser-ui/svg-export/index.d.ts

@@ -0,0 +1,6 @@
+export * from './definitions';
+export * from './svg-exporter';
+export * from './util';
+export * from './image-exporter';
+export * from './svg-export-ui';
+export * from './image-export-ui';

package/types/browser-ui/svg-export/svg-export-ui.d.ts

@@ -0,0 +1,11 @@
+import { SvgExportUIOptions } from "./definitions";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+export declare class SvgExportUI {
+    private ui;
+    underlay: HTMLElement;
+    overlay: HTMLElement;
+    closeButton: HTMLElement;
+    constructor(ui: BrowserUI);
+    private _cancel;
+    export(options?: SvgExportUIOptions): void;
+}

package/types/browser-ui/svg-export/svg-exporter.d.ts

@@ -0,0 +1,8 @@
+import { RectangleXY } from "../../core";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+import { SvgExportOptions } from "./definitions";
+export declare function exportSvg(ui: BrowserUI, options?: SvgExportOptions): {
+    element: SVGElement;
+    extents: RectangleXY;
+    svg: string;
+};

package/types/browser-ui/svg-export/util.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @internal
+ * @param str
+ */
+export declare function base64Encode(str: string): string;
+/**
+ * Base 64 encode the contents of some SVG element.
+ * @param el
+ * @internal
+ */
+export declare function base64EncodeSvgElement(el: SVGElement): string;
+/**
+ * Base 64 encode some SVG element and return the whole thing as a data url
+ * @param el SVG element
+ * @internal
+ */
+export declare function svgElementToDataUrl(el: SVGElement): string;
+/**
+ * Add a prefix to some base 64 encoded SVG to turn it into a data url.
+ * @param encodedSvg
+ * @internal
+ */
+export declare function encodedSvgToDataUrl(encodedSvg: string): string;

package/types/browser-ui/svg-util.d.ts

@@ -0,0 +1,27 @@
+import { BrowserElement } from "./util";
+import { GradientSpec } from "../core";
+import { SvgConnector } from "./svg-element-connector";
+export type ElementAttributes = Record<string, string | number | object>;
+export declare function $attr(node: BrowserElement, attributes: ElementAttributes): void;
+export declare function $svgNode(name: string, attributes?: ElementAttributes, style?: Record<string, any>, clazz?: string): SVGElement;
+/**
+ * Creates a lineargradient from the given spec.
+ * @param x1
+ * @param x2
+ * @param gradient
+ * @internal
+ */
+export declare function $createGradient(x1: number, x2: number, gradient: GradientSpec): {
+    id: string;
+    g: SVGLinearGradientElement;
+};
+export declare function _applyStyles(connector: SvgConnector, node: SVGElement, style: any, ignoreGradient: boolean): void;
+export declare function $appendAtIndex(svg: SVGElement, path: SVGElement, idx: number): void;
+/**
+ * Converts the given text element's child content from a string into a set of spans, by splitting the string on whitespace (and newline).
+ * @param textElement
+ * @param text
+ * @param maxWidth
+ * @internal
+ */
+export declare function convertToMultilineText(textElement: SVGTextElement, text: string, maxWidth: number): SVGTextElement;

package/types/browser-ui/templating/browser-ui-recado.d.ts

@@ -0,0 +1,48 @@
+import { CommentFacade, ElementFacade, FragmentFacade, RecadoOptions, TemplateResolver, TextNodeFacade, Recado } from "../../core";
+/**
+ * Default implementation of TemplateResolver for use in browsers.
+ * @param tid
+ * @internal
+ */
+export declare function InBrowserTemplateResolver(tid: string): string;
+/**
+ * Implementation of Recado for use with the browser-ui package. Creates DOM elements
+ * and fragments.
+ * @internal
+ */
+export declare class BrowserUiRecado extends Recado {
+    constructor(options: RecadoOptions);
+    /**
+     * create an element with the given tag name
+     * @internal
+     * @param tag
+     */
+    ce(tag: string): ElementFacade;
+    /**
+     * create a fragment
+     * @internal
+     */
+    cf(): FragmentFacade;
+    /**
+     * create a text node
+     * @internal
+     * @param value
+     */
+    ctn(value: string): TextNodeFacade;
+    /**
+     * create a comment.
+     * @param content
+     */
+    cc(content: string): CommentFacade;
+    /**
+     * @internal
+     */
+    _getDefaultTemplateResolver(): TemplateResolver;
+    removeElement(e: ElementFacade): void;
+    removeTextNode(e: TextNodeFacade): void;
+}
+/**
+ * @internal
+ * @param options
+ */
+export declare function newRecadoInstance(options?: RecadoOptions): Recado;

package/types/browser-ui/templating/custom-tag-definition.d.ts

@@ -0,0 +1,32 @@
+import { Surface } from "../surface-renderer";
+import { Recado, Vertex } from "../../core";
+export interface CustomTagDefinition {
+    /**
+     * Template for the tag. Must have a single root element.
+     */
+    template: string;
+    /**
+     * This function is called whenever the tag is encountered during rendering. `el` is the root element for a fragment rendered
+     * using the definition's `template`. Note that at the time this is called, `el` is not yet in the DOM.
+     * @param el
+     * @param data
+     * @param instance
+     * @param surface
+     * @param vertex
+     */
+    rendered: (el: Element, data: any, instance: Recado, ui: Surface, vertex: Vertex) => any;
+    /**
+     * This function is called whenever the tag is updated during an update call.
+     * @param el
+     * @param data
+     * @param instance
+     * @param surface
+     * @param vertex
+     */
+    updated: (el: Element, data: any, instance: Recado, ui: Surface, vertex: Vertex) => any;
+    /**
+     * If set to true, the element rendered for this tag is removed from the DOM. The Toolkit uses this capability internally
+     * to add endpoints to the DOM.
+     */
+    remove?: boolean;
+}

package/types/browser-ui/templating/index.d.ts

@@ -0,0 +1,11 @@
+import { RecadoTemplateRendererOptions } from "./recado-template-renderer";
+import { TemplateRenderer } from "../browser-ui";
+export * from './browser-ui-recado';
+export * from './recado-template-renderer';
+export * from './custom-tag-definition';
+/**
+ * Create a template renderer using the template-2 package.
+ * @param params
+ * @internal
+ */
+export declare function newTemplates2Renderer(defaultTemplate: string, useSvgContainer: boolean, params?: RecadoTemplateRendererOptions): TemplateRenderer<Element>;

package/types/browser-ui/templating/recado-template-renderer.d.ts

@@ -0,0 +1,69 @@
+import { Recado, ElementFacade, RecadoOptions, ObjectData, Vertex, DataSource } from "../../core";
+import { TemplateRenderer } from "../browser-ui";
+import { BrowserElement } from "../util";
+import { BrowserUI } from "../browser-visuallyjs-instance";
+import { VertexMapping } from "../../ui";
+/**
+ * The default template to use for a node when the container is an HTML element.
+ * @internal
+ */
+export declare const _defaultNodeHtmlTemplate: string;
+export declare const _defaultPortHtmlTemplate: string;
+/**
+ * The default template to use for a group when the container is an HTML element.
+ * @internal
+ */
+export declare const _defaultGroupHtmlTemplate: string;
+/**
+ * The default template to use for a node when the container is an SVG element.
+ * @internal
+ */
+export declare const _defaultNodeSvgTemplate: string;
+export declare const _defaultPortSvgTemplate: string;
+/**
+ * The default template to use for a node when the container is an SVG element.
+ * @internal
+ */
+export declare const _defaultGroupSvgTemplate: string;
+export declare const _getDefaultTemplate: (type: "html" | "svg", id: string) => string | null;
+/**
+ * Options for the recado template engine. Extends RecadoOptions to take optional `tags` map.
+ * @internal
+ */
+export interface RecadoTemplateRendererOptions extends RecadoOptions {
+    tags?: Record<string, CustomTagRegistration>;
+}
+/**
+ * A registration for a custom tag.
+ * @group Components
+ * @category Templating
+ */
+export interface CustomTagRegistration {
+    template: string;
+    rendered?: (el: Element, data: any, instance: Recado, surface: BrowserUI, obj: Vertex) => any;
+    updated?: (el: Element, data: any, instance: Recado, surface: BrowserUI, obj: Vertex) => any;
+    mounted?: (el: BrowserElement, data: any, recado: Recado, parent: ElementFacade) => any;
+    fragments?: Record<string, Record<string, string>>;
+}
+/**
+ * Template renderer that uses the Toolkit's templates-2 engine.
+ * @internal
+ */
+export declare class RecadoTemplateRenderer implements TemplateRenderer<BrowserElement> {
+    private recado;
+    asynchronous: boolean;
+    reactive: boolean;
+    usesWrapperElement: boolean;
+    uicore: BrowserUI;
+    currentVertex: Vertex;
+    constructor(defaultTemplate: string, templateResolver: (id: string) => string, params?: RecadoTemplateRendererOptions);
+    render(templateId: string, data: ObjectData, dataSource: DataSource, objectType: string, renderer: BrowserUI, def: VertexMapping<any, BrowserElement>, obj: Vertex, eventInfo: any): void;
+    rerender(templateId: string, data: ObjectData, dataSource: DataSource, objectType: string, renderer: BrowserUI, def: any, obj: Vertex, eventInfo: any, originalElement: BrowserElement): void;
+    private _cleanup;
+    cleanupVertex(objId: string, el: BrowserElement): void;
+    cleanupPort(objId: string, el: BrowserElement): void;
+    addTemplate(id: string, content: string): void;
+    registerTag(tagName: string, options: CustomTagRegistration): void;
+    update(el: BrowserElement, data: Record<string, any>, v: Vertex, renderer: BrowserUI): void;
+    removeElement(el: HTMLElement | SVGElement): void;
+}

package/types/browser-ui/ui-path.d.ts

@@ -0,0 +1,57 @@
+import { Path } from "../core";
+import { BrowserUI } from "./browser-visuallyjs-instance";
+/**
+ * A wrapper around the Toolkit's path object, which offers a few DOM specific methods.
+ */
+export declare class UIPath {
+    path: Path;
+    private ui;
+    /**
+     * @param path Underlying path object.
+     * @param ui The UI instance that constructed this path.
+     */
+    constructor(path: Path, ui: BrowserUI);
+    /**
+     * Gets the count of vertices in the path.
+     */
+    getVertexCount(): number;
+    /**
+     * Gets the total number of edges in the path.
+     */
+    getEdgeCount(): number;
+    /**
+     * Sets the visible state of all vertices and edges in the path
+     * @param val
+     */
+    setVisible(val: boolean): void;
+    /**
+     * Adds a CSS class to the elements representing the vertices in the path
+     * @param clazz
+     */
+    addVertexClass(clazz: string): void;
+    /**
+     * Removes a CSS class from the elements representing the vertices in the path
+     * @param clazz
+     */
+    removeVertexClass(clazz: string): void;
+    /**
+     * Adds a CSS class to the elements representing the edges in the path
+     * @param clazz
+     */
+    addEdgeClass(clazz: string): void;
+    /**
+     * Removes a CSS class from the elements representing the edges in the path
+     * @param clazz
+     */
+    removeEdgeClass(clazz: string): void;
+    /**
+     * Adds a CSS class to the elements representing the vertices and edges in the path
+     * @param clazz
+     */
+    addClass(clazz: string): void;
+    /**
+     * Removes a CSS class from the elements representing the vertices and edges in the path
+     * @param clazz
+     */
+    removeClass(clazz: string): void;
+}

package/types/browser-ui/util.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Abstraction of HTML/SVG element. Used extensively internally, and by a number of methods in the public API.
+ */
+export type BrowserElement = HTMLElement | SVGElement;

package/types/browser-ui/wheel-listener.d.ts

@@ -0,0 +1,2 @@
+export declare function addWheelListener(el: any, callback: Function, ignoreTouchWheelEvents?: boolean, requireMetaKey?: boolean): (e: any) => void;
+export declare function removeWheelListener(el: any, callback: Function): void;

package/types/charts/area/area-chart.d.ts

@@ -0,0 +1,85 @@
+import { ChartDimensions } from "../definitions";
+import { ChartSVGElement } from "../util";
+import { CategoryVsAxisPlot, XYPlotOptions } from "../plot";
+import { BrowserElement } from "../../browser-ui";
+import { PointXY } from "../../core";
+import { StackablePlotOptions } from "../bar-and-column/bar-plot";
+import { DomainExtentMap } from "../domain_scale_utilities";
+import { CategoryValueChart, CategoryValueChartOptions } from "../category-value-chart";
+import { RealisedSeries } from "../series";
+/**
+ * Options for an area chart
+ * @group Charts
+ * @category Area Chart
+ */
+export interface AreaChartOptions extends Omit<CategoryValueChartOptions, "plots"> {
+    /**
+     * If true, draw the line as a series of bezier splines, which makes for a smooth line. Defaults to false.
+     */
+    spline?: boolean;
+    /**
+     * Options for the area plot.
+     */
+    plotOptions?: AreaPlotOptions;
+}
+/**
+ * Area charts are a variant of line charts used to visualize volumes. Set `inverted:true` on your AreaChart options if you wish to use the Y axis as the value axis.
+ * @group Charts
+ * @category Area Chart
+ */
+export declare class AreaChart extends CategoryValueChart {
+    constructor(container: BrowserElement, options: AreaChartOptions);
+}
+/**
+ * Options for an area chart plot
+ * @group Charts
+ * @category Area Chart
+ */
+export interface AreaPlotOptions extends XYPlotOptions, StackablePlotOptions {
+    /**
+     * Configuration of the marker dot
+     */
+    marker?: {
+        /**
+         * Whether or not the marker should be enabled. Defaults to true.
+         */
+        enabled?: boolean;
+        /**
+         * Size (diameter) of the marker dot.
+         */
+        size?: number;
+    };
+}
+/**
+ * Used by Area chart
+ * @group Charts
+ * @category Area Chart
+ */
+export declare class AreaPlot extends CategoryVsAxisPlot {
+    chart: CategoryValueChart;
+    static type: string;
+    stacked: boolean;
+    private _markerEnabled;
+    private _markerSize;
+    private _perimeterMarker;
+    private _dataPoints;
+    constructor(chart: CategoryValueChart, options: AreaPlotOptions);
+    /**
+     * Provide domain extents for this plot so XYChart can build scales by domain.
+     *
+     * Area plots behave like line plots for extents:
+     * - value domain is "y" when inverted, otherwise "x"
+     * - if stacked, provide an additional stacked domain ("yStacked"/"xStacked")
+     *
+     * @internal
+     */
+    getDomainExtents(): DomainExtentMap;
+    $getValueLocation(category: number, series: number, dim: ChartDimensions): number;
+    $draw(svgRoot: ChartSVGElement, dim: ChartDimensions, minPlottableValue: number, maxPlottableValue: number): void;
+    showMarker(categoryIndex: number, dim: ChartDimensions, focusedSeries: number | null): {
+        loc: PointXY;
+        series: RealisedSeries;
+        seriesIndex: number;
+    } | null;
+    hideMarker(): void;
+}

package/types/charts/area/index.d.ts

@@ -0,0 +1 @@
+export * from "./area-chart";