@syncfusion/ej2-charts
Version:
Feature-rich chart control with built-in support for over 25 chart types, technical indictors, trendline, zooming, tooltip, selection, crosshair and trackball.
897 lines (896 loc) • 29.1 kB
TypeScript
import { Component, Internationalization, INotifyPropertyChanged, ModuleDeclaration, EmitType } from '@syncfusion/ej2-base';
import { MarginModel, BorderModel, AccessibilityModel, AnimationModel } from '../common/model/base-model';
import { ChartTheme, ExportType, Orientation } from '../common/utils/enum';
import { Rect, Size, SvgRenderer } from '@syncfusion/ej2-svg-base';
import { SankeySeries } from './series/series';
import { SankeyModel } from './sankey-model';
import { SankeyNode, SankeyLink } from './model/sankey-base';
import { SankeyLabelSettingsModel, SankeyNodeSettingsModel, SankeyLinkSettingsModel, SankeyTitleStyleModel, SankeyLegendSettingsModel, SankeyTooltipSettingsModel, SankeyNodeModel, SankeyLinkModel } from './model/sankey-base-model';
import { ISankeyThemeStyle, SankeyExportedEventArgs, SankeyExportEventArgs, SankeyLabelRenderEventArgs, SankeyLegendItemHoverEventArgs, SankeyLegendRenderEventArgs, SankeyLinkEventArgs, SankeyLinkRenderEventArgs, SankeyLoadedEventArgs, SankeyNodeEventArgs, SankeyNodeLayout, SankeyNodeRenderEventArgs, SankeyPrintEventArgs, SankeySizeChangedEventArgs, SankeyTooltipRenderEventArgs } from './model/sankey-interface';
import { SankeyLegend } from './legend/legend';
import { SankeyTooltip } from './user-interaction/tooltip';
import { IAfterExportEventArgs } from '../common';
import { SankeyExport } from './print-export/export';
import { SankeyHighlight } from './user-interaction/highlight';
/**
* Represents the Sankey diagram control for visualizing flow quantities between entities.
*
* const sankey = new Sankey({
* nodes: [
* { id: 'A', label: 'Source A' },
* { id: 'B', label: 'Process B' },
* { id: 'C', label: 'Destination C' }
* ],
* links: [
* { source: 'A', target: 'B', value: 40 },
* { source: 'B', target: 'C', value: 35 },
* { source: 'A', target: 'C', value: 5 }
* ],
* orientation: 'Horizontal,
* tooltip: { enabled: true }
* });
*
* @public
*/
export declare class Sankey extends Component<HTMLElement> implements INotifyPropertyChanged {
/**
* The width of the sankey diagram as a string, accepting values like '100px' or '100%'.
* If specified as '100%', the component renders to the full width of its parent element.
*
* @default null
*/
width: string;
/**
* The height of the sankey diagram as a string, accepting values like '100px' or '100%'.
* If specified as '100%', the component renders to the full height of its parent element.
*
* @default null
*/
height: string;
/**
* The title displayed at the top of the sankey diagram.
*
* @default ''
*/
title: string;
/**
* The subtitle displayed below the main title.
*
* @default ''
*/
subTitle: string;
/**
* Options to customize the appearance of the title text.
*/
titleStyle: SankeyTitleStyleModel;
/**
* Options to customize the appearance of the subtitle text.
*/
subTitleStyle: SankeyTitleStyleModel;
/**
* Background color of the sankey diagram. Accepts valid CSS color values.
*
* @default null
*/
background: string;
/**
* Background image URL of the sankey diagram.
*
* @default null
*/
backgroundImage: string;
/**
* Options to configure the margins around the component.
*/
margin: MarginModel;
/**
* Options to configure the outer border of the component.
*/
border: BorderModel;
/**
* Defines the theme of the component.
*
* @default 'Material'
*/
theme: ChartTheme;
/**
* Collection of Sankey links that represent the flow between nodes.
* Each link defines properties such as source, target, and value.
*
* @default []
*/
links: SankeyLinkModel[];
/**
* Collection of Sankey nodes that represent entities in the diagram.
* Each node defines properties such as name, color, and position.
*
* @default []
*/
nodes: SankeyNodeModel[];
/**
* Defines the orientation of the Sankey diagram.
* The options are:
* * Horizontal - Renders nodes from left to right.
* * Vertical - Renders nodes from top to bottom.
*
* @default 'Horizontal'
*/
orientation: Orientation;
/**
* Customize labels using labelSettings to improve clarity and alignment with application design.
*/
labelSettings: SankeyLabelSettingsModel;
/**
* Node style configuration for the sankey diagram.
* Customize node appearance, size, opacity, and text alignment.
*/
nodeStyle: SankeyNodeSettingsModel;
/**
* Link style configuration for the sankey diagram.
* Customize link color, opacity, and hover behavior.
*/
linkStyle: SankeyLinkSettingsModel;
/**
* Legend configuration for the sankey diagram.
*/
legendSettings: SankeyLegendSettingsModel;
/**
* Tooltip configuration for displaying details on hover.
*/
tooltip: SankeyTooltipSettingsModel;
/**
* Options for customizing the animation.
*
*/
animation: AnimationModel;
/**
* When set to true, enables export of the diagram into supported formats.
*
* @default true
*/
enableExport: boolean;
/**
* Enables export in specific scenarios.
*
* @default false
*/
allowExport: boolean;
/**
* Accessibility options for the component.
*/
accessibility: AccessibilityModel;
/**
* Triggers before a legend item is rendered. Allows customization of legend text and shape color.
*
* @event legendItemRendering
*/
legendItemRendering: EmitType<SankeyLegendRenderEventArgs>;
/**
* Triggers when the mouse hovers over a legend item.
*
* @event legendItemHover
*/
legendItemHover: EmitType<SankeyLegendItemHoverEventArgs>;
/**
* Triggers before a label is rendered. Allows customization of label text and style.
*
* @event labelRendering
*/
labelRendering: EmitType<SankeyLabelRenderEventArgs>;
/**
* Triggers before a node is rendered. Allows customization of node appearance.
*
* @event nodeRendering
*/
nodeRendering: EmitType<SankeyNodeRenderEventArgs>;
/**
* Triggers before a link is rendered. Allows customization of link appearance.
*
* @event linkRendering
*/
linkRendering: EmitType<SankeyLinkRenderEventArgs>;
/**
* Triggers when the chart size changes.
*
* @event sizeChanged
*/
sizeChanged: EmitType<SankeySizeChangedEventArgs>;
/**
* Triggers before a tooltip is rendered. Allows customization of tooltip text.
*
* @event tooltipRendering
*/
tooltipRendering: EmitType<SankeyTooltipRenderEventArgs>;
/**
* Triggers after the chart export is completed.
*
* @event exportCompleted
*/
exportCompleted: EmitType<SankeyExportedEventArgs>;
/**
* Triggers when a node is clicked.
*
* @event nodeClick
*/
nodeClick: EmitType<SankeyNodeEventArgs>;
/**
* Triggers when the mouse enters a node.
*
* @event nodeEnter
*/
nodeEnter: EmitType<SankeyNodeEventArgs>;
/**
* Triggers when the mouse leaves a node.
*
* @event nodeLeave
*/
nodeLeave: EmitType<SankeyNodeEventArgs>;
/**
* Triggers when a link is clicked.
*
* @event linkClick
*/
linkClick: EmitType<SankeyLinkEventArgs>;
/**
* Triggers when the mouse enters a link.
*
* @event linkEnter
*/
linkEnter: EmitType<SankeyLinkEventArgs>;
/**
* Triggers when the mouse leaves a link.
*
* @event linkLeave
*/
linkLeave: EmitType<SankeyLinkEventArgs>;
/**
* Triggers after the sankey has fully loaded.
*
* @event loaded
* @blazorProperty 'Loaded'
*/
loaded: EmitType<SankeyLoadedEventArgs>;
/**
* Triggers before the sankey loads. This event allows for customization and configuration before the sankey is rendered.
*
* @event load
*/
load: EmitType<SankeyLoadedEventArgs>;
/**
* Triggers before the export gets started.
*
* @event beforeExport
*/
beforeExport: EmitType<SankeyExportEventArgs>;
/**
* Triggers after the export completed.
*
* @event afterExport
*/
afterExport: EmitType<IAfterExportEventArgs>;
/**
* Triggers before the prints gets started.
*
* @event beforePrint
*/
beforePrint: EmitType<SankeyPrintEventArgs>;
/**
* Customize the focus border color.
* If not specified, the element will use the default focus border color.
*
* @default null
*/
focusBorderColor: string;
/**
* Customize the focus border width.
* If not specified, the element will use the default focus border width.
*
* @default 1.5
*/
focusBorderWidth: number;
/**
* Customize the focus border margin.
* If not specified, the element will use the default focus border margin.
*
* @default 0
*/
focusBorderMargin: number;
/** @private */
sankeySeriesModule: SankeySeries;
/** @private */
sankeyLegendModule: SankeyLegend;
/** @private */
previousTargetId: string;
/** @private */
currentGroup: 'title' | 'subtitle' | 'nodes' | 'links' | 'legend' | null;
/** @private */
currentNodeIndex: number;
/** @private */
currentLinkIndex: number;
/** @private */
private currentLegendIndex;
/** @private */
intl: Internationalization;
/** @private */
isTouch: boolean;
/** @private */
startMove: boolean;
/** @private */
mouseX: number;
/** @private */
mouseY: number;
/** @private */
disableTrackTooltip: boolean;
/** @private */
svgObject: Element;
/** @private */
renderer: SvgRenderer;
/** @private */
availableSize: Size;
/** @private */
initialClipRect: Rect;
/** @private */
themeStyle: ISankeyThemeStyle;
/** @private */
private resizeBound;
/** @private */
animateSeries: boolean;
/** @private */
/**
* Stores the computed Sankey node layout map keyed by node id.
*/
nodeLayoutMap: {
[key: string]: SankeyNodeLayout;
};
/**
* Provides the tooltip module used to render Sankey tooltips.
*
* @private
*/
tooltipModule: SankeyTooltip;
/**
* Holds the currently hovered Sankey node instance.
*
* @private
*/
hoveredNode: SankeyNode;
/**
* Holds the currently hovered Sankey link instance.
*
* @private
*/
hoveredLink: SankeyLink;
/**
* The Export Module is used to export chart.
*
* @private
*/
sankeyExportModule: SankeyExport;
/**
* Provides the highlight module used for node/link hover interactions.
*
* @private
*/
sankeyHighlightModule: SankeyHighlight;
/**
* Initializes the Sankey chart instance and its core modules.
*
* @param {SankeyModel} [options] - The Sankey configuration model used to initialize the component.
* @param {string | HTMLElement} [element] - The host element or element id used to render the component.
* @private
*/
constructor(options?: SankeyModel, element?: string | HTMLElement);
/**
* Prepares the Sankey component for rendering by wiring events, applying culture/RTL settings, and computing available size.
*
* @returns {void}
* @private
*/
protected preRender(): void;
/**
* Renders the Sankey component by initializing SVG, computing nodes/legend/bounds, and drawing visual elements.
*
* @returns {void}
* @private
*/
protected render(): void;
/**
* Creates the chart SVG by removing the existing SVG and initializing a new one.
*
* @returns {void}
* @private
*/
createChartSvg(): void;
/**
* Removes the existing SVG and tooltip parent element from the DOM.
*
* @returns {void}
* @private
*/
removeSvg(): void;
/**
* Creates the secondary tooltip container element used for rendering tooltip content.
*
* @returns {void}
* @private
*/
createSecondaryElement(): void;
/**
* Positions and applies required styles to the secondary tooltip container element.
*
* @returns {void}
*/
private positionSecondaryElement;
/**
* Calculates the initial clip rect and legend bounds based on margins, borders, titles, and available size.
*
* @returns {void}
*/
private calculateBounds;
/**
* Renders all visual elements of the Sankey chart including border, title, series, legend, and accessibility features.
*
* @returns {void}
*/
private renderElements;
/**
* Renders the chart border and background (including optional background image) into the SVG.
*
* @returns {void}
*/
private renderBorder;
/**
* Renders the chart title and subtitle text elements with accessibility attributes applied.
*
* @returns {void}
*/
private renderTitle;
/**
* Renders the Sankey legend if the legend module is available and legend visibility is enabled.
*
* @returns {void}
*/
private renderLegend;
/**
* Finds and returns a user-defined node by id from the nodes collection.
*
* @param {string} id - The node id used to locate the node definition.
* @returns {SankeyNode | null} returns node if present, else null.
* @private
*/
findNode(id: string): SankeyNode | null;
/**
* Finds and returns a user-defined link by source and target ids from the links collection.
*
* @param {string} sourceId - The source node id used to locate the link definition.
* @param {string} targetId - The target node id used to locate the link definition.
* @returns {SankeyLink | null} returns link if present, else null.
*
* @private
*/
findLink(sourceId: string, targetId: string): SankeyLink | null;
/**
* Initializes the internationalization instance used by the component.
*
* @returns {void}
*/
private setCulture;
/**
* Applies theme styles for the current chart theme.
*
* @returns {void}
*/
private setTheme;
/**
* Calculates the available rendering size based on configured width/height or element client size.
*
* @returns {void}
*
* @private
*/
calculateAvailableSize(): void;
/**
* Unbinds all DOM and window event listeners attached for Sankey interactions.
*
* @returns {void}
*
* @private
*/
unWireEvents(): void;
/**
* Binds all required DOM and window event listeners for Sankey interactions.
*
* @returns {void}
*
* @private
*/
wireEvents(): void;
/**
* Applying styles for sankey chart element.
*
* @param {HTMLElement} element - Specifies the element.
* @returns {void}
*/
private setStyle;
/**
* Handles document-level keyboard shortcuts for the Sankey chart.
*
* Moves focus to the chart container when the Alt + J key combination is pressed
* and applies the container navigation focus styling.
*
* @param {KeyboardEvent} keyboardEvent - The keyboard event triggered on the document.
* @returns {void}
*
* @private
*/
handleDocumentKeyDown(keyboardEvent: KeyboardEvent): void;
/**
* Applies keyboard navigation focus styling to the Sankey chart container.
*
* @returns {void}
*
* @private
*/
setContainerNavigationStyle(): void;
/**
* Handles pointer or mouse move events on the chart area.
*
* Updates the internal mouse position used for hit-testing
* and tooltip positioning.
*
* @param {PointerEvent | MouseEvent} event - The pointer or mouse move event.
* @returns {boolean} Returns false to prevent further propagation.
*/
private handlePointerMove;
/**
* Handles pointer or mouse up events on the chart area.
*
* Updates the internal mouse position used for interaction handling.
*
* @param {PointerEvent | MouseEvent} event - The pointer or mouse up event.
* @returns {boolean} Returns false to prevent further propagation.
*/
private handlePointerUp;
/**
* Handles pointer or mouse leave events on the chart area.
*
* Updates the mouse position (if available) and resets
* the internal pointer movement state.
*
* @param {PointerEvent | MouseEvent} [event] - The optional pointer or mouse leave event.
* @returns {boolean} Returns false to prevent further propagation.
*
* @private
*/
handlePointerLeave(event?: PointerEvent | MouseEvent): boolean;
/**
* Handles window resize by recalculating available size, triggering sizeChanged, and re-rendering only when dimensions differ.
*
* @returns {boolean} returns boolean based on chart resize actions.
*
* @private
*/
chartResize(): boolean;
/**
* Sets the mouse coordinates relative to the chart SVG for pointer and mouse events.
*
* @param {PointerEvent | MouseEvent} event - Mouse/pointer event with client coordinates.
* @returns {void}
*
* @private
*/
updateMousePosition(event: {
clientX: number;
clientY: number;
} | PointerEvent | MouseEvent): void;
/**
* Tracks pointer/touch movement, updates chart-relative mouse coordinates, and forwards the move event to the chart handler.
*
* @param {(PointerEvent | TouchEvent)} event - Pointer or touch move event containing client coordinates.
* @returns {boolean} returns boolean based on mouse actions.
*
* @private
*/
mouseMove(event: PointerEvent | TouchEvent): boolean;
/**
* Tracks pointer/touch end, updates chart-relative mouse coordinates, and forwards the end event to the mouse-leave handler.
*
* @param {(PointerEvent | TouchEvent)} event - Pointer or touch end event containing client coordinates.
* @returns {boolean} returns boolean based on mouse actions.
*
* @private
*/
mouseEnd(event: PointerEvent | TouchEvent): boolean;
/**
* Handles mouse move interactions over the Sankey chart.
*
* Detects whether the pointer is over a node or a link, triggers the corresponding
* enter/leave events, and maintains the current hovered node/link state.
*
* @param {MouseEvent} event - The mouse move event dispatched on the chart.
* @returns {boolean} Always returns false to prevent default propagation in the control.
*
* @private
*/
handleMouseMove(event: MouseEvent): boolean;
/**
* Notifies the chart about the pointer/touch start event to initiate interaction handling.
*
* @param {PointerEvent} event - Pointer down event raised on the chart surface.
* @returns {boolean} returns boolean based on mouse actions.
*
* @private
*/
handleMouseDown(event: PointerEvent): boolean;
/**
* Handles mouse leave by clearing hover states, triggering leave events, and notifying the chart about interaction end.
*
* @param {MouseEvent} event - Mouse leave event raised when the pointer exits the chart surface.
* @returns {boolean} returns boolean based on mouse actions.
*
* @private
*/
mouseLeave(event: MouseEvent): boolean;
/**
* Handles the mouse click on the chart.
*
* @param {PointerEvent | TouchEvent} e - The mouse or touch event.
* @returns {boolean} - Return false.
* @private
*
*/
handleMouseClick(e: PointerEvent | TouchEvent): boolean;
/**
* Export method for the chart.
*
* @param {ExportType} type - Specifies the type of the export.
* @param {string} fileName - Specifies the file name of the exported file.
* @returns {void}
*
* @private
*/
export(type: ExportType, fileName: string): void;
/**
* Prints the chart in the page.
*
* @param {string[] | string | Element} id - The id of the chart to be printed on the page.
* @returns {void}
*
* @private
*/
print(id?: string[] | string | Element): void;
/**
* Returns the persisted state of the component.
*
* @returns {string} the persisted state.
*
* @private
*/
getPersistData(): string;
/**
* Handles property updates and refreshes the Sankey rendering based on the changed properties.
*
* @param {SankeyModel} newProp - Newly updated property values.
* @param {SankeyModel} _oldProp - Previously existing property values.
* @returns {void}
*
* @private
*/
onPropertyChanged(newProp: SankeyModel, _oldProp: SankeyModel): void;
/**
* Handles focus-in events within the Sankey chart to manage keyboard navigation,
* highlighting, and tooltip behavior based on the focused element group.
*
* @param {FocusEvent} event - The focus-in event dispatched on the chart.
* @returns {void}
* @private
*/
handleFocusIn(event: FocusEvent): void;
/**
* Initializes the keyboard tab order for focusable groups within the Sankey chart.
*
* The order is: Title → Subtitle → Nodes → Links → Legend.
* Only the first element of each group is tabbable by default; others use roving tabindex.
*
* @returns {void}
*/
private initKeyboardTabOrder;
/**
* Updates tabindex so the previous element becomes unfocusable and the next element becomes focusable.
*
* @param {Element | null} [previousElement] - The element to make unfocusable.
* @param {Element | null} [nextElement] - The element to make focusable.
* @returns {void}
*
* @private
*/
updateTabIndex(previousElement?: Element | null, nextElement?: Element | null): void;
/**
* Wraps an index into the valid range [0, total - 1].
*
* @param {number} index - The index to normalize.
* @param {number} total - The total number of items in the collection.
* @returns {number} The normalized index within bounds.
*
* @private
*/
normalizeIndex(index: number, total: number): number;
/**
* Finds the index of an element by id within a list of elements.
*
* @param {Element[]} elements - The collection to search.
* @param {string} targetId - The id of the element to find.
* @returns {number} The index of the matching element, or 0 if not found.
*
* @private
*/
indexOfElementById(elements: Element[], targetId: string): number;
/**
* Removes the focused CSS class from elements currently marked as focused.
*
* @returns {void}
*/
private clearFocusedClasses;
/**
* Focuses the specified element, applies the focused class, and ensures it is tabbable.
*
* @param {Element} element - The element to focus.
* @returns {string} The id of the focused element, or an empty string if focus was not applied.
*
* @private
*/
focusElement(element: Element): string;
/**
* Applies keyboard navigation outline styling to the specified target element by id.
*
* @param {string} targetId - The id of the element to style.
* @returns {void}
*
* @private
*/
applyNavigationStyle(targetId: string): void;
/**
* Removes navigation outline styling from all focusable elements within the Sankey chart.
*
* @returns {void}
*
* @private
*/
clearNavigationStyles(): void;
/**
* Determines the Sankey navigation group of a given element id.
*
* @param {string} targetId - The id of the element to classify.
* @returns {'title' | 'subtitle' | 'nodes' | 'links' | 'legend' | null} The group name, or null if not recognized.
*
* @private
*/
getGroupOf(targetId: string): 'title' | 'subtitle' | 'nodes' | 'links' | 'legend' | null;
/**
* Gets all SVG node <rect> elements within the Sankey node collection.
*
* @returns {Element[]} An array of node elements.
*
* @private
*/
getNodeElements(): Element[];
/**
* Gets all SVG link <path> elements within the Sankey link collection.
*
* @returns {Element[]} An array of link elements.
*
* @private
*/
getLinkElements(): Element[];
/**
* Gets all legend group elements within the Sankey legend container.
*
* @returns {Element[]} An array of legend group elements.
*
* @private
*/
getLegendItems(): Element[];
/**
* Moves keyboard focus within the specified group by the given step (delta).
*
* Uses a roving tabindex strategy among Nodes, Links, or Legend items.
*
* @param {'nodes' | 'links' | 'legend'} group - The group to navigate within.
* @param {1 | -1} delta - The step to move focus by (1 for next, -1 for previous).
* @returns {string | null} The id of the newly focused element, or null if none.
*
* @private
*/
moveFocusWithinGroup(group: 'nodes' | 'links' | 'legend', delta: 1 | -1): string | null;
/**
* Applies highlight behavior based on the given element type (node or link).
*
* @param {Element} element - The element to highlight (node <rect> or link <path>).
* @returns {void}
*
* @private
*/
applyHighlightForElement(element: Element): void;
/**
* Ensures the tooltip module is created when tooltip is enabled.
*
* @returns {boolean} True if the tooltip module is available; otherwise, false.
*
* @private
*/
ensureTooltip(): boolean;
/**
* Computes a fallback center position for an SVG element using client bounding rectangles.
*
* Converts the element's visual center from viewport coordinates to chart coordinate space,
* relative to the initial clip rectangle.
*
* @param {Element} targetElement - The SVG element whose center should be calculated.
* @returns {number | null} The computed center position, or null on failure.
*
* @private
*/
getElementCenterInChartCoords(targetElement: Element): {
x: number;
y: number;
} | null;
/**
* Handles keydown events for Sankey keyboard interactions.
*
* Prevents default arrow key scrolling, clears effects on Escape,
* and removes navigation outline on Tab. Triggers print on CtrlP.
*
* @param {KeyboardEvent} keyboardEvent - The keydown event.
* @returns {boolean} Always returns false to prevent default behavior within the control.
*
* @private
*/
handleKeyDown(keyboardEvent: KeyboardEvent): boolean;
/**
* Handles keyup events and delegates to Sankey keyboard navigation logic.
*
* Detects Tab, Arrow, and Escape actions and invokes the navigation handler.
*
* @param {KeyboardEvent} keyboardEvent - The keyup event.
* @returns {boolean} Always returns false to prevent default behavior within the control.
*
* @private
*/
handleKeyUp(keyboardEvent: KeyboardEvent): boolean;
/**
* Executes roving tabindex navigation and tooltip/highlight behavior based on keyboard actions.
*
* Supports Arrow key movement within groups and Tab to move focus between groups, applying
* highlight for nodes/links and hiding tooltip for non-tooltip groups (e.g., legend).
*
* @param {KeyboardEvent} keyboardEvent - The keyboard event that triggered navigation.
* @param {string} targetId - The id of the currently focused element before navigation.
* @param {'Tab' | 'ArrowMove' | 'Enter' | 'Space' | 'ESC'} action - The navigation action to perform.
* @returns {void}
*
* @private
*/
handleKeyboardNavigation(keyboardEvent: KeyboardEvent, targetId: string, action: 'Tab' | 'ArrowMove' | 'Enter' | 'Space' | 'ESC'): void;
/**
* Provides the list of modules required to render the control (series, tooltip, legend, export, etc.).
*
* @returns {ModuleDeclaration[]} returns required modules injected in sample.
*
* @private
*/
requiredModules(): ModuleDeclaration[];
/**
* To destroy the widget
*
* @returns {void}
* @private
*/
destroy(): void;
/**
* Returns the name of the module used for Sankey control identification.
*
* @returns {string} - the module name
* @private
*/
getModuleName(): string;
}