@nova-ui/dashboards/index.d.ts

Nova Dashboards is a framework designed to provide feature developers with a common solution for presenting data coming from various sources within a single view, as well as a set of predefined widget visualizations that are 100% configuration-driven and

import * as i0 from '@angular/core';
import { PipeTransform, ChangeDetectorRef, EventEmitter, StaticProvider, Injector, InjectionToken, OnInit, Type, OnDestroy, OnChanges, SimpleChanges, ComponentRef, AfterViewInit, QueryList, ElementRef, NgZone, KeyValueDiffers, DoCheck, ComponentFactoryResolver, ApplicationRef, RendererFactory2, TemplateRef, Renderer2, AfterContentInit, AfterViewChecked } from '@angular/core';
import * as i73 from '@nova-ui/bits';
import { UnitConversionService, UnitOption, EventBus, IEvent, LoggerService, IEventDefinition, ITimeFramePresetDictionary, IDataField, TableAlignmentOptions, EventDefinition, ISelection, IDataSource, IDataFieldsConfig, IconService, ITableSelectionConfigEnabled, ITableSelectionConfigDisabled, VirtualViewportManager, ISortedItem, TableComponent, PaginatorComponent, SelectorService, ITimeframe, TimeframeService, HistoryStorage, IBusyConfig, DialogService, SpinnerSize, IFilteringOutputs, SelectV2Component } from '@nova-ui/bits';
import * as _angular_forms from '@angular/forms';
import { AbstractControl, FormGroup, FormGroupDirective, FormBuilder, FormControl, ControlValueAccessor, ValidationErrors, FormArray } from '@angular/forms';
import * as i4 from '@angular/common';
import { KeyValue } from '@angular/common';
import { BehaviorSubject, Observable, ReplaySubject, Subject, noop } from 'rxjs';
import * as i35 from '@nova-ui/charts';
import { TimeseriesZoomPlugin, ZoomPlugin, IScale, IXYScales, ChartAssist, Renderer, IAccessors, IChartAssistSeries, IValueProvider, ChartPalette, IChartSeries, IAllAround, ChartDonutContentPlugin, SparkChartAssist, StatusAccessors, TimeseriesZoomPluginsSyncService, ITimeseriesZoomPluginInspectionFrame } from '@nova-ui/charts';
import * as i70 from 'angular-gridster2';
import { GridsterItem, GridsterConfig, GridsterComponent, GridsterItemComponent } from 'angular-gridster2';
import * as i3 from '@angular/cdk/portal';
import { ComponentPortal, Portal } from '@angular/cdk/portal';
import { DomSanitizer } from '@angular/platform-browser';
import * as i67 from '@angular/cdk/scrolling';
import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
import moment, { Moment } from 'moment/moment';
import { Router } from '@angular/router';
import { Subject as Subject$1 } from 'rxjs/internal/Subject';
import * as i71 from '@angular/cdk/drag-drop';
import { CdkDragDrop, CdkDragStart } from '@angular/cdk/drag-drop';
import { ScrollDispatcher } from '@angular/cdk/overlay';

/**
 * Pipe for transforming large values to their abbreviated counterparts.
 * Conversions are applied for values 10000 or greater
 */
declare class DashboardUnitConversionPipe implements PipeTransform {
    private unitConversionService;
    constructor(unitConversionService: UnitConversionService);
    /**
     * Transforms a large number value to its abbreviated counterpart
     *
     * @param value The value to convert
     *
     * @returns The string representation of the converted value
     */
    transform: (value: string | number | undefined, units?: UnitOption, defaultThreshold?: number) => string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardUnitConversionPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DashboardUnitConversionPipe, "nuiDashboardUnitConversion", false>;
}

declare class PreviewOverlayComponent {
    static lateLoadKey: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewOverlayComponent, "nui-preview-overlay", never, {}, {}, never, never, false, never>;
}

/**
 * Same as Partial<T> but goes deeper and makes all of its properties and sub-properties Parti al<T>.
 */
type DeepPartial<T> = T extends object ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : T;
declare const PIZZAGNA_EVENT_BUS: InjectionToken<EventBus<IEvent<any>>>;
declare const DASHBOARD_EVENT_BUS: InjectionToken<EventBus<IEvent<any>>>;
declare const DATA_SOURCE: InjectionToken<EventBus<IEvent<any>>>;
declare const FORMATTERS_REGISTRY: InjectionToken<EventBus<IEvent<any>>>;
declare const TEST_REGISTRY: InjectionToken<EventBus<IEvent<any>>>;
declare const HEADER_LINK_PROVIDER: InjectionToken<EventBus<IEvent<any>>>;
declare enum WellKnownProviders {
    DataSource = "dataSource",
    Adapter = "adapter",
    Converter = "converter",
    Broadcaster = "broadcaster",
    Refresher = "refresher",
    EventProxy = "eventProxy",
    LoadingAdapter = "loadingAdapter",
    ContentFallbackAdapter = "contentFallbackAdapter",
    InteractionHandler = "interactionHandler",
    EventBusDebugger = "eventBusDebugger",
    KpiColorPrioritizer = "kpiColorPrioritizer",
    FormattersRegistry = "formattersRegistry",
    DataSourceManager = "dataSourceManager"
}
declare enum WellKnownPathKey {
    Root = "root",
    DataSourceConfigComponentType = "dataSourceConfigComponentType",
    TileDescriptionConfigComponentType = "tileDescriptionConfigComponentType",
    DataSourceProviders = "dataSourceProviders",
    Formatters = "formatters",
    TileDescriptionBackgroundColors = "tileDescriptionBackgroundColors",
    TileBackgroundColorRulesBackgroundColors = "tileBackgroundColorRulesBackgroundColors"
}
declare enum WellKnownDataSourceFeatures {
    Interactivity = "interactivity",
    DisableTableColumnGeneration = "disableTableColumnGeneration"
}
type IProperties = Record<string, any>;
interface IProviderProperties extends IProperties {
    /** This is property is set by the component portal directive to give providers self-awareness they need to update properties in pizzagna. */
    providerKey?: string;
}
interface ISerializableTimeframe {
    startDatetime: string;
    endDatetime: string;
    selectedPresetId?: string;
    title?: string;
}
interface IComponentConfiguration {
    id: string;
    componentType: string;
    providers?: Record<string, IProviderConfiguration>;
    properties?: IProperties;
}
interface IProviderConfiguration {
    providerId: string;
    properties?: IProviderProperties;
}
interface IProviderConfigurationForDisplay extends IProviderConfiguration {
    label: string;
}
interface IPortalEnvironment {
    providers?: StaticProvider[];
    injector?: Injector;
}
type IPizzagnaLayer = Record<string, DeepPartial<IComponentConfiguration>>;
type IPizzagna = Record<string, IPizzagnaLayer>;
type IPizza = Record<string, IComponentConfiguration>;
/**
 * Interface for components that can be dynamically refreshed from the outside using the changeDetector
 */
interface IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
}
/**
 * Interface for components that expose a form
 */
interface IHasForm<T extends AbstractControl = FormGroup> {
    form: T;
    formReady: EventEmitter<T>;
}
/**
 * Interface for providers that require the related component info
 */
interface IHasComponent<T = any> {
    setComponent(component: T, componentId: string): void;
}
/**
 * Interface for configurable providers
 */
interface IConfigurable {
    providerKey?: string;
    setComponent?: (component: any, componentId: string) => void;
    updateConfiguration(properties: IProperties): void;
}
declare enum PizzagnaLayer {
    Structure = "structure",
    Configuration = "configuration",
    Data = "data"
}
declare enum AccordionState {
    CRITICAL = "critical",
    WARNING = "warning",
    DEFAULT = "default"
}
declare enum HttpStatusCode {
    Unknown = "0",
    Ok = "200",
    Forbidden = "403",
    NotFound = "404"
}
interface IPaletteColor {
    color: string;
    label: string;
}
type ComparatorFn = (a: any, b: any) => boolean;
type ComparatorTypes = ">" | ">=" | "==" | "<" | "<=";
interface IBackgroundColorComparator {
    comparatorFn: ComparatorFn;
    label?: string;
}
type IComparatorsDict = Partial<Record<ComparatorTypes | string, IBackgroundColorComparator>>;

interface IWidgets {
    [key: string]: IWidget;
}
interface IWidget {
    id: string;
    type: string;
    version?: number;
    pizzagna: IPizzagna;
    metadata?: IWidgetMetadata;
    uniqueKey?: string;
}
interface IWidgetMetadata extends Record<string, any> {
    /**
     * Set this to true to communicate to the widget cloner that the widget requires
     * further configuration before it can be placed on the dashboard.
     */
    needsConfiguration?: boolean;
}
interface IWidgetTypeDefinition {
    configurator?: IPizzagna;
    widget: IPizzagna;
    /**
     * Paths to various important values in pizzagnas - this should be coupled with respective pizzagnas in v10 - NUI-5829
     */
    paths?: {
        widget?: Record<string, string>;
        configurator?: Record<string, string>;
    };
}
/**
 * The properties for widget error display
 */
interface IWidgetErrorDisplayProperties {
    image: string;
    title: string;
    description: string;
}

declare class WidgetErrorComponent implements OnInit, IHasChangeDetector, IWidgetErrorDisplayProperties {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    readonly defaultClasses = "d-flex flex-column justify-content-center w-100 p-3";
    image: string;
    title: string;
    description: string;
    /**
     * Optional class for styling
     */
    elementClass: string;
    classNames: string;
    constructor(changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetErrorComponent, "nui-widget-error", never, { "image": { "alias": "image"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NuiDashboardsCommonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NuiDashboardsCommonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NuiDashboardsCommonModule, [typeof DashboardUnitConversionPipe, typeof PreviewOverlayComponent, typeof WidgetErrorComponent], [typeof i4.CommonModule, typeof i73.NuiImageModule], [typeof i4.CommonModule, typeof DashboardUnitConversionPipe, typeof PreviewOverlayComponent, typeof WidgetErrorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NuiDashboardsCommonModule>;
}

/** The default threshold at which unit conversion goes into effect */
declare const DEFAULT_UNIT_CONVERSION_THRESHOLD = 1000000;

interface IComponentWithLateLoadKey extends Type<any> {
    lateLoadKey: string;
}
declare class ComponentRegistryService {
    private logger;
    private components;
    constructor(logger: LoggerService);
    registerByLateLoadKey(component: IComponentWithLateLoadKey): void;
    registerComponentType(key: string, component: any): void;
    getComponentType(key: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegistryService>;
}

declare class EventRegistryService {
    private events;
    registerEvent(eventDefinition: IEventDefinition): void;
    getEvent(id: string): IEventDefinition;
    static ɵfac: i0.ɵɵFactoryDeclaration<EventRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EventRegistryService>;
}

interface IInteractionPayload<T> {
    interactionType?: string;
    data: T;
}
interface IInteractionHandlerProperties extends IProperties {
    interactionType?: string;
}
declare abstract class InteractionHandler<T extends IInteractionHandlerProperties, P> implements IConfigurable {
    protected readonly eventBus: EventBus<IEvent>;
    protected properties: T;
    constructor(eventBus: EventBus<IEvent>);
    updateConfiguration(properties: T): void;
    protected initializeSubscriptions(): void;
    protected abstract handleInteraction(interaction: IInteractionPayload<P>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InteractionHandler<any, any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InteractionHandler<any, any>>;
}

declare enum LegendPlacement {
    None = "None",
    Right = "Right",
    Bottom = "Bottom"
}
interface ILegendPlacementOption {
    id: LegendPlacement;
    label: string;
}

interface ITimeseriesWidgetConfig {
    interaction: null | "series" | "dataPoints";
    displayedSeries: ITimeseriesWidgetSeries[];
    legendPlacement: LegendPlacement;
    leftAxisLabel?: string;
    timeFramePickerPresets?: ITimeFramePresetDictionary;
    enableZoom: boolean;
    chartColors?: string[];
    preset: TimeseriesChartPreset;
    scales: ITimeseriesScalesConfig;
    units: UnitOption;
    collectionId?: string;
    leftYAxisUnits?: UnitOption;
    rightYAxisUnits?: UnitOption;
    gridConfig?: {
        [key: string]: any;
    };
    hasAdjacentChart?: boolean;
    groupUniqueId?: string;
    allowLegendMenu?: boolean;
    metricIds?: string;
    realTimeIds?: string[];
    type?: number;
    projectType?: TimeseriesWidgetProjectType;
}
interface ITimeseriesWidgetSeries {
    id: string;
    label: string;
    selectedSeriesId: string;
}
interface ITimeseriesWidgetData<T = ITimeseriesWidgetSeriesData> {
    id: string;
    name: string;
    description: string;
    data: T[];
    rawData?: T[];
    transformer?: (data: T[], hasPercentile?: boolean) => T[];
    link?: string;
    secondaryLink?: string;
    metricUnits?: UnitOption;
}
interface ITimeseriesWidgetSeriesData {
    x: any;
    y: any;
    [key: string]: any;
}
interface ITimeseriesWidgetStatusData extends ITimeseriesWidgetSeriesData {
    thick?: boolean;
    color?: string;
    icon?: string;
}
interface ITimeseriesOutput<T = ITimeseriesWidgetSeriesData> {
    series: ITimeseriesWidgetData<T>[];
    summarySerie?: ITimeseriesWidgetData<T>;
}
declare enum TimeseriesInteractionType {
    DataPoints = "dataPoints",
    Series = "series",
    Values = "values"
}
/** Configuration for a chart preset */
interface IChartPreset {
    componentType: string;
}
/**
 * Configuration of scales for a x/y chart
 */
interface ITimeseriesScalesConfig {
    x: ITimeseriesScaleConfig;
    y: ITimeseriesScaleConfig;
    yRight?: ITimeseriesScaleConfig;
}
/**
 * Configuration of a scale for timeseries widget
 */
interface ITimeseriesScaleConfig {
    /** Type of the scale */
    type: TimeseriesScaleType;
    /** Additional properties of the scale */
    properties?: IProperties;
}
/**
 * List of supported scale types for the timeseries widget
 */
declare enum TimeseriesScaleType {
    /** Continous time scale */
    Time = "time",
    /** Time interval scale */
    TimeInterval = "timeInterval",
    /** Numeric linear scale */
    Linear = "linear"
}
/** Enumeration of chart presets supported by the timeseries widget */
declare enum TimeseriesChartPreset {
    Line = "line",
    StackedArea = "stackedArea",
    StackedPercentageArea = "stackedPercentageArea",
    StackedBar = "stackedBar",
    StatusBar = "statusBar"
}
/** Enumeration of timeseries chart types recieved from the backend */
declare enum TimeseriesChartTypes {
    line = 1,// Line
    counter = 2,// StackedBar
    event = 3,// StackedBar
    alert = 4,// StackedArea
    status = 5,// StackedArea
    multi = 6,// StatusBar
    dpaWaitTime = 7
}
declare enum TimeseriesTransformer {
    None = "none",
    Normalize = "normalize",
    ChangePoint = "changePoint",
    Difference = "difference",
    Linear = "linear",
    PercentileStd = "percentileStd",
    Smoothing = "smoothing",
    LoessStandardize = "loessStandardize",
    Standardize = "standardize",
    FloatingAverage = "floatingAverage"
}
declare enum TimeseriesWidgetProjectType {
    ModernDashboard = 0,
    PerfstackApp = 1
}
type TimeseriesWidgetZoomPlugin = TimeseriesZoomPlugin | ZoomPlugin;

interface IFormatterData<T = any> {
    value: T;
    [key: string]: any;
}
interface ILinkFormatterData extends IFormatterData<string> {
    link: string;
}

interface IFormatterProperties extends IProperties {
    dataFieldIds?: IFormatterData;
}
interface IFormatter {
    componentType: string;
    properties: IFormatterProperties;
}
interface IFormatterConfigurator {
    formatter?: IFormatter;
    formatterDefinition: IFormatterDefinition;
    dataFields: IDataField[];
}
interface IFormatterDefinitionProperties {
    /** CSS class to be applied to the formatter host element */
    elementClass?: string;
}
interface IFormatterDefinition {
    componentType: string;
    label: string;
    /**
     * The formatter's compatible data types.
     */
    dataTypes: Record<string, string | string[]>;
    /**
     * Component used to configure values for formatter.
     */
    configurationComponent?: string;
    properties?: IFormatterDefinitionProperties;
}
interface ITableFormatterDefinition extends IFormatterDefinition {
    alignment?: TableAlignmentOptions;
}
interface IInfoMessage {
    componentType: string;
    properties: IInfoMessageProperties;
}
interface IInfoMessageProperties {
    generalText: string;
    emphasizeText?: string;
    link?: ILinkDefinition;
    allowDismiss?: boolean;
}
interface ILinkDefinition {
    href: string;
    target: string;
    text: string;
}
declare enum EmbeddedContentMode {
    URL = 0,
    HTML = 1
}

/** Default refresh interval in seconds */
declare const DEFAULT_REFRESH_INTERVAL = 300;
interface ITimeseriesDataSourceAdapterConfiguration extends IProperties {
    series: ITimeseriesWidgetSeries[];
}
interface IDataSourceOutput<T> {
    result: T;
    error?: IDataSourceError;
}
interface IComponentIdPayload {
    componentId: string;
}
interface IDataSourceOutputPayload<T> extends IDataSourceOutput<T>, IComponentIdPayload {
}
interface IDataSourceBusyPayload extends IComponentIdPayload {
    busy: boolean;
}
interface IDataSourceError {
    type: string | number;
    message?: string;
}
type BroadcasterTrackOnType = "component" | "pizzagna";
interface IBroadcasterConfig {
    trackOn?: BroadcasterTrackOnType;
    key: string;
    paths: string[];
}
interface IKpiColorRules {
    comparisonType: ComparatorTypes;
    value: any;
    color: any;
}
interface IDrilldownComponentConfiguration extends IFormatter {
    properties: Record<string, any>;
    itemProperties?: IProperties;
}
interface IDrilldownComponentsConfiguration {
    group: IDrilldownComponentConfiguration;
    leaf: IDrilldownComponentConfiguration;
}
interface IBrokerValue {
    id: string;
    targetID: string;
    targetValue: number;
}
interface IBrokerUserConfig {
    id: string;
    type?: "min" | "max";
}
interface IBroker extends IBrokerUserConfig {
    in$: BehaviorSubject<IBrokerValue>;
    out$: BehaviorSubject<IBrokerValue>;
}

declare const DEFAULT_PIZZAGNA_ROOT = "/";
interface IStaticProviders {
    [providerId: string]: StaticProvider;
}
interface ISetPropertyPayload {
    path: string;
    value: any;
}
interface IPreviewEventPayload {
    id: IEventDefinition;
    payload: any;
}
interface IRegistryAddOptions {
    overrideExisting: boolean;
}
type IAddFormattersOptions = Pick<IRegistryAddOptions, "overrideExisting">;
interface IRemoveMetricPayload {
    metricId: string;
    groupUniqueId: string;
}
interface IWidgetPayload {
    widgetId: string;
}
interface IWidgetResizePayload extends IWidgetPayload {
    height?: number;
    width?: number;
}
declare const REFRESH: EventDefinition<unknown>;
declare const SET_NEXT_PAGE: EventDefinition<unknown>;
declare const SCROLL_NEXT_PAGE: EventDefinition<unknown>;
declare const WIDGET_REMOVE: EventDefinition<unknown>;
declare const WIDGET_EDIT: EventDefinition<unknown>;
declare const WIDGET_CREATE: EventDefinition<unknown>;
declare const WIDGET_READY: EventDefinition<unknown>;
declare const WIDGET_RESIZE: EventDefinition<IWidgetResizePayload>;
declare const WIDGET_POSITION_CHANGE: EventDefinition<unknown>;
declare const WIDGET_SEARCH: EventDefinition<string>;
declare const SET_PROPERTY_VALUE: EventDefinition<ISetPropertyPayload>;
declare const SET_TIMEFRAME: EventDefinition<ISerializableTimeframe>;
declare const PREVIEW_EVENT: EventDefinition<IPreviewEventPayload>;
declare const DATA_SOURCE_BUSY: EventDefinition<IDataSourceBusyPayload>;
declare const DASHBOARD_EDIT_MODE: EventDefinition<boolean>;
declare const INTERACTION: EventDefinition<IInteractionPayload<any>>;
declare const SELECTION: EventDefinition<ISelection>;
declare const CHANGE_SELECTION: EventDefinition<ISelection>;
declare const SELECTED_ITEMS: EventDefinition<any[]>;
declare const DATA_SOURCE_INVOKED: EventDefinition<void>;
declare const DRILLDOWN: EventDefinition<unknown>;
declare const NOVA_DATASOURCE_INTERVAL_REFRESHER = "NOVA_DATASOURCE_INTERVAL_REFRESHER";
declare const NOVA_DATASOURCE_ADAPTER = "NOVA_DATASOURCE_ADAPTER";
declare const NOVA_TIMESERIES_DATASOURCE_ADAPTER = "NOVA_TIMESERIES_DATASOURCE_ADAPTER";
declare const NOVA_KPI_DATASOURCE_ADAPTER = "NOVA_KPI_DATASOURCE_ADAPTER";
declare const NOVA_DRILLDOWN_DATASOURCE_ADAPTER = "NOVA_DRILLDOWN_DATASOURCE_ADAPTER";
declare const NOVA_KPI_COLOR_PRIORITIZER = "NOVA_KPI_COLOR_PRIORITIZER";
declare const NOVA_TITLE_AND_DESCRIPTION_CONVERTER = "NOVA_TITLE_AND_DESCRIPTION_CONVERTER";
declare const NOVA_PROPORTIONAL_WIDGET_CHART_OPTIONS_CONVERTER = "NOVA_PROPORTIONAL_WIDGET_CHART_OPTIONS_CONVERTER";
declare const NOVA_KPI_TILES_CONVERTER = "NOVA_KPI_TILES_CONVERTER";
declare const NOVA_TIMESERIES_METADATA_CONVERTER = "NOVA_TIMESERIES_METADATA_CONVERTER";
declare const NOVA_TIMESERIES_SERIES_CONVERTER = "NOVA_TIMESERIES_SERIES_CONVERTER";
declare const NOVA_DASHBOARD_EVENT_PROXY = "NOVA_DASHBOARD_EVENT_PROXY";
declare const NOVA_TABLE_COLUMNS_CONVERTER = "NOVA_TABLE_COLUMNS_CONVERTER";
declare const NOVA_TABLE_FILTERS_CONVERTER = "NOVA_TABLE_FILTERS_CONVERTER";
declare const NOVA_TABLE_SCROLL_TYPE_CONVERTER = "NOVA_TABLE_SCROLL_TYPE_CONVERTER";
declare const NOVA_TABLE_DATASOURCE_ADAPTER = "NOVA_TABLE_DATASOURCE_ADAPTER";
declare const NOVA_GENERIC_CONVERTER = "NOVA_GENERIC_CONVERTER";
declare const NOVA_GENERIC_ARRAY_CONVERTER = "NOVA_GENERIC_ARRAY_CONVERTER";
declare const NOVA_KPI_SECTION_CONVERTER = "NOVA_KPI_SECTION_CONVERTER";
declare const NOVA_TIMESERIES_TILE_INDICATOR_DATA_CONVERTER = "NOVA_TIMESERIES_TILE_INDICATOR_DATA_CONVERTER";
declare const NOVA_LOADING_ADAPTER = "NOVA_LOADING_ADAPTER";
declare const NOVA_STATUS_CONTENT_FALLBACK_ADAPTER = "NOVA_STATUS_CONTENT_FALLBACK_ADAPTER";
declare const NOVA_KPI_STATUS_CONTENT_FALLBACK_ADAPTER = "NOVA_KPI_STATUS_CONTENT_FALLBACK_ADAPTER";
declare const NOVA_KPI_SCALE_SYNC_BROKER = "NOVA_KPI_SCALE_SYNC_BROKER";
declare const NOVA_URL_INTERACTION_HANDLER = "NOVA_URL_INTERACTION_HANDLER";
declare const NOVA_EVENT_BUS_DEBUGGER = "NOVA_EVENT_BUS_DEBUGGER";
declare const NOVA_PIZZAGNA_BROADCASTER = "NOVA_PIZZAGNA_BROADCASTER";
declare const NOVA_VIRTUAL_VIEWPORT_MANAGER = "NOVA_VIRTUAL_VIEWPORT_MANAGER";
declare const NOVA_TABLE_FORMATTERS_REGISTRY = "NOVA_TABLE_FORMATTERS_REGISTRY";
declare const NOVA_KPI_FORMATTERS_REGISTRY = "NOVA_KPI_FORMATTERS_REGISTRY";
declare const NOVA_RISK_SCORE_FORMATTERS_REGISTRY = "NOVA_RISK_SCORE_FORMATTERS_REGISTRY";
declare const NOVA_PROPORTIONAL_CONTENT_FORMATTERS_REGISTRY = "NOVA_PROPORTIONAL_CONTENT_FORMATTERS_REGISTRY";
declare const NOVA_TEST_REGISTRY = "NOVA_TEST_REGISTRY";
declare const NOVA_CONFIGURATOR_DATA_SOURCE_MANAGER = "NOVA_CONFIGURATOR_DATA_SOURCE_MANAGER";
declare const CHART_METRIC_REMOVE: IEventDefinition<IEvent<IRemoveMetricPayload>>;

type IRegistryMap<T> = Record<string, T>;
declare abstract class RegistryService<T = object> implements OnDestroy {
    private logger;
    private className?;
    protected state$: BehaviorSubject<IRegistryMap<T>>;
    stateChanged$: Observable<T[]>;
    private _stateVersion;
    get stateVersion(): string;
    private _isEmpty;
    get isEmpty(): boolean;
    protected constructor(logger: LoggerService, className?: string | undefined);
    addItems(items: T[], options?: IRegistryAddOptions): void;
    getItem(id: string): T | undefined;
    getItems(): T[];
    reset(): void;
    ngOnDestroy(): void;
    protected abstract getItemKey(item: T): string;
    private updateStateFlags;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegistryService<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RegistryService<any>, never, never, {}, {}, never, never, true, never>;
}

declare abstract class FormatterRegistryService<TFormatter extends IFormatterDefinition = IFormatterDefinition> extends RegistryService<TFormatter> {
    /** @deprecated use 'stateChanged$' instead - NUI-5852 */
    formattersStateChanged$: Observable<TFormatter[]>;
    /** @deprecated use 'addItems' instead - NUI-5852 */
    addFormatters(formatters: TFormatter[], options?: IAddFormattersOptions): void;
    /** @deprecated use 'getItems' instead - NUI-5852 */
    getFormatters(): TFormatter[];
    protected getItemKey(item: TFormatter): string;
}
declare class TableFormatterRegistryService extends FormatterRegistryService<ITableFormatterDefinition> {
    constructor(logger: LoggerService);
    static ɵfac: i0.ɵɵFactoryDeclaration<TableFormatterRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableFormatterRegistryService>;
}
declare class KpiFormattersRegistryService extends FormatterRegistryService<IFormatterDefinition> {
    constructor(logger: LoggerService);
    static ɵfac: i0.ɵɵFactoryDeclaration<KpiFormattersRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KpiFormattersRegistryService>;
}
declare class RiskScoreFormattersRegistryService extends FormatterRegistryService<IFormatterDefinition> {
    constructor(logger: LoggerService);
    static ɵfac: i0.ɵɵFactoryDeclaration<RiskScoreFormattersRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RiskScoreFormattersRegistryService>;
}
declare class ProportionalDonutContentFormattersRegistryService extends FormatterRegistryService<IFormatterDefinition> {
    constructor(logger: LoggerService);
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalDonutContentFormattersRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProportionalDonutContentFormattersRegistryService>;
}
declare class ProportionalLegendFormattersRegistryService extends FormatterRegistryService<IFormatterDefinition> {
    constructor(logger: LoggerService);
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalLegendFormattersRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProportionalLegendFormattersRegistryService>;
}

declare class WidgetTypesService {
    private widgetTypes;
    constructor();
    registerWidgetType(key: string, version: number, widgetType: IWidgetTypeDefinition): void;
    getWidgetType(type: string, version?: number): IWidgetTypeDefinition;
    /**
     * Take a widget and merge it with the pizzagna of its type
     *
     * @param widget
     *
     * @return new reference of a widget including the pizzagna of its type
     */
    mergeWithWidgetType(widget: IWidget): IWidget;
    setNode(widgetTemplate: IWidgetTypeDefinition, section: "widget" | "configurator", pathKey: string, value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetTypesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetTypesService>;
}

declare class DynamicComponentCreator {
    getPizzagnaUpdatedWithComponents(pizzagna: IPizzagna, parentPath: string, componentIds: string[]): IPizzagna;
    private getPizzagnaWithChildren;
    private updateChildPizzagna;
    private getPizzagnaWithNodesSet;
    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentCreator, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentCreator>;
}

interface IPizzagnaProperty {
    pizzagnaKey?: string;
    componentId: string;
    providerKey?: string;
    propertyPath: string[];
}
declare function getPizzagnaPropertyPath(definition: IPizzagnaProperty): string;

/**
 * This service allows pizzagna sub-components to read data of other components and initiate changes of property values
 */
declare class PizzagnaService {
    private eventBus;
    private dynamicComponentCreator;
    constructor(eventBus: EventBus<IEvent>, dynamicComponentCreator: DynamicComponentCreator);
    pizzagna: IPizzagna;
    pizzaChanged: ReplaySubject<IPizza>;
    private components;
    updatePizzagna(pizzagna: IPizzagna): void;
    updateComponents(components: IPizza): void;
    getComponent(refId: string): IComponentConfiguration;
    setProperty(property: IPizzagnaProperty | string, value: any): void;
    createComponentsFromTemplateWithProperties(parentPath: string, components: any): void;
    createComponentsFromTemplate(parentPath: string, componentIds: string[]): void;
    removeComponents(ids: string | string[]): void;
    private removeComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<PizzagnaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PizzagnaService>;
}

declare class PizzagnaComponent implements OnChanges {
    pizzagnaService: PizzagnaService;
    logger: LoggerService;
    eventBus: EventBus<IEvent>;
    rootNode: string;
    get pizzagna(): IPizzagna;
    set pizzagna(value: IPizzagna);
    private _pizzagna;
    private _pizzagnaBuffer;
    outputs: string[];
    pizzagnaChange: EventEmitter<IPizzagna>;
    output: EventEmitter<IEvent<any>>;
    pizza: Record<string, IComponentConfiguration>;
    constructor(pizzagnaService: PizzagnaService, logger: LoggerService, eventBus: EventBus<IEvent>);
    ngOnChanges(changes: SimpleChanges): void;
    onOutput(event: IEvent): void;
    /**
     * This takes all the pizzagna layers and merges them into one component pizza
     *
     * @param pizza
     * @param previousPizzagna
     * @param currentPizzagna
     */
    private mergePizzagnaIntoPizza;
    private getLayerChanges;
    private getLayerSafe;
    static ɵfac: i0.ɵɵFactoryDeclaration<PizzagnaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PizzagnaComponent, "nui-pizzagna", never, { "rootNode": { "alias": "rootNode"; "required": false; }; "pizzagna": { "alias": "pizzagna"; "required": false; }; "outputs": { "alias": "outputs"; "required": false; }; }, { "pizzagnaChange": "pizzagnaChange"; "output": "output"; }, never, never, false, never>;
}

interface IComponentPortalBundle<T> {
    portal: ComponentPortal<T>;
    attached?: (componentRef: ComponentRef<T>) => void;
}
interface IConfiguratorSource {
    dashboardComponent: DashboardComponent;
    widget?: IWidget;
    previewPizzagnaComponent?: () => PizzagnaComponent;
}
interface IConfigurator<T = any> extends IConfiguratorSource {
    trySubmit?: WidgetUpdateOperation;
    portalBundle?: IComponentPortalBundle<T>;
}
interface IWidgetSelector<T = any> extends IConfigurator<T> {
    widgetSelectionComponentType: Function;
}
interface IWidgetEditor<T = any> extends IConfigurator<T> {
    formPizzagna: IPizzagna;
    paths: Record<string, string>;
}
type WidgetUpdateOperation = (widget: IWidget, source: IConfiguratorSource) => Observable<IWidget>;
type WidgetRemovalOperation = (widgetId: string, source: IConfiguratorSource) => Observable<string>;

interface IDashboard {
    widgets: IWidgets;
    positions: Record<string, GridsterItem>;
}
interface IDashboardBelowFoldLazyLoadingConfig {
    enabled: boolean;
    configuration?: {
        reloadWidgetsOnScroll: boolean;
    };
}
interface IDashboardPersistenceHandler {
    trySubmit?: WidgetUpdateOperation;
    tryRemove?: WidgetRemovalOperation;
}

declare class WidgetConfigurationService {
    private widget;
    updateWidget(widget: IWidget): void;
    getWidget(): IWidget;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetConfigurationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetConfigurationService>;
}

interface IWidgetEvent extends IEvent {
    widgetId?: string;
}
/**
 * Configuration of WidgetToDashboardEventProxy
 */
interface IWidgetToDashboardEventProxyConfiguration extends IProperties {
    /**
     * List of events that are transmitted from widget to dashboard
     */
    upstreams?: string[];
    /**
     * List of events that are transmitted from dashboard to widget
     */
    downstreams?: string[];
}
/**
 * This provider transmits events between the dashboard event bus and the widget event bus.
 * It needs to be configured with the events that need transmission each way.
 */
declare class WidgetToDashboardEventProxyService implements IConfigurable, OnDestroy {
    private pizzagnaBus;
    private dashboardBus;
    private widgetConfigurationService;
    private eventRegistry;
    private pizzagnaService;
    private upstreamSubscriptions;
    private downstreamSubscriptions;
    private readonly destroy$;
    private component;
    private upstreams?;
    private downstreams?;
    providerKey: string;
    constructor(pizzagnaBus: EventBus<IEvent>, dashboardBus: EventBus<IEvent>, widgetConfigurationService: WidgetConfigurationService, eventRegistry: EventRegistryService, pizzagnaService: PizzagnaService);
    ngOnDestroy(): void;
    setComponent(component: any): void;
    updateConfiguration(properties: IWidgetToDashboardEventProxyConfiguration): void;
    addUpstream(stream: IEventDefinition): void;
    addDownstream(stream: IEventDefinition): void;
    private addStream;
    private registerUpstreamSubscriptions;
    private registerDownstreamSubscriptions;
    private registerSubscriptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetToDashboardEventProxyService, [null, { optional: true; }, { optional: true; }, null, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetToDashboardEventProxyService>;
}

declare class DashboardComponent implements OnChanges, AfterViewInit {
    readonly eventBus: EventBus<IWidgetEvent>;
    gridsterConfig: GridsterConfig;
    get dashboard(): IDashboard;
    set dashboard(value: IDashboard);
    private _dashboard;
    dashboardBuffer: IDashboard | null;
    editMode: boolean;
    belowFoldLazyLoadingConfig: IDashboardBelowFoldLazyLoadingConfig;
    gridsterConfigChange: EventEmitter<GridsterConfig>;
    dashboardChange: EventEmitter<IDashboard>;
    get hostClass(): boolean;
    gridster: GridsterComponent;
    gridsterItems: QueryList<GridsterItemComponent>;
    gridsterItemsVisibilityMap: Record<string, boolean>;
    constructor(eventBus: EventBus<IWidgetEvent>);
    ngAfterViewInit(): void;
    onGridsterScroll(): void;
    ngOnChanges(changes: SimpleChanges): void;
    orderWidgets: (a: KeyValue<string, IWidget>, b: KeyValue<string, IWidget>) => number;
    trackByFn: (index: number, item: KeyValue<string, IWidget>) => string;
    onWidgetChange(widget: IWidget): void;
    updateWidget(widget: IWidget): void;
    removeWidget(widgetId: string, removePosition?: boolean): void;
    shouldWidgetRender(key: string): boolean;
    private updateWidgetPosition;
    private emitWidgetResize;
    private hookEvent;
    private calculateWidgetsVisibility;
    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardComponent, "nui-dashboard", never, { "gridsterConfig": { "alias": "gridsterConfig"; "required": false; }; "dashboard": { "alias": "dashboard"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "belowFoldLazyLoadingConfig": { "alias": "belowFoldLazyLoadingConfig"; "required": false; }; }, { "gridsterConfigChange": "gridsterConfigChange"; "dashboardChange": "dashboardChange"; }, never, never, false, never>;
}

declare class EmbeddedContentComponent implements IHasChangeDetector, OnInit, OnChanges {
    changeDetector: ChangeDetectorRef;
    private document;
    private domSanitizer;
    static lateLoadKey: string;
    mode: EmbeddedContentMode;
    customEmbeddedContent: string;
    sanitized: boolean;
    elementClass: string;
    anchor: ElementRef;
    constructor(changeDetector: ChangeDetectorRef, document: Document, domSanitizer: DomSanitizer);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private validateAndApplyEmbeddedContent;
    private sanitizeContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmbeddedContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmbeddedContentComponent, "nui-embedded-content", never, { "mode": { "alias": "mode"; "required": false; }; "customEmbeddedContent": { "alias": "customEmbeddedContent"; "required": false; }; "sanitized": { "alias": "sanitized"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * This directive assigns a "widgetId" property to host gridster item. We need it there because moving and resizing the widget with gridster only contains
 * gridster position data and gridster component payload, so we need to identify which widget that event belongs to.
 */
declare class GridsterItemWidgetIdDirective implements OnChanges {
    private gridsterItem;
    nuiGridsterItemWidgetId: string;
    constructor(gridsterItem: GridsterItemComponent);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterItemWidgetIdDirective, [{ host: true; self: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GridsterItemWidgetIdDirective, "[nuiGridsterItemWidgetId]", never, { "nuiGridsterItemWidgetId": { "alias": "nuiGridsterItemWidgetId"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum KpiFormatterTypes {
    Value = "Value"
}
interface IKpiData {
    id?: string;
    value?: any;
    units?: string;
    label?: string;
    backgroundColor?: string;
    textColor?: string;
    fontSize?: string;
    numberFormat?: string;
    link?: string;
    margin?: number;
    [key: string]: any;
}
interface IKpiConfiguration {
    interactive?: boolean;
    formatters?: IKpiFormattersConfiguration;
}
type IKpiFormattersConfiguration = Partial<Record<KpiFormatterTypes | string, {
    formatter: IFormatter;
}>>;
type IKpiFormatterProperties = Partial<Record<KpiFormatterTypes | string, any>>;

declare class KpiComponent implements IHasChangeDetector, OnChanges {
    changeDetector: ChangeDetectorRef;
    dataSource: IDataSource;
    eventBus: EventBus<IEvent>;
    static lateLoadKey: string;
    widgetData: IKpiData;
    backgroundColor: string;
    syncValuesBroker: IBroker[];
    configuration: IKpiConfiguration;
    busy: boolean;
    elementClass: string;
    formattersProperties: IKpiFormatterProperties;
    defaultColor: string;
    get interactive(): boolean;
    constructor(changeDetector: ChangeDetectorRef, dataSource: IDataSource, eventBus: EventBus<IEvent>);
    onInteraction(): void;
    getScaleBroker(id: string): IBroker | undefined;
    ngOnChanges(changes: SimpleChanges): void;
    get showEmpty(): boolean;
    /**
     * Iterates over formatters and maps their properties from the data
     *
     * @param formattersConfiguration
     */
    private getFormatterProperties;
    static ɵfac: i0.ɵɵFactoryDeclaration<KpiComponent, [null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KpiComponent, "nui-kpi", never, { "widgetData": { "alias": "widgetData"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "syncValuesBroker": { "alias": "syncValuesBroker"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; "busy": { "alias": "busy"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum RiskScoreFormatterTypes {
    Value = "Value"
}
interface IRiskScoreData {
    id?: string;
    value?: number;
    minValue?: number;
    maxValue?: number;
    label?: string;
    description?: string;
    backgroundColor?: string;
    textColor?: string;
    fontSize?: string;
    numberFormat?: string;
    link?: string;
    [key: string]: any;
}
interface IRiskScoreConfiguration {
    interactive?: boolean;
    formatters?: IRiskScoreFormattersConfiguration;
}
type IRiskScoreFormattersConfiguration = Partial<Record<RiskScoreFormatterTypes | string, {
    formatter: IFormatter;
}>>;
type IRiskScoreFormatterProperties = Partial<Record<RiskScoreFormatterTypes | string, any>>;

declare class RiskScoreTileComponent implements IHasChangeDetector, OnChanges {
    changeDetector: ChangeDetectorRef;
    dataSource: IDataSource;
    eventBus: EventBus<IEvent>;
    static lateLoadKey: string;
    widgetData: IRiskScoreData;
    syncValuesBroker: IBroker[];
    configuration: IRiskScoreConfiguration;
    busy: boolean;
    elementClass: string;
    formattersProperties: IRiskScoreFormatterProperties;
    defaultColor: string;
    get interactive(): boolean;
    constructor(changeDetector: ChangeDetectorRef, dataSource: IDataSource, eventBus: EventBus<IEvent>);
    onInteraction(): void;
    getScaleBroker(id: string): IBroker | undefined;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Iterates over formatters and maps their properties from the data
     *
     * @param formattersConfiguration
     */
    private getFormatterProperties;
    static ɵfac: i0.ɵɵFactoryDeclaration<RiskScoreTileComponent, [null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RiskScoreTileComponent, "nui-risk-score-tile", never, { "widgetData": { "alias": "widgetData"; "required": false; }; "syncValuesBroker": { "alias": "syncValuesBroker"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; "busy": { "alias": "busy"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * This service handles scale creation and configuration for the timeseries widget
 */
declare class TimeseriesScalesService {
    private unitConversionService;
    private unitConversionPipe;
    constructor(unitConversionService: UnitConversionService);
    /**
     * Creates a scale based on given configuration
     *
     * @param scaleConfig
     */
    getScale(scaleConfig: ITimeseriesScaleConfig, units: UnitOption, widgetConfig?: ITimeseriesWidgetConfig): IScale<any>;
    /**
     * Currently only TimeIntervalScale has configuration
     *
     * @param scale
     * @param scaleConfig
     */
    updateConfiguration(scale: IScale<any>, scaleConfig: ITimeseriesScaleConfig, widgetConfig?: ITimeseriesWidgetConfig): void;
    private getStackedBarScaleDomain;
    private getLineScaleDomain;
    private getStackedAreaScaleDomain;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesScalesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TimeseriesScalesService>;
}

declare abstract class TimeseriesChartComponent<T = ITimeseriesWidgetSeriesData> implements OnChanges, OnDestroy, OnInit {
    protected eventBus: EventBus<IEvent>;
    timeseriesScalesService: TimeseriesScalesService;
    dataSource: IDataSource;
    widgetData: ITimeseriesOutput<T>;
    configuration: ITimeseriesWidgetConfig;
    protected scales: IXYScales;
    protected destroy$: Subject<void>;
    protected buildChart$: Subject<void>;
    protected resetChart: boolean;
    protected chartBuilt: boolean;
    get seriesInteractive(): boolean;
    protected constructor(eventBus: EventBus<IEvent>, timeseriesScalesService: TimeseriesScalesService, dataSource: IDataSource);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    protected applyPreviousTransformer(previousData: any): void;
    protected transformSeriesData(serie: ITimeseriesWidgetData<T>): void;
    updateYAxisDomain(): void;
    removeMetric(metricId: string): void;
    /** Updates chart data. */
    protected abstract updateChartData(): void;
    protected abstract buildChart(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesChartComponent<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TimeseriesChartComponent<any>, never, never, { "widgetData": { "alias": "widgetData"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; }, {}, never, never, true, never>;
}

interface ITransformerDescription {
    displayName: string;
    transformer?: (data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean) => ITimeseriesWidgetSeriesData[];
}
declare abstract class XYChartComponent extends TimeseriesChartComponent implements OnChanges, OnDestroy, IHasChangeDetector {
    protected eventBus: EventBus<IEvent>;
    timeseriesScalesService: TimeseriesScalesService;
    changeDetector: ChangeDetectorRef;
    chartAssist: ChartAssist;
    valueAccessorKey: string;
    collectionId: string;
    zoomPlugins: TimeseriesWidgetZoomPlugin[];
    protected renderer: Renderer<IAccessors>;
    protected accessors: IAccessors;
    timeseriesChartTypes: typeof TimeseriesChartTypes;
    summarySerie: IChartAssistSeries<IAccessors>;
    summaryLegendBcgColor: string;
    summaryLegendColor: string;
    transformers: Map<TimeseriesTransformer, ITransformerDescription>;
    constructor(eventBus: EventBus<IEvent>, dataSource: IDataSource, timeseriesScalesService: TimeseriesScalesService, changeDetector: ChangeDetectorRef);
    protected abstract createAccessors(colorProvider: IValueProvider<string>): IAccessors;
    protected abstract createChartAssist(palette: ChartPalette): ChartAssist;
    mapSeriesSet(data: any[], scales: IXYScales): IChartAssistSeries<IAccessors>[];
    /** Checks if legend should be shown. */
    hasLegend(): boolean;
    /** Checks if legend should be aligned to right. */
    legendShouldBeAlignedRight(): boolean;
    onPrimaryDescClick(event: MouseEvent, legendSeries: IChartAssistSeries<IAccessors>): void;
    /** Updates chart data. */
    protected updateChartData(): void;
    /**
     * Initialize chart
     */
    protected buildChart(): void;
    /**
     * Subscribe to chart events and emit
     */
    protected setupInteraction(): void;
    displayLegendMenu(): boolean;
    displayDeleteButton(): boolean;
    transformData(metricId: string, trId: TimeseriesTransformer): void;
    getLegendValue(legendSeries: IChartAssistSeries<IAccessors<any>>, valueAccessorKey: string): string | number | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<XYChartComponent, [null, { optional: true; }, null, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<XYChartComponent>;
}

declare class LineChartComponent extends XYChartComponent {
    static lateLoadKey: string;
    constructor(eventBus: EventBus<IEvent>, dataSource: IDataSource, timeseriesScalesService: TimeseriesScalesService, changeDetector: ChangeDetectorRef);
    protected createAccessors(colorProvider: IValueProvider<string>): IAccessors;
    protected createChartAssist(palette: ChartPalette): ChartAssist;
    static ɵfac: i0.ɵɵFactoryDeclaration<LineChartComponent, [null, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LineChartComponent, "nui-line-chart", never, {}, {}, never, never, false, never>;
}

declare class LoadingComponent implements IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    active: boolean;
    constructor(changeDetector: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "nui-loading", never, { "active": { "alias": "active"; "required": false; }; }, {}, never, never, false, never>;
}

interface IProportionalDonutContentAggregatorProperties {
    /** Metric Id, case sensitive. */
    activeMetricId?: string;
    [key: string]: any;
}
interface IProportionalDonutContentAggregator {
    aggregatorType: string;
    properties?: IProportionalDonutContentAggregatorProperties;
}
interface IAggregatorChartData extends Pick<IChartSeries<any>, "id" | "data"> {
    [key: string]: any;
}
type IProportionalAggregatorOrigin = Array<IAggregatorChartData>;
type IProportionalAggregatorFn = ((origin: IProportionalAggregatorOrigin, properties?: IProportionalDonutContentAggregatorProperties) => string) & {
    aggregatorType: string;
};
interface IProportionalDonutContentAggregatorDefinition {
    aggregatorType: string;
    label: string;
    fn: IProportionalAggregatorFn;
    properties?: IProportionalDonutContentAggregatorProperties;
    configurationComponent?: string;
}

declare enum ProportionalWidgetChartTypes {
    DonutChart = "DonutChart",
    PieChart = "PieChart",
    VerticalBarChart = "VerticalBarChart",
    HorizontalBarChart = "HorizontalBarChart"
}
interface IProportionalWidgetChartTypeConfiguration {
    id: ProportionalWidgetChartTypes;
    label: string;
}
interface ITickLabelConfig {
    maxWidth: Partial<IAllAround<number>>;
}
interface IProportionalWidgetChartOptions {
    type: ProportionalWidgetChartTypes;
    contentFormatter?: IFormatter;
    legendPlacement?: LegendPlacement;
    legendFormatter?: IFormatter;
    chartFormatterComponentType?: string;
    donutContentConfig?: IDonutContentConfig;
    horizontalBarTickLabelConfig?: ITickLabelConfig;
}
interface IProportionalWidgetConfig {
    chartDonutContentLabel?: string;
    chartDonutContentIcon?: string;
    chartOptions: IProportionalWidgetChartOptions;
    /** Chart and legend will emit an INTERACTION event on click if this property is enabled */
    interactive?: boolean;
    chartColors?: string[] | {
        [key: string]: string;
    };
    /** set "true" if you want for widget configuration to override colors that come built-in data */
    prioritizeWidgetColors?: boolean;
}
interface ILegendFormat {
    displayValue: string;
    formatKey: string;
}
interface IProportionalWidgetChartEditorOptions {
    chartTypes: ProportionalWidgetChartTypes[];
    legendPlacementOptions: ILegendPlacementOption[];
    legendFormats: Array<ILegendFormat>;
    legendFormatters: IFormatterDefinition[];
    contentFormatters?: IFormatterDefinition[];
}
interface IDonutContentConfig {
    formatter: IFormatter;
    aggregator: IProportionalDonutContentAggregator;
}
interface IProportionalDataFieldsConfig extends IDataFieldsConfig {
    chartSeriesDataFields$: BehaviorSubject<IDataField[]>;
}
interface IProportionalWidgetData extends IChartAssistSeries<IAccessors> {
    link?: string;
}

/** @ignore