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 */
declare class ProportionalWidgetComponent implements AfterViewInit, OnChanges, IHasChangeDetector, OnDestroy {
    changeDetector: ChangeDetectorRef;
    private ngZone;
    private kvDiffers;
    private eventBus;
    private dataSource;
    private logger;
    static lateLoadKey: string;
    private static NO_SWITCH_LAYOUT_INTERVAL_SIZE;
    private static MAX_ROW_LAYOUT_SIZE;
    private static TICK_LABEL_MAX_WIDTH;
    widgetData: IProportionalWidgetData[];
    configuration: IProportionalWidgetConfig;
    elementClass: string;
    seriesToIconMap: {
        [seriesId: string]: string;
    };
    chartAssist: ChartAssist;
    accessors: IAccessors;
    donutContentPlugin: ChartDonutContentPlugin | null;
    legendUnitLabel: string;
    legendFormatter: IFormatter | undefined;
    contentFormatter: IFormatter | undefined;
    chartFormatterComponentType: string | undefined;
    contentFormatterProperties: any;
    prioritizedGridRows: {
        right: boolean;
        bottom: boolean;
    };
    private differ;
    private renderer;
    private scales;
    private chartPalette;
    private proportionalWidgetResizeObserver;
    private unitConversionPipe;
    private gridContainer;
    private chartTypeSubscription$;
    get interactive(): boolean;
    constructor(changeDetector: ChangeDetectorRef, ngZone: NgZone, kvDiffers: KeyValueDiffers, eventBus: EventBus<IEvent>, dataSource: IDataSource, logger: LoggerService, unitConversionService: UnitConversionService);
    computeLegendTileValue(legendSeries: unknown): string | undefined;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    getContentFormatterProperties(): void;
    /** Checks if chart is donut. */
    isDonutChart(): boolean;
    /** Checks if chart is radial. */
    isRadialChart(): boolean;
    /** Checks if legend should be shown. */
    hasLegend(): boolean;
    /** Checks if legend should be aligned to right. */
    legendShouldBeAlignedRight(): boolean;
    onInteraction(data: any): void;
    /** Configures the chart options */
    private buildChart;
    private handleGridFlowOnResize;
    private applyTickLabelMaxWidths;
    private onResize;
    private isContainerInNoSwitchLayoutInterval;
    private containerHasRowLayoutWidth;
    /** Builds the chart */
    private updateChart;
    private updateChartColors;
    private getDataDriverColorProvider;
    private getConfigurationColorProvider;
    get isEmpty(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProportionalWidgetComponent, "nui-proportional-widget", never, { "widgetData": { "alias": "widgetData"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; "seriesToIconMap": { "alias": "seriesToIconMap"; "required": false; }; }, {}, never, never, false, never>;
}

declare abstract class BaseLayout implements IHasChangeDetector, OnChanges, DoCheck, OnDestroy {
    changeDetector: ChangeDetectorRef;
    protected pizzagnaService: PizzagnaService;
    protected logger: LoggerService;
    nodeComponentsConfigs: IComponentConfiguration[];
    nodeConfigs: IComponentConfiguration[];
    protected destroyed$: Subject<void>;
    template: Partial<IComponentConfiguration>;
    constructor(changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService);
    abstract getNodes(): string[];
    ngOnChanges(changes: SimpleChanges): void;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    trackByFn(index: number, node: IComponentConfiguration): string;
    private checkNodeConfigs;
    private updateNodeComponentConfigs;
    private updateNodeConfigs;
    private getNodeComponentsConfigs;
    private getTemplateChangeForNodes;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseLayout, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseLayout>;
}

declare class StackComponent extends BaseLayout implements OnInit, OnDestroy {
    static lateLoadKey: string;
    nodes: string[];
    direction: string;
    elementClass: string;
    classNames: string;
    readonly defaultClassNames = "h-100 w-100 d-flex";
    constructor(changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    getNodes(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<StackComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StackComponent, "nui-stack", never, { "nodes": { "alias": "nodes"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class StackedAreaChartComponent 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<StackedAreaChartComponent, [null, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StackedAreaChartComponent, "nui-stacked-area-chart", never, {}, {}, never, never, false, never>;
}

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

declare class StackedPercentageAreaChartComponent 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<StackedPercentageAreaChartComponent, [null, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StackedPercentageAreaChartComponent, "nui-stacked-percentage-area-chart", never, {}, {}, never, never, false, never>;
}

declare class StatusBarChartComponent extends TimeseriesChartComponent<ITimeseriesWidgetStatusData> implements OnInit {
    private iconService;
    timeseriesScalesService: TimeseriesScalesService;
    changeDetector: ChangeDetectorRef;
    protected eventBus: EventBus<IEvent>;
    static lateLoadKey: string;
    chartAssist: SparkChartAssist;
    collectionId: string;
    protected accessors: StatusAccessors;
    protected renderer: Renderer<IAccessors>;
    private chartUpdate$;
    zoomPlugins: TimeseriesWidgetZoomPlugin[];
    timeseriesChartTypes: typeof TimeseriesChartTypes;
    summaryLegendBcgColor: string;
    summaryLegendColor: string;
    constructor(iconService: IconService, dataSource: IDataSource, timeseriesScalesService: TimeseriesScalesService, changeDetector: ChangeDetectorRef, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    getDataPointData(series: IChartAssistSeries<IAccessors>, key: string): any;
    protected buildChart(): void;
    protected updateChartData(): void;
    /**
     * Transforms standard timeseries x/y data so that it can be understood by a status chart
     *
     * @param data The data to transform
     * @param isIntervalProgression Whether the data should be treated as continuous or occurring at a regular interval
     *
     * @returns The transformed data
     */
    protected transformData(data: ITimeseriesWidgetStatusData[], isIntervalProgression: boolean): IStatusData[];
    private setGridConfigFromConfiguration;
    displayDeleteButton(): boolean;
    isStatusChart(): boolean;
    getDescriptionSecondary(series: IChartAssistSeries<IAccessors>, index: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusBarChartComponent, [null, { optional: true; }, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatusBarChartComponent, "nui-status-bar-chart", never, {}, {}, never, never, false, never>;
}
interface IStatusData {
    start: Date;
    end: Date;
    thick?: boolean;
    color?: string;
    icon?: string;
}

interface ITableWidgetColumnConfig {
    id: string;
    label: string;
    /**
     * Possibility to show or hide column without removing it
     */
    isActive?: boolean;
    /**
     * Formatter configuration
     */
    formatter?: IFormatter;
    /**
     * Width of the column
     */
    width?: number;
    /**
     * If column is sortable
     */
    sortable?: boolean;
}
interface ITableWidgetConfig {
    reorderable?: boolean;
    columns: Array<ITableWidgetColumnConfig>;
    sortable?: boolean;
    sorterConfiguration: ITableWidgetSorterConfig;
    /**
     * Allows to choose row selection behavior of a table.
     * Can be None | Multi | Single | Radio.
     */
    selectionConfiguration?: TableWidgetSelectionConfig;
    /**
     * @deprecated Use scrollType and set it to "infinite" instead
     */
    hasVirtualScroll?: boolean;
    scrollType?: ScrollType;
    /**
     * Makes table rows interactive.
     * Disabled if 'selectable' is set to true.
     */
    interactive?: boolean;
    headerTooltipsEnabled?: boolean;
    scrollActivationDelayMs?: number;
    /**
     * Selectors for target elements to be ignored for row click.
     *
     * Default value ["button", "input[type='button']", "a[href]"]
     */
    interactionIgnoredSelectors?: string[];
    searchConfiguration?: {
        enabled: boolean;
        searchTerm?: string;
        searchDebounce?: number;
        maxSearchLength?: number;
    };
    paginatorConfiguration?: ITableWidgetPaginatorConfig;
}
interface ITableWidgetSorterConfig {
    descendantSorting: boolean;
    sortBy: string;
}
interface ITableWidgetPaginatorConfig {
    pageSizeSet?: number[];
    pageSize?: number;
}
interface IPaginatorState {
    page: number;
    pageSize: number;
    pageSizeSet: number[];
    total: number;
}
declare enum ScrollType {
    virtual = "virtual",
    paginator = "paginator",
    default = "default"
}
interface ITableWidgetSelectionConfigEnabled extends ITableSelectionConfigEnabled {
    /**
     * Property name that is unique.
     * Needs to be set in order for selection to work in combination with filtering.
     *
     * Using property that is not unique across table data will result in a selection
     * of all rows with the same column value at once.

     @default "id"
     */
    trackByProperty?: string;
    /**
     * If clicking on row should select it.
     * True if selectionMode is set to "single".
     * @default false
     */
    clickableRow?: boolean;
    /**
     * Controls if the dropdown is needed for selection on other pages
     * Only available for the pagination
     */
    allPages?: boolean;
}
type TableWidgetSelectionConfig = ITableWidgetSelectionConfigEnabled | ITableSelectionConfigDisabled;

declare class DelayedMousePresenceDetectionDirective {
    enabled: boolean;
    mousePresentSubject: Subject<boolean>;
    delay: number;
    private timeout;
    onHostMouseenter(): void;
    onHostClick(): void;
    onHostMouseleave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DelayedMousePresenceDetectionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DelayedMousePresenceDetectionDirective, "[nuiDelayedMousePresenceDetection]", never, { "enabled": { "alias": "nuiDelayedMousePresenceDetection"; "required": false; }; "mousePresentSubject": { "alias": "mousePresentSubject"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PaginatorFeatureAddonService {
    defaultPaginatorState: IPaginatorState;
    paginatorState: IPaginatorState;
    private widget;
    private reinit$;
    initPaginator(widget: TableWidgetComponent): void;
    applyFilters(): void;
    private registerPaginator;
    private deregisterPaginator;
    private setPaginatorState;
    private updatePaginatorState;
    private listenPaginatorChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginatorFeatureAddonService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PaginatorFeatureAddonService>;
}

declare class SearchFeatureAddonService {
    private widget;
    private searchDebounceTime;
    private reinit$;
    initWidget(widget: TableWidgetComponent): void;
    private initSearch;
    private registerSearch;
    private deregisterSearch;
    private defineSearch;
    private watchSearchTerm;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchFeatureAddonService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SearchFeatureAddonService>;
}

declare class VirtualScrollFeatureAddonService {
    private widget;
    visibleItems: unknown[];
    initWidget(widget: TableWidgetComponent): void;
    initVirtualScroll(widget: TableWidgetComponent): void;
    private registerVirtualScroll;
    private deregisterVirtualScroll;
    /**
     * Subscribe to virtual scroll rendered items and fetches next items
     */
    subscribeToVirtualScroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualScrollFeatureAddonService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VirtualScrollFeatureAddonService>;
}

/**
 * @ignore
 */
declare class TableWidgetComponent implements AfterViewInit, OnChanges, OnDestroy, OnInit {
    eventBus: EventBus<IEvent>;
    dataSource: IDataSource;
    private widgetConfigurationService;
    changeDetector: ChangeDetectorRef;
    pizzagnaService: PizzagnaService;
    viewportManager: VirtualViewportManager;
    zone: NgZone;
    private el;
    private logger;
    private searchAddon;
    paginatorAddon: PaginatorFeatureAddonService;
    virtualScrollAddon: VirtualScrollFeatureAddonService;
    private formattersRegistryService;
    private selectorService;
    static lateLoadKey: string;
    widgetData: any[];
    componentId: string;
    configuration: ITableWidgetConfig;
    dataFields: IDataField[];
    totalItems: number;
    indentFromTop: number;
    sortable: boolean;
    delayedMousePresenceDetectionEnabled: boolean;
    elementClass: string;
    tableData: any[];
    headers: string[];
    sortedColumn: ISortedItem;
    columns: ITableWidgetColumnConfig[];
    columnsWidthMap: Map<string, number | undefined>;
    scrollType: ScrollType;
    tableContainerHeight: number;
    isSearchEnabled: boolean;
    searchTerm$: Subject<string>;
    searchValue: string;
    onDestroy$: Subject<void>;
    tableUpdate$: Subject<void>;
    mousePresent$: BehaviorSubject<boolean>;
    rowHeight: number;
    selection: ISelection;
    table: TableComponent<any>;
    paginator: PaginatorComponent;
    vscrollViewport?: CdkVirtualScrollViewport;
    tableRows: QueryList<ElementRef>;
    private sortFilter;
    private totalPages;
    private lastPageFetched;
    isBusy: boolean;
    private sortableSet;
    private formatters;
    private tableWidgetHeight;
    private readonly defaultColumnAlignment;
    private idle;
    isSearchLimitWarningDisplayed: i0.WritableSignal<boolean>;
    private readonly defaultMaxSearchLength;
    constructor(eventBus: EventBus<IEvent>, dataSource: IDataSource, widgetConfigurationService: WidgetConfigurationService, changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, viewportManager: VirtualViewportManager, zone: NgZone, el: ElementRef, logger: LoggerService, searchAddon: SearchFeatureAddonService, paginatorAddon: PaginatorFeatureAddonService, virtualScrollAddon: VirtualScrollFeatureAddonService, formattersRegistryService: TableFormatterRegistryService, selectorService: SelectorService);
    get headerTooltipsEnabled(): boolean;
    private _scrollBuffer;
    set scrollBuffer(value: number);
    private _range;
    get range(): number;
    set range(value: number);
    get interactive(): boolean;
    get clickableRow(): boolean;
    get hasVirtualScroll(): boolean;
    get hasPaginator(): boolean;
    get searchLimitMaxLength(): number;
    ngOnChanges(changes: SimpleChanges): void;
    resolveScrollType(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /** Checks if table should be displayed */
    shouldDisplayTable(): boolean;
    dataTrackBy(): (index: any, item: any) => any;
    columnTrackBy(index: number, item: ITableWidgetColumnConfig): string;
    /**
     * Handles updating of columns.
     * @param configuration
     */
    updateColumns(configuration: ITableWidgetConfig): void;
    /**
     * Takes widgetData from back-end, columns which are provided in table widget config and dataFields and maps them to data-format
     * which is acceptable by table component.
     * Also it can merge multiple data fields into one column. If you provide more than one dataFieldId in your
     * widget config, they will be merged to an object with needed data. This data can be passed to formatter and displayed
     * in one column.
     * @param widgetData
     * @param columns
     * @param dataFields
     * @returns any[]
     */
    mapTableData(widgetData: any[], columns: ITableWidgetColumnConfig[], dataFields: IDataField[]): any[];
    /**
     * Handles change of sorting. Gets sorted column from columns array.
     * @param event
     */
    onSortOrderChanged(event: ISortedItem): void;
    onSelectionChange(event: ISelection): void;
    onInteraction(row: any, event: MouseEvent): void;
    onSearchInputChanged(searchTerm: string): void;
    getColumnAlignment(column: ITableWidgetColumnConfig): TableAlignmentOptions;
    private setSortFilter;
    /**
     * Checks if column id has changed or if sorting order has changed
     * @param configuration
     */
    private isSortByUpdated;
    /**
     * Updates table columns and maps table data.
     */
    private updateTable;
    /**
     * Registers sorter filter.
     */
    private registerSorter;
    private setSortableSet;
    private flushTableData;
    private scrollTypeChanged;
    private getTableScrollRange;
    onPagerAction(page: any): void;
    private initPrefetchAddon;
    private resolveSortBy;
    private resolveSearch;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableWidgetComponent, [null, { optional: true; }, { optional: true; }, null, null, null, null, null, null, null, null, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableWidgetComponent, "nui-table-widget", never, { "widgetData": { "alias": "widgetData"; "required": false; }; "componentId": { "alias": "componentId"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; "dataFields": { "alias": "dataFields"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; "indentFromTop": { "alias": "indentFromTop"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "delayedMousePresenceDetectionEnabled": { "alias": "delayedMousePresenceDetectionEnabled"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; "range": { "alias": "range"; "required": false; }; }, {}, never, never, false, never>;
}

/** @ignore */
declare class TemplateLoadErrorComponent {
    static lateLoadKey: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateLoadErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateLoadErrorComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class TilesComponent extends BaseLayout implements OnDestroy, AfterViewInit {
    private ngZone;
    static lateLoadKey: string;
    nodes: string[];
    direction: string;
    elementClass: string;
    prioritizeGridRows: boolean;
    private gridItemsContainer;
    private tilesResizeObserver;
    constructor(changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    getNodes(): string[];
    private handleGridFlowOnResize;
    private onResize;
    static ɵfac: i0.ɵɵFactoryDeclaration<TilesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TilesComponent, "nui-tiles", never, { "nodes": { "alias": "nodes"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TimeframeSerializationService {
    convertToSerializable(timeframe: ITimeframe): ISerializableTimeframe;
    convertFromSerializable(timeframe: ISerializableTimeframe): ITimeframe;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeframeSerializationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TimeframeSerializationService>;
}

declare class TimeframeSelectionComponent implements OnChanges, OnInit, IHasChangeDetector {
    private pizzagnaService;
    timeframeService: TimeframeService;
    private tfSerialization;
    history: HistoryStorage<ITimeframe>;
    private dataSource;
    private eventBus;
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    currentTimeframe: ITimeframe;
    minDateAsMoment: Moment;
    maxDateAsMoment: Moment;
    componentId: string;
    minDate: string;
    maxDate: string;
    timeframe: ISerializableTimeframe;
    elementClass: string;
    constructor(pizzagnaService: PizzagnaService, timeframeService: TimeframeService, tfSerialization: TimeframeSerializationService, history: HistoryStorage<ITimeframe>, dataSource: IDataSource, eventBus: EventBus<IEvent>, changeDetector: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    onTimeframeChange(timeframe: ITimeframe): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeframeSelectionComponent, [null, null, null, null, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeframeSelectionComponent, "nui-timeframe-selection", never, { "componentId": { "alias": "componentId"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "timeframe": { "alias": "timeframe"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TimeseriesChartPresetService {
    presets: Record<TimeseriesChartPreset, IChartPreset>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesChartPresetService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TimeseriesChartPresetService>;
}

/** @ignore */
declare class TimeseriesWidgetComponent implements OnInit, OnChanges, IHasChangeDetector {
    timeseriesChartPresetService: TimeseriesChartPresetService;
    changeDetector: ChangeDetectorRef;
    zoomPluginsSyncService: TimeseriesZoomPluginsSyncService;
    static lateLoadKey: string;
    widgetData?: ITimeseriesOutput;
    configuration?: ITimeseriesWidgetConfig;
    collectionId?: string;
    elementClass: string;
    chartPreset: IChartPreset;
    zoomPlugins: TimeseriesWidgetZoomPlugin[];
    allowPopover: boolean;
    timeseriesWidgetProjectType: typeof TimeseriesWidgetProjectType;
    constructor(timeseriesChartPresetService: TimeseriesChartPresetService, changeDetector: ChangeDetectorRef, zoomPluginsSyncService: TimeseriesZoomPluginsSyncService);
    ngOnInit(): void;
    private getTimeseriesZoomPlugin;
    ngOnChanges(changes: SimpleChanges): void;
    /** Checks if chart should be shown. */
    shouldShowChart(): boolean;
    toggleLeave(): void;
    toggleEnter(): void;
    isExploringEnabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeseriesWidgetComponent, "nui-timeseries-widget", never, { "widgetData": { "alias": "widgetData"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; "collectionId": { "alias": "collectionId"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WidgetBodyComponent extends BaseLayout implements OnInit, OnDestroy {
    private eventBus;
    static lateLoadKey: string;
    /**
     * The component's id
     */
    componentId: string;
    /**
     * Keeps track of whether the dashboard is in edit mode
     */
    editMode: boolean;
    /**
     * Pizzagna key for the widget body content
     */
    content: string;
    /**
     * Optional class for styling
     */
    elementClass: string;
    classNames: string;
    readonly defaultClasses = "d-flex h-100 w-100";
    constructor(eventBus: EventBus<IEvent>, changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    getNodes: () => string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetBodyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetBodyComponent, "nui-widget-body", never, { "componentId": { "alias": "componentId"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "content": { "alias": "content"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WidgetBodyContentComponent extends BaseLayout implements OnChanges, OnInit, OnDestroy {
    static lateLoadKey: string;
    /**
     * The component's id
     */
    componentId: string;
    /**
     * The pizzagna node to use for the primary content
     */
    primaryContent: string;
    /**
     * When this property is populated, the component displays the associated
     * fallback content in place of the primary content
     */
    fallbackKey: string;
    /**
     * Map of content keys to pizzagna nodes
     */
    fallbackMap: Record<string, string>;
    /**
     * Optional class for styling
     */
    elementClass: string;
    classNames: string;
    readonly defaultClasses = "w-100";
    constructor(changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    getNodes(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetBodyContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetBodyContentComponent, "nui-widget-body-content", never, { "componentId": { "alias": "componentId"; "required": false; }; "primaryContent": { "alias": "primaryContent"; "required": false; }; "fallbackKey": { "alias": "fallbackKey"; "required": false; }; "fallbackMap": { "alias": "fallbackMap"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WidgetComponent implements OnChanges {
    private widgetConfigurationService;
    private widgetTypesService;
    widget: IWidget;
    widgetChange: EventEmitter<IWidget>;
    rootNode: string;
    constructor(widgetConfigurationService: WidgetConfigurationService, widgetTypesService: WidgetTypesService);
    ngOnChanges(changes: SimpleChanges): void;
    onPizzagnaChange(pizzagna: IPizzagna): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetComponent, "nui-widget", never, { "widget": { "alias": "widget"; "required": false; }; }, { "widgetChange": "widgetChange"; }, never, never, false, never>;
}

declare class ConfiguratorService {
    private componentFactoryResolver;
    private widgetTypesService;
    private injector;
    private appRef;
    private logger;
    private router;
    private renderer;
    private componentRef;
    private close$;
    constructor(componentFactoryResolver: ComponentFactoryResolver, widgetTypesService: WidgetTypesService, injector: Injector, appRef: ApplicationRef, logger: LoggerService, rendererFactory: RendererFactory2, router: Router);
    open(configurator: IConfigurator): Observable<void>;
    close(): void;
    handleSubmit: (confSource: IConfiguratorSource, trySubmit: WidgetUpdateOperation) => (source: Observable<IWidget>) => Observable<void>;
    private trySubmit;
    private updateDashboard;
    private appendComponentToBody;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorService, [null, null, null, null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorService>;
}

/** @ignore */
declare class ComponentPortalService {
    private componentRegistry;
    private logger;
    constructor(componentRegistry: ComponentRegistryService, logger: LoggerService);
    createComponentPortal(componentType: string | Function, injector: Injector | null): ComponentPortal<any>;
    createInjector(environment: IPortalEnvironment): Injector;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentPortalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentPortalService>;
}

declare class WidgetEditorService {
    private configuratorService;
    private componentPortalService;
    private ref;
    constructor(configuratorService: ConfiguratorService, componentPortalService: ComponentPortalService);
    open(widgetEditor: IWidgetEditor): Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetEditorService>;
}

declare class WidgetRemovalService {
    private logger;
    constructor(logger: LoggerService);
    handleRemove(dashboardComponent: DashboardComponent, widgetId: string, configuratorSource: IConfiguratorSource, tryRemove?: WidgetRemovalOperation): Observable<void>;
    private tryRemove;
    private updateDashboard;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetRemovalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetRemovalService>;
}

declare class WidgetEditorDirective implements OnInit, OnDestroy {
    private dashboardComponent;
    private widgetEditorService;
    private widgetRemovalService;
    private widgetTypesService;
    dashboardPersistenceHandler: IDashboardPersistenceHandler;
    private readonly destroy$;
    constructor(dashboardComponent: DashboardComponent, widgetEditorService: WidgetEditorService, widgetRemovalService: WidgetRemovalService, widgetTypesService: WidgetTypesService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetEditorDirective, [{ host: true; self: true; }, null, null, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WidgetEditorDirective, "[nuiWidgetEditor]", never, { "dashboardPersistenceHandler": { "alias": "nuiWidgetEditor"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * The interface for a dynamic link provider for widget header.
 */
interface IHeaderLinkProvider {
    /**
     * Generates a link url based on a user configured URL
     *
     * @param template a user configured URL
     */
    getLink(template: string): string;
}

declare class WidgetHeaderComponent implements OnInit, OnDestroy, AfterViewInit {
    private eventBus;
    pizzagnaService: PizzagnaService;
    changeDetector: ChangeDetectorRef;
    private eventProxy;
    private linkProvider;
    static lateLoadKey: string;
    componentId: string;
    editMode: boolean;
    /**
     * Boolean which shows or hides the edit button
     */
    editable: boolean;
    /**
     * Boolean which shows or hides the remove widget button
     */
    removable: boolean;
    /**
     * Boolean which adds ability to collapse widget header
     */
    collapsible: boolean;
    reloadable: boolean;
    title: string;
    titleIcon: string;
    titleIconSize: string;
    titleIconTooltip: string;
    subtitle: string;
    hideMenu: boolean;
    url: string;
    /**
     * Boolean which tells what state the widget header is in if collapsible
     */
    collapsed: boolean;
    get hostClass(): boolean;
    widgetHeaderCustomElement: ElementRef;
    withCustomElement: boolean;
    private onDestroy$;
    get state(): "expanded" | "collapsed";
    get hasTitleIcon(): boolean;
    get showTitleIcon(): boolean;
    linkTooltip: string;
    constructor(eventBus: EventBus<IEvent>, pizzagnaService: PizzagnaService, changeDetector: ChangeDetectorRef, eventProxy: WidgetToDashboardEventProxyService, linkProvider: IHeaderLinkProvider);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    removeWidget(): void;
    toggleCollapsed(): void;
    onEditWidget(): void;
    onReloadData(): void;
    prepareLink($event: MouseEvent): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetHeaderComponent, [null, null, null, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetHeaderComponent, "nui-widget-header", never, { "componentId": { "alias": "componentId"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "reloadable": { "alias": "reloadable"; "required": false; }; "title": { "alias": "title"; "required": false; }; "titleIcon": { "alias": "titleIcon"; "required": false; }; "titleIconSize": { "alias": "titleIconSize"; "required": false; }; "titleIconTooltip": { "alias": "titleIconTooltip"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "hideMenu": { "alias": "hideMenu"; "required": false; }; "url": { "alias": "url"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; }, {}, never, ["*"], false, never>;
}

interface IListWidgetConfiguration extends IFormatter {
    properties: Record<string, any>;
    itemProperties?: IProperties;
}
interface INavigationBarButtons {
    back?: {
        disabled?: boolean;
    };
    home?: {
        disabled?: boolean;
    };
}
interface INavigationBarConfig {
    buttons?: INavigationBarButtons;
    label?: string;
    isRoot?: boolean;
}

declare class ListWidgetComponent implements OnDestroy, OnInit, IHasChangeDetector, OnChanges {
    changeDetector: ChangeDetectorRef;
    private zone;
    private host;
    private eventBus;
    static lateLoadKey: string;
    data: any[];
    configuration: IListWidgetConfiguration;
    elementClass: string;
    private itemFormatterProps;
    private readonly destroy$;
    private widgetWidth;
    constructor(changeDetector: ChangeDetectorRef, zone: NgZone, host: ElementRef, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onListItemEvent(item: any): void;
    ngOnDestroy(): void;
    getPropsFor(item: any): any;
    shouldDisplayRepeat(): boolean;
    private calcItemProps;
    private initResizeObserver;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListWidgetComponent, "nui-list-widget", never, { "data": { "alias": "data"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ListLeafItemComponent implements IHasChangeDetector, OnInit {
    changeDetector: ChangeDetectorRef;
    eventBus: EventBus<IEvent>;
    static lateLoadKey: string;
    icon: string;
    status: string;
    detailedUrl: string;
    label: string;
    canNavigate: boolean;
    url: string;
    navigated: EventEmitter<ListLeafItemComponent>;
    searchTerm: string;
    protected readonly destroy$: Subject<void>;
    onButtonClick(): void;
    constructor(changeDetector: ChangeDetectorRef, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListLeafItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListLeafItemComponent, "nui-list-leaf-item", never, { "icon": { "alias": "icon"; "required": false; }; "status": { "alias": "status"; "required": false; }; "detailedUrl": { "alias": "detailedUrl"; "required": false; }; "label": { "alias": "label"; "required": false; }; "canNavigate": { "alias": "canNavigate"; "required": false; }; "url": { "alias": "url"; "required": false; }; }, { "navigated": "navigated"; }, never, never, false, never>;
}

declare class ListGroupItemComponent implements IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    id: string;
    label: string;
    statuses: Array<{
        [key: string]: any;
    }>;
    canNavigate: boolean;
    set widgetWidth(res: number);
    navigated: EventEmitter<ListGroupItemComponent>;
    isMedium: boolean;
    isSmall: boolean;
    constructor(changeDetector: ChangeDetectorRef);
    onButtonClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListGroupItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListGroupItemComponent, "nui-list-group-item", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "statuses": { "alias": "statuses"; "required": false; }; "canNavigate": { "alias": "canNavigate"; "required": false; }; "widgetWidth": { "alias": "widgetWidth"; "required": false; }; }, { "navigated": "navigated"; }, never, never, false, never>;
}

declare class ListNavigationBarComponent {
    changeDetector: ChangeDetectorRef;
    private eventBus;
    static lateLoadKey: string;
    navBarConfig: INavigationBarConfig;
    navigated: EventEmitter<any>;
    constructor(changeDetector: ChangeDetectorRef, eventBus: EventBus<IEvent>);
    onBack(): void;
    onHome(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListNavigationBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListNavigationBarComponent, "nui-navigation-bar", never, { "navBarConfig": { "alias": "navBarConfig"; "required": false; }; }, { "navigated": "navigated"; }, never, never, false, never>;
}

interface ISearchOnKeyUp {
    enabled: boolean;
    debounceTime?: number;
}
interface IWidgetSearchConfiguration {
    searchOnKeyUp?: ISearchOnKeyUp;
}

declare class WidgetSearchComponent implements OnInit, OnDestroy, OnChanges {
    private dataSource;
    eventBus: EventBus<IEvent>;
    static lateLoadKey: string;
    static defaultSearchDebounce: number;
    configuration: IWidgetSearchConfiguration;
    searchValue: string;
    enabled: boolean;
    searchTerm$: Subject<string>;
    readonly destroy$: Subject<void>;
    private searchTermSubscription;
    constructor(dataSource: IDataSource, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onSearchInputChanged(searchTerm: string): void;
    onSearch(searchTerm: string): void;
    ngOnDestroy(): void;
    private registerFilters;
    private handleSearchTermSubscription;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetSearchComponent, [{ optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetSearchComponent, "nui-widget-search", never, { "configuration": { "alias": "configuration"; "required": false; }; "searchValue": { "alias": "searchValue"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ProportionalContentAggregatorsRegistryService extends RegistryService<IProportionalDonutContentAggregatorDefinition> {
    constructor(logger: LoggerService);
    getItemKey(item: IProportionalDonutContentAggregatorDefinition): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalContentAggregatorsRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProportionalContentAggregatorsRegistryService>;
}

declare class ProviderRegistryService {
    private logger;
    staticProviders: IStaticProviders;
    constructor(logger: LoggerService);
    setProviders(providers: IStaticProviders): void;
    getProvider(providerId: string): StaticProvider;
    getProviderInstance(provider: StaticProvider, parentInjector: Injector): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProviderRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProviderRegistryService>;
}

declare class UnitTestRegistryService {
    static providerId: string;
    componentMap: any;
    providersMap: any;
    setComponent(component: any, componentId: string): void;
    setProviders(services: any, componentId: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UnitTestRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UnitTestRegistryService>;
}

declare const DEFAULT_COMPARATORS: IComparatorsDict;
declare class KpiColorComparatorsRegistryService {
    protected comparators: IComparatorsDict;
    constructor();
    registerComparators(comparators: IComparatorsDict): void;
    clearComparators(): void;
    getComparators(): IComparatorsDict;
    static ɵfac: i0.ɵɵFactoryDeclaration<KpiColorComparatorsRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KpiColorComparatorsRegistryService>;
}

declare class UrlInteractionService {
    private logger;
    constructor(logger: LoggerService);
    template(url: string, data: any): string;
    private evaluate;
    static ɵfac: i0.ɵɵFactoryDeclaration<UrlInteractionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UrlInteractionService>;
}

declare class ProportionalDonutContentComponent implements OnChanges, OnDestroy, IHasChangeDetector {
    private aggregatorRegistry;
    private formatterRegistry;
    changeDetector: ChangeDetectorRef;
    private logger;
    static lateLoadKey: string;
    widgetData: IChartAssistSeries<IAccessors>[];
    donutConfig: IDonutContentConfig;
    private chartAssist;
    aggregatedValue: string;
    contentFormatter: IFormatter;
    contentFormatterProperties: IFormatterProperties | undefined;
    private contentFormatterDefinition;
    private contentAggregatorDefinition;
    /** Hovered series Id */
    private emphasizedSeriesId;
    private destroy$;
    private chartAssistSubscription;
    constructor(aggregatorRegistry: ProportionalContentAggregatorsRegistryService, formatterRegistry: ProportionalDonutContentFormattersRegistryService, changeDetector: ChangeDetectorRef, logger: LoggerService);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /**
     * Iterates over formatters and maps their properties from the data
     *
     * @param formattersConfiguration
     */
    private getFormatterProperties;
    private updateAggregatorDefinition;
    private updateFormatterDefinition;
    private updateAggregatedValue;
    private updateFormatterProperties;
    private getAggregatorProperties;
    private subscribeToChartAssist;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalDonutContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProportionalDonutContentComponent, "nui-proportional-donut-content", never, { "widgetData": { "alias": "widgetData"; "required": false; }; "donutConfig": { "alias": "donutConfig"; "required": false; }; "chartAssist": { "alias": "chartAssist"; "required": false; }; }, {}, never, never, false, never>;
}

declare const TIMESERIES_INSPECTION_MENU_ZOOM_IN: IEventDefinition<IEvent<ITimeseriesZoomPluginInspectionFrame>>;
declare const TIMESERIES_INSPECTION_MENU_ZOOM_OUT: IEventDefinition<IEvent<ITimeseriesZoomPluginInspectionFrame>>;
declare const TIMESERIES_INSPECTION_MENU_EXPLORE: IEventDefinition<IEvent<ITimeseriesZoomPluginExploreData>>;
declare const TIMESERIES_INSPECTION_MENU_CLOSE: IEventDefinition<IEvent<void>>;
declare const TIMESERIES_INSPECTION_MENU_SYNCHRONIZE: IEventDefinition<IEvent<void>>;
declare const TIMESERIES_INSPECTION_MENU_CLEAR: IEventDefinition<IEvent<void>>;
interface ITimeseriesZoomPluginExploreData {
    ids: string;
    startDate: moment.Moment;
    endDate: moment.Moment;
    openSidePanel: boolean;
    exploringEnabled: boolean;
}
declare class TimeseriesInspectionMenuComponent implements OnInit, OnChanges, OnDestroy {
    element: ElementRef;
    private eventBus;
    private syncService;
    plugin: TimeseriesZoomPlugin;
    exploringEnabled: boolean;
    metricIds?: string;
    collectionId?: string;
    allowed?: boolean;
    private offset;
    private destroy$;
    constructor(element: ElementRef, eventBus: EventBus<IEvent>, syncService: TimeseriesZoomPluginsSyncService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    clearZoom(): void;
    isZoomInAllowed(): boolean;
    zoomIn(): void;
    zoomOut(): void;
    explore(openSidePanel?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesInspectionMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeseriesInspectionMenuComponent, "nui-timeseries-inspection-menu", never, { "plugin": { "alias": "plugin"; "required": false; }; "exploringEnabled": { "alias": "exploringEnabled"; "required": false; }; "metricIds": { "alias": "metricIds"; "required": false; }; "collectionId": { "alias": "collectionId"; "required": false; }; "allowed": { "alias": "allowed"; "required": false; }; }, {}, never, never, false, never>;
}

/** @ignore */
declare class ConfiguratorComponent implements OnInit, OnDestroy {
    widgetTypesService: WidgetTypesService;
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    formPortal: Portal<any>;
    previewWidget: IWidget | null;
    result: EventEmitter<IWidget | null>;
    formPortalAttached: EventEmitter<ComponentRef<any>>;
    previewPizzagnaComponent: PizzagnaComponent;
    submitError: Subject<void>;
    private readonly destroy$;
    constructor(widgetTypesService: WidgetTypesService, changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    getPreview(): PizzagnaComponent;
    handleSubmitError(): void;
    onFormPortalAttached(componentRef: ComponentRef<any>): void;
    updateWidget(previewWidget: IWidget | null): void;
    formCancel(): void;
    formSubmit(): void;
    onPizzagnaChange(pizzagna: IPizzagna): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorComponent, "nui-configurator", never, { "formPortal": { "alias": "formPortal"; "required": false; }; "previewWidget": { "alias": "previewWidget"; "required": false; }; }, { "result": "result"; "formPortalAttached": "formPortalAttached"; }, never, never, false, never>;
}

/**
 * This component registers multiple nested form groups in a parent form
 */
declare class FormStackComponent extends BaseLayout implements OnInit, OnChanges {
    formDirective: FormGroupDirective;
    private eventBus;
    static lateLoadKey: string;
    nodes: [];
    elementClass: string;
    form: FormGroup;
    constructor(changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService, formDirective: FormGroupDirective, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onEvent(componentId: string, event: IEvent): void;
    addFormGroup(name: string, formGroup: FormGroup): void;
    getNodes(): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FormStackComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormStackComponent, "nui-form-stack", never, { "nodes": { "alias": "nodes"; "required": false; }; }, {}, never, never, false, never>;
}

interface IDashwizStepNavigatedEvent {
    /** Index of the current step. */
    currentStepIndex: number;
    /** Index of the previous step. */
    previousStepIndex?: number;
    /** The current step instance. */
    currentStep: any;
    /** The previous step instance. */
    previousStep?: any;
}
interface IDashwizWaitEvent {
    busyState: IBusyConfig;
    allowStepChange: boolean;
}
interface IDashwizStepComponent {
    stepTemplate?: TemplateRef<any>;
    stepControl?: boolean;
    nextText?: string;
    disabled?: boolean;
    hidden?: boolean;
    enter?: EventEmitter<IDashwizStepNavigatedEvent | void>;
    exit?: EventEmitter<IDashwizStepNavigatedEvent | void>;
    next?: EventEmitter<IDashwizStepNavigatedEvent | void>;
    valid?: EventEmitter<boolean>;
}
interface IDashwizButtonsComponent {
    busy?: boolean;
    canProceed?: boolean;
    canFinish?: boolean;
    isFirstStepActive?: boolean;
    isLastStepActive?: boolean;
    nextText?: string;
    finishText?: string;
    cancel?: EventEmitter<void>;
    next?: EventEmitter<void>;
    back?: EventEmitter<void>;
    finish?: EventEmitter<void>;
}

declare class DashwizButtonsComponent implements IDashwizButtonsComponent {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef);
    busy: boolean;
    canFinish: boolean;
    canProceed: boolean;
    isFirstStepActive: boolean;
    isLastStepActive: boolean;
    nextText: string;
    finishText: string;
    cancel: EventEmitter<void>;
    next: EventEmitter<void>;
    back: EventEmitter<void>;
    finish: EventEmitter<void>;
    onCancel(): void;
    onNext(): void;
    onBack(): void;
    onFinish(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DashwizButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DashwizButtonsComponent, "nui-dashwiz-buttons", never, { "busy": { "alias": "busy"; "required": false; }; "canFinish": { "alias": "canFinish"; "required": false; }; "canProceed": { "alias": "canProceed"; "required": false; }; "isFirstStepActive": { "alias": "isFirstStepActive"; "required": false; }; "isLastStepActive": { "alias": "isLastStepActive"; "required": false; }; "nextText": { "alias": "nextText"; "required": false; }; "finishText": { "alias": "finishText"; "required": false; }; }, { "cancel": "cancel"; "next": "next"; "back": "back"; "finish": "finish"; }, never, never, false, never>;
}

declare class ConfiguratorHeadingService {
    height$: BehaviorSubject<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorHeadingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorHeadingService>;
}

/**
 * This is a basic implementation of a data source configuration component. In the real world scenario, this component will most likely be replaced by a
 * custom one, but still can be used as a template for developing a custom specific solution.
 */
declare class DataSourceConfigurationComponent implements IHasChangeDetector, IHasForm, OnInit, OnChanges {
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    private formBuilder;
    private providerRegistryService;
    private eventBus;
    private injector;
    private logger;
    static lateLoadKey: string;
    /**
     * This component shows a dropdown with options for selecting a data source, this input represents these options.
     */
    dataSourceProviders: string[];
    errorComponent: string;
    properties: IProperties;
    providerId: string;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    hasDataSourceError: boolean;
    dataSource: IDataSource;
    dsOutput: Subject<any>;
    dataFieldIds: Subject<any>;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, providerRegistryService: ProviderRegistryService, eventBus: EventBus<IEvent>, injector: Injector, logger: LoggerService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onDataSourceChange(providerId: string): void;
    /**
     * The data source is invoked here to notify the rest of the form about  changes in the data source output.
     * DATA_SOURCE_OUTPUT event is emitted through the event bus carrying the data source result as the payload.
     * This might not be necessary in every situation. If the important information is already stored in the
     * data source properties, this step can be omitted.
     *
     * @param providerId
     */
    invokeDataSource(providerId: string): void;
    onErrorState(isError: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataSourceConfigurationComponent, "nui-data-source-configuration", never, { "dataSourceProviders": { "alias": "dataSourceProviders"; "required": false; }; "errorComponent": { "alias": "errorComponent"; "required": false; }; "properties": { "alias": "properties"; "required": false; }; "providerId": { "alias": "providerId"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

/**
 * This is a basic implementation of a data source configuration component. In the real world scenario, this component will most likely be replaced by a
 * custom one, but still can be used as a template for developing a custom specific solution.
 */
declare class DataSourceConfigurationV2Component implements IHasChangeDetector, IHasForm, OnInit, OnChanges, AfterViewInit {
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    protected formBuilder: FormBuilder;
    protected providerRegistryService: ProviderRegistryService;
    protected eventBus: EventBus<IEvent>;
    protected injector: Injector;
    protected logger: LoggerService;
    static lateLoadKey: string;
    /**
     * This component shows a dropdown with options for selecting a data source, this input represents these options.
     */
    dataSourceProviders: IProviderConfigurationForDisplay[];
    properties: IProperties;
    providerId: string;
    errorComponent: string;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    hasDataSourceError: boolean;
    dataSource: IDataSource;
    dataFieldIds: Subject$1<any>;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, providerRegistryService: ProviderRegistryService, eventBus: EventBus<IEvent>, injector: Injector, logger: LoggerService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    onDataSourceSelected(selectedDataSource: IProviderConfigurationForDisplay): void;
    /**
     * The data source is invoked here to notify the rest of the form about  changes in the data source output.
     * DATA_SOURCE_OUTPUT event is emitted through the event bus carrying the data source result as the payload.
     * This might not be necessary in every situation. If the important information is already stored in the
     * data source properties, this step can be omitted.
     *
     * @param data
     */
    invokeDataSource(data: IProviderConfiguration): void;
    onErrorState(isError: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceConfigurationV2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataSourceConfigurationV2Component, "nui-data-source-configuration", never, { "dataSourceProviders": { "alias": "dataSourceProviders"; "required": false; }; "properties": { "alias": "properties"; "required": false; }; "providerId": { "alias": "providerId"; "required": false; }; "errorComponent": { "alias": "errorComponent"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class DataSourceErrorComponent implements OnDestroy, OnChanges {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    dataSource: IDataSource;
    errorState: EventEmitter<boolean>;
    dataSourceError: IDataSourceError | null;
    busy: boolean;
    onDestroy$: Subject<void>;
    data: any;
    private dataSourceClear$;
    constructor(changeDetector: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    onDataSourceChanged(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataSourceErrorComponent, "nui-data-source-error", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, { "errorState": "errorState"; }, never, never, false, never>;
}

interface IWidgetTemplateSelector {
    widgetSelected: EventEmitter<IWidget>;
}
interface IItemConfiguration {
    id: string;
    componentType?: string;
    headerSubject?: BehaviorSubject<string>;
    [key: string]: any;
}

interface IKpiItemConfiguration extends IItemConfiguration {
    widgetData: IKpiData;
    thresholds: IKpiThresholdsConfig;
    dataSource: IProviderConfiguration;
}
interface IKpiThresholdsConfig {
    showThresholds: boolean;
    reversedThresholds: boolean;
    warningThresholdValue?: number;
    criticalThresholdValue: number;
    backgroundColor?: string;
}
/**
 * @deprecated - Please use IKpiData instead - NUI-5853
 */
interface IKpiWidgetIndicatorData extends IKpiData {
    description?: string;
}
/** @ignore */
declare enum KpiWidgetThresholdColors {
    Warning = "var(--nui-color-semantic-warning)",
    Critical = "var(--nui-color-semantic-critical)"
}
declare enum KpiWidgetFontSizes {
    Small = "24px",
    Medium = "48px",
    Large = "72px",
    ExtraLarge = "120px"
}

/**
 * This component and its related form represent a collection of KPI tile configuration components
 */
declare class KpiTilesConfigurationComponent implements IHasChangeDetector, IHasForm, OnChanges {
    pizzagnaService: PizzagnaService;
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    private eventBus;
    static lateLoadKey: string;
    componentId: string;
    tiles: IKpiItemConfiguration[];
    nodes: string[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    emptyItems$: Observable<boolean>;
    constructor(pizzagnaService: PizzagnaService, changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, eventBus: EventBus<IEvent>);
    ngOnChanges(changes: SimpleChanges): void;
    onFormReady(form: AbstractControl): void;
    onItemsChange(tiles: IItemConfiguration[]): void;
    addTile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KpiTilesConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KpiTilesConfigurationComponent, "nui-kpi-tiles-configuration-component", never, { "componentId": { "alias": "componentId"; "required": false; }; "tiles": { "alias": "tiles"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

interface IRiskScoreItemConfiguration extends IItemConfiguration {
    widgetData: IRiskScoreData;
    dataSource: IProviderConfiguration;
}

/**
 * This component and its related form represent a collection of KPI tile configuration components
 */
declare class RiskScoreTilesConfigurationComponent implements IHasChangeDetector, IHasForm, OnChanges {
    pizzagnaService: PizzagnaService;
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    private eventBus;
    static lateLoadKey: string;
    componentId: string;
    tiles: IRiskScoreItemConfiguration[];
    nodes: string[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    emptyItems$: Observable<boolean>;
    constructor(pizzagnaService: PizzagnaService, changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, eventBus: EventBus<IEvent>);
    ngOnChanges(changes: SimpleChanges): void;
    onFormReady(form: AbstractControl): void;
    onItemsChange(tiles: IItemConfiguration[]): void;
    addTile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RiskScoreTilesConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RiskScoreTilesConfigurationComponent, "nui-risk-score-tiles-configuration-component", never, { "componentId": { "alias": "componentId"; "required": false; }; "tiles": { "alias": "tiles"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class EmbeddedContentConfigurationComponent implements OnInit, OnChanges, IHasChangeDetector, IHasForm, OnDestroy {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    static lateLoadKey: string;
    mode: EmbeddedContentMode;
    messageComponent: IInfoMessage;
    customEmbeddedContent: string;
    formReady: EventEmitter<FormGroup<any>>;
    private readonly destroy$;
    form: FormGroup;
    modes: {
        value: EmbeddedContentMode;
        displayValue: string;
    }[];
    get urlCustomContent(): AbstractControl | null;
    get htmlCustomContent(): AbstractControl | null;
    get modeValue(): AbstractControl | null;
    get customEmbeddedContentValue(): AbstractControl | null;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private initializeForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<EmbeddedContentConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EmbeddedContentConfigurationComponent, "nui-embedded-content-configuration", never, { "mode": { "alias": "mode"; "required": false; }; "messageComponent": { "alias": "messageComponent"; "required": false; }; "customEmbeddedContent": { "alias": "customEmbeddedContent"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class InfoMessageConfigurationComponent implements IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    emphasizeText: string;
    generalText: string;
    link: ILinkDefinition;
    allowDismiss: boolean;
    constructor(changeDetector: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<InfoMessageConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfoMessageConfigurationComponent, "nui-info-message-configuration", never, { "emphasizeText": { "alias": "emphasizeText"; "required": false; }; "generalText": { "alias": "generalText"; "required": false; }; "link": { "alias": "link"; "required": false; }; "allowDismiss": { "alias": "allowDismiss"; "required": false; }; }, {}, never, never, false, never>;
}

type ChartTypeNamesMap = {
    [key in ProportionalWidgetChartTypes]: string;
};
interface IChartOptionViewModel {
    label: string;
    value: ProportionalWidgetChartTypes;
}
declare class ProportionalChartOptionsEditorComponent implements IHasChangeDetector, IHasForm, OnInit, OnChanges {
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    private formBuilder;
    static lateLoadKey: string;
    chartOptions: IProportionalWidgetChartEditorOptions;
    chartType: ProportionalWidgetChartTypes;
    legendPlacement: LegendPlacement;
    legendFormatterComponentType: string;
    contentFormatterComponentType: string;
    contentFormatterProperties: IProperties | undefined;
    dsOutput: any;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    chartTypeNamesMap: ChartTypeNamesMap;
    legendFormatters: IFormatterDefinition[];
    contentFormatters: IFormatterDefinition[];
    formatterHasConfigurationComponent: boolean;
    currentConfigurationComponent: string;
    currentConfigurationComponentProperties: any;
    chartFormatters: any;
    configurationComponentProperties: any;
    private cachedChartOptionsViewModels;
    private rawFormatter;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder);
    get chartTypeSelectViewModels(): IChartOptionViewModel[];
    get chartTitle(): string;
    getConfigurationComponent(): string;
    getConfigurationComponentProperties(): void;
    getCurrentFormatterDefinition(): IFormatterDefinition | undefined;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onFormReady(payload: FormGroup): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalChartOptionsEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProportionalChartOptionsEditorComponent, "nui-proportional-chart-options-editor-component", never, { "chartOptions": { "alias": "chartOptions"; "required": false; }; "chartType": { "alias": "chartType"; "required": false; }; "legendPlacement": { "alias": "legendPlacement"; "required": false; }; "legendFormatterComponentType": { "alias": "legendFormatterComponentType"; "required": false; }; "contentFormatterComponentType": { "alias": "contentFormatterComponentType"; "required": false; }; "contentFormatterProperties": { "alias": "contentFormatterProperties"; "required": false; }; "dsOutput": { "alias": "dsOutput"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class ProportionalChartOptionsEditorV2Component implements OnInit, IHasChangeDetector, IHasForm, OnChanges, OnDestroy {
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    private formBuilder;
    static lateLoadKey: string;
    type: ProportionalWidgetChartTypes;
    legendPlacement: ILegendPlacementOption;
    legendFormatter: IFormatter;
    chartTypes: IProportionalWidgetChartTypeConfiguration[];
    legendPlacementOptions: ILegendPlacementOption[];
    legendFormatters: IFormatterDefinition[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    chartTypeChanged$: Subject<ProportionalWidgetChartTypes>;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, legendFormattersRegistry: ProportionalLegendFormattersRegistryService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get chartTitle(): string | undefined;
    get legendFormatterControl(): FormControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalChartOptionsEditorV2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProportionalChartOptionsEditorV2Component, "nui-proportional-chart-options-editor-v2-component", never, { "type": { "alias": "type"; "required": false; }; "legendPlacement": { "alias": "legendPlacement"; "required": false; }; "legendFormatter": { "alias": "legendFormatter"; "required": false; }; "chartTypes": { "alias": "chartTypes"; "required": false; }; "legendPlacementOptions": { "alias": "legendPlacementOptions"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class TableFiltersEditorComponent implements OnInit, OnChanges, OnDestroy, IHasForm, IHasChangeDetector {
    private formBuilder;
    configuratorHeading: ConfiguratorHeadingService;
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    sorterConfiguration: ITableWidgetSorterConfig;
    columns: Array<ITableWidgetColumnConfig>;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    selectedSortByValue: string;
    selectedSortOrderValue: string;
    sortableColumns: Array<ITableWidgetColumnConfig>;
    private onDestroy$;
    constructor(formBuilder: FormBuilder, configuratorHeading: ConfiguratorHeadingService, changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private setAccordionSubtitleValues;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableFiltersEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableFiltersEditorComponent, "nui-table-filters-editor-component", never, { "sorterConfiguration": { "alias": "sorterConfiguration"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class ScrollTypeEditorService {
    loadStrategies: {
        id: ScrollType;
        title: string;
    }[];
    setAccordionSubtitleValues(hasVirtualScroll: boolean, scrollType: ScrollType): string;
    getScrollTypeTitle(scrollType: ScrollType): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollTypeEditorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollTypeEditorService>;
}

interface IPageSizeSetMenuOption {
    value: number;
    checked: boolean;
}
declare class TableScrollTypeEditorComponent implements OnInit, OnChanges, OnDestroy, IHasForm, IHasChangeDetector {
    private formBuilder;
    configuratorHeading: ConfiguratorHeadingService;
    changeDetector: ChangeDetectorRef;
    scrollTypeEditorService: ScrollTypeEditorService;
    static lateLoadKey: string;
    paginatorConfiguration: ITableWidgetPaginatorConfig;
    hasVirtualScroll: boolean;
    scrollType: ScrollType;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    private onDestroy$;
    private pageSizeSetAll;
    pageSizeSetOptions: IPageSizeSetMenuOption[];
    pageSizeOptions: number[];
    subtitle: string;
    isExpanderOpen: boolean;
    displayPageSizeSetErrorMessage: boolean;
    displayPageSizeErrorMessage: boolean;
    scrollTypeFormControl?: AbstractControl | null;
    pageSizeSetFormControl?: AbstractControl | null;
    pageSizeFormControl?: AbstractControl | null;
    constructor(formBuilder: FormBuilder, configuratorHeading: ConfiguratorHeadingService, changeDetector: ChangeDetectorRef, scrollTypeEditorService: ScrollTypeEditorService);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    onPageSizeSetChange(item: IPageSizeSetMenuOption): void;
    get hasPaginator(): boolean;
    private updateSubtitle;
    private updateValidators;
    private emitUpdatedSelectedOptions;
    private updateDefaultPageSizeOptions;
    private updatePaginatorSelectOptions;
    private clearPageSizeSetOptions;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableScrollTypeEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableScrollTypeEditorComponent, "nui-scroll-type-editor-component", never, { "paginatorConfiguration": { "alias": "paginatorConfiguration"; "required": false; }; "hasVirtualScroll": { "alias": "hasVirtualScroll"; "required": false; }; "scrollType": { "alias": "scrollType"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

interface ITimeseriesChartTypeOption {
    label: string;
    value: TimeseriesChartPreset;
}
interface ITimeSpanOption {
    id: string;
    name: string;
}
declare class TimeseriesMetadataConfigurationComponent implements IHasChangeDetector, IHasForm, OnInit, OnChanges, OnDestroy {
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    private formBuilder;
    private eventBus;
    static lateLoadKey: string;
    legendPlacements: LegendPlacement[];
    timeSpans: ITimeSpanOption[];
    startingTimespan: any;
    legendPlacement: LegendPlacement;
    leftAxisLabel: string;
    preset: TimeseriesChartPreset;
    availableChartTypes: ITimeseriesChartTypeOption[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getSecondaryText(): string;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesMetadataConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeseriesMetadataConfigurationComponent, "nui-timeseries-metadata-configuration", never, { "legendPlacements": { "alias": "legendPlacements"; "required": false; }; "timeSpans": { "alias": "timeSpans"; "required": false; }; "startingTimespan": { "alias": "startingTimespan"; "required": false; }; "legendPlacement": { "alias": "legendPlacement"; "required": false; }; "leftAxisLabel": { "alias": "leftAxisLabel"; "required": false; }; "preset": { "alias": "preset"; "required": false; }; "availableChartTypes": { "alias": "availableChartTypes"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

interface ITimeseriesItemConfiguration extends IItemConfiguration {
    selectedSeriesId: string;
}

declare class TimeseriesSeriesCollectionConfigurationComponent implements IHasChangeDetector, IHasForm, OnDestroy, OnChanges {
    pizzagnaService: PizzagnaService;
    changeDetector: ChangeDetectorRef;
    private eventBus;
    static lateLoadKey: string;
    nodes: string[];
    componentId: string;
    series: ITimeseriesItemConfiguration[];
    availableSeries: ITimeseriesWidgetData[];
    allSeries: ITimeseriesWidgetData[];
    formReady: EventEmitter<any>;
    form: FormGroup;
    emptySeries$: Observable<boolean>;
    private readonly destroy$;
    constructor(pizzagnaService: PizzagnaService, changeDetector: ChangeDetectorRef, eventBus: EventBus<IEvent>);
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onFormReady(form: AbstractControl): void;
    onItemsChange(series: ITimeseriesItemConfiguration[]): void;
    isPossibleToAddSeries(): boolean;
    addSeries(): void;
    private createSeriesConfigComponents;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesSeriesCollectionConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeseriesSeriesCollectionConfigurationComponent, "nui-timeseries-series-collection-configuration", never, { "nodes": { "alias": "nodes"; "required": false; }; "componentId": { "alias": "componentId"; "required": false; }; "series": { "alias": "series"; "required": false; }; "availableSeries": { "alias": "availableSeries"; "required": false; }; "allSeries": { "alias": "allSeries"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class TableColumnsConfigurationComponent implements OnInit, IHasForm, OnChanges, OnDestroy {
    private formBuilder;
    private changeDetector;
    private dialogService;
    private pizzagnaService;
    private eventBus;
    static lateLoadKey: string;
    columns: ITableWidgetColumnConfig[];
    formatters: Array<IFormatterDefinition>;
    componentId: string;
    dataFields: Array<IDataField>;
    nodes: string[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    emptyColumns$: Observable<boolean>;
    dataSource: IDataSource;
    private onDestroy$;
    private lastValidDataFields;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef, dialogService: DialogService, pizzagnaService: PizzagnaService, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onFormReady(form: AbstractControl): void;
    onItemsChange(columns: ITableWidgetColumnConfig[]): void;
    addColumn(): void;
    onResetColumns(): void;
    resetColumns(confirmation: boolean): void;
    /**
     * Merges current column definitions with new incoming data fields
     *
     * @param currentDatafields
     * @param columns
     */
    private mergeColumns;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnsConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnsConfigurationComponent, "nui-table-columns-configuration", never, { "columns": { "alias": "columns"; "required": false; }; "formatters": { "alias": "formatters"; "required": false; }; "componentId": { "alias": "componentId"; "required": false; }; "dataFields": { "alias": "dataFields"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

/**
 * Component that provides wizard step functionality.
 */
declare class DashwizStepComponent implements IDashwizStepComponent, OnInit, OnChanges {
    /**
     * Template for step.
     */
    stepTemplate?: TemplateRef<any>;
    /**
     * Check is form inside step valid.
     */
    stepControl?: boolean;
    /**
     * The title of the step.
     */
    title: string;
    /**
     * Default:'Next'. Text for the Next button.
     */
    nextText: string;
    /**
     * Hide step
     */
    hidden: boolean;
    /**
     * Disables step
     */
    disabled?: boolean;
    /**
     * The size of the busy spinner
     */
    spinnerSize: SpinnerSize;
    /**
     * Evaluated when the step is entered.
     */
    enter: EventEmitter<void | IDashwizStepNavigatedEvent>;
    /**
     * Evaluated when validity of the step is changed.
     */
    valid: EventEmitter<boolean>;
    /**
     * Evaluated when the step is exited.
     */
    exit: EventEmitter<void | IDashwizStepNavigatedEvent>;
    /**
     * Evaluated when trying to go to the next step.
     */
    next: EventEmitter<void | IDashwizStepNavigatedEvent>;
    /**
     *
     * Options for busy state. Default: no busy state, with clear empty busy component when set to true
     */
    busyConfig: IBusyConfig;
    visited: boolean;
    active: boolean;
    complete: boolean;
    icon: string;
    iconColor: string;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Set flags for step entering and emits enter event
     */
    enterStep: (event?: IDashwizStepNavigatedEvent) => void;
    /**
     * Set flags for step exiting and emits exit event
     */
    exitStep: (event?: IDashwizStepNavigatedEvent) => void;
    nextStep: (event?: IDashwizStepNavigatedEvent) => void;
    applyEnteringStep: () => void;
    applyExitingStep: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DashwizStepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DashwizStepComponent, "nui-dashwiz-step", never, { "stepTemplate": { "alias": "stepTemplate"; "required": false; }; "stepControl": { "alias": "stepControl"; "required": false; }; "title": { "alias": "title"; "required": false; }; "nextText": { "alias": "nextText"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "spinnerSize": { "alias": "spinnerSize"; "required": false; }; }, { "enter": "enter"; "valid": "valid"; "exit": "exit"; "next": "next"; }, never, never, false, never>;
}

interface IDashwizComponent {
    steps: QueryList<DashwizStepComponent>;
    stepTitles: QueryList<ElementRef>;
    dynamicStep: any;
    /**
     * Set to true to hide the wizard header including the step breadcrumbs.
     * (default: false)
     */
    hideHeader: boolean;
    /**
     * Set to true to show the "Next" button at any point during the wizard process.
     * (default: false)
     */
    canProceed: boolean;
    /**
     * Set to true to show the "Finish" button at any point during the wizard process.
     * (default: false)
     */
    canFinish: boolean;
    /**
     * Overrides the default text on the finish step button.
     * (default: 'Action')
     */
    finishText: string;
    /**
     * Use this to stretch lines between step labels according to largest label width.
     * (default: false)
     */
    stretchStepLines: boolean;
    /**
     * Optional components to use for the buttons for each step
     */
    buttonComponentTypes: string[];
    /**
     * Evaluated when a step is selected.
     */
    stepNavigated: EventEmitter<IDashwizStepNavigatedEvent>;
    /**
     * Evaluated when the user attempts to cancel the wizard.
     */
    cancel: EventEmitter<boolean>;
    /**
     * Evaluated when the user completes the wizard.
     */
    finish: EventEmitter<any>;
    /**
     * Emits when next button is clicked.
     */
    next: EventEmitter<any>;
    /**
     * Emits when Back button is clicked.
     */
    back: EventEmitter<any>;
    /**
     * Use this BehaviorSubject to control navigability between steps
     */
    navigationControl: BehaviorSubject<IDashwizWaitEvent>;
    currentStep: DashwizStepComponent;
    stepLineWidth: number;
    stepIndex: number;
    buttonProperties: IDashwizButtonsComponent;
    buttonPortalActionMap: Record<string, Function>;
    addStepDynamic(wizardStep: IDashwizStepComponent, indexToInsert: number): any;
    disableStep(step: DashwizStepComponent): void;
    enableStep(step: DashwizStepComponent): void;
    hideStep(step: DashwizStepComponent): void;
    showStep(step: DashwizStepComponent): void;
    goToStep(stepIndex: number): void;
    selectStep(step: DashwizStepComponent): void;
    onBack(): void;
    onNext(): void;
    onFinish(): void;
    onCancel(): void;
    enterAnotherStep(): void;
    onButtonPortalOutput(event: IEvent): void;
}

declare class DashwizService {
    component: IDashwizComponent | undefined;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DashwizService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DashwizService>;
}

declare class ConfiguratorDataSourceManagerService implements OnDestroy {
    private eventBus;
    private dashwizService;
    private onDestroy$;
    private dataSourceCreated$;
    dataSource: IDataSource;
    error$: Subject<IDataSourceError | null>;
    busy$: BehaviorSubject<boolean>;
    dataSourceFields$: BehaviorSubject<Array<IDataField>>;
    constructor(eventBus: EventBus<IEvent>, dashwizService: DashwizService);
    onDataSourceCreated(dataSource: IDataSource): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorDataSourceManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfiguratorDataSourceManagerService>;
}

declare class TableColumnsConfigurationV2Component implements OnInit, IHasForm, OnChanges, OnDestroy {
    private formBuilder;
    private changeDetector;
    private dialogService;
    private pizzagnaService;
    dataSourceManager: ConfiguratorDataSourceManagerService;
    tableFormatterRegistry: TableFormatterRegistryService;
    private eventBus;
    static lateLoadKey: string;
    columns: ITableWidgetColumnConfig[];
    componentId: string;
    /**
     * @deprecated backward compatibility measure - deprecated in v11. Removal: NUI-5898
     *
     * This property is here because it was present in V1 component and was used to configure formatters
     */
    template: any;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    emptyColumns$: Observable<boolean>;
    dataSourceFields: Array<IDataField>;
    draggedItemHeight: number;
    isWidthMessageDisplayed: boolean;
    dataSourceError: IDataSourceError | null;
    get columnForms(): FormControl[];
    dataSource: IDataSource;
    columnLabel: string;
    private onDestroy$;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef, dialogService: DialogService, pizzagnaService: PizzagnaService, dataSourceManager: ConfiguratorDataSourceManagerService, tableFormatterRegistry: TableFormatterRegistryService, eventBus: EventBus<IEvent>);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    getColumns(): any[];
    updateColumns(columns: ITableWidgetColumnConfig[], emitEvent?: boolean): void;
    trackBy(index: number, item: FormControl): string | undefined;
    addColumn(): void;
    onResetColumns(): void;
    resetColumns(confirmation: boolean): void;
    /**
     * Merges current column definitions with new incoming data fields
     *
     * @param currentDatafields
     * @param columns
     */
    private mergeColumns;
    /**
     * This method calculates whether the width message should be displayed
     *
     * @param columns
     * @private
     */
    private getWidthMessageDisplayed;
    moveItem(index: number, toIndex: number): void;
    removeItem(index: number): void;
    drop(event: CdkDragDrop<string[]>): void;
    cdkDragStarted(event: CdkDragStart): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnsConfigurationV2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnsConfigurationV2Component, "nui-table-columns-configuration", never, { "columns": { "alias": "columns"; "required": false; }; "componentId": { "alias": "componentId"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class TableColumnConfigurationComponent implements ControlValueAccessor, OnInit, OnDestroy {
    private formBuilder;
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    form: FormGroup;
    changeFn: Function;
    private readonly destroy$;
    private input;
    formControl: AbstractControl;
    isWidthMessageDisplayed: boolean;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    validate(c: FormControl): ValidationErrors | null;
    writeValue(obj: ITableWidgetColumnConfig): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnConfigurationComponent, "nui-table-column-configuration", never, { "formControl": { "alias": "formControl"; "required": false; }; "isWidthMessageDisplayed": { "alias": "isWidthMessageDisplayed"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TableDataSourceErrorComponent extends DataSourceErrorComponent implements OnDestroy {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef);
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableDataSourceErrorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableDataSourceErrorComponent, "nui-table-data-source-error", never, {}, {}, never, never, false, never>;
}

declare class DonutContentPercentageFormatterComponent implements OnChanges, OnInit {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    sum: number;
    emphasizedSeriesData: IChartAssistSeries<IAccessors> | undefined;
    currentMetricData: number | undefined;
    chartContent: string;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef);
    data: IChartAssistSeries<IAccessors>[];
    chartAssist: ChartAssist;
    properties: IProperties;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    getProperSeriesData(): number;
    getProperContentValue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DonutContentPercentageFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DonutContentPercentageFormatterComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "chartAssist": { "alias": "chartAssist"; "required": false; }; "properties": { "alias": "properties"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ComponentPortalDirective implements OnInit, AfterViewInit, OnDestroy, OnChanges {
    private injector;
    private logger;
    private portalService;
    private renderer;
    private providerRegistry;
    componentId: string;
    componentType: string | Function;
    properties: Record<string, any>;
    providers: Record<string, IProviderConfiguration>;
    outputs: string[];
    output: EventEmitter<IEvent<any>>;
    portal: Portal<any>;
    private component;
    private propertiesChanges;
    private providerInstances;
    private readonly destroy$;
    private changesSubscription?;
    private listenerUnsubscriber?;
    constructor(injector: Injector, logger: LoggerService, portalService: ComponentPortalService, renderer: Renderer2, providerRegistry: ProviderRegistryService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    attached(componentRef: ComponentRef<any>): void;
    private recreatePortal;
    private updateProviders;
    private updateProviderConfigurations;
    private subscribeToOutputs;
    private checkForProviderChanges;
    private destroyProviders;
    /**
     * There was a change in component properties, so we need to handle that here
     *
     * @param change a change of the `properties` input
     */
    private applyPropertiesChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentPortalDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComponentPortalDirective, "[nuiComponentPortal]", ["nuiComponentPortal"], { "componentId": { "alias": "componentId"; "required": false; }; "componentType": { "alias": "componentType"; "required": false; }; "properties": { "alias": "properties"; "required": false; }; "providers": { "alias": "providers"; "required": false; }; "outputs": { "alias": "outputs"; "required": false; }; }, { "output": "output"; }, never, never, false, never>;
}

declare class NuiPizzagnaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NuiPizzagnaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NuiPizzagnaModule, [typeof PizzagnaComponent, typeof ComponentPortalDirective], [typeof i3.PortalModule, typeof NuiDashboardsCommonModule], [typeof i3.PortalModule, typeof PizzagnaComponent, typeof ComponentPortalDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NuiPizzagnaModule>;
}

declare abstract class DonutChartFormatterConfiguratorComponent implements IHasChangeDetector, IHasForm, OnChanges, OnInit {
    changeDetector: ChangeDetectorRef;
    protected formBuilder: FormBuilder;
    logger: LoggerService;
    contentFormatterProperties: IProperties;
    dsOutput: any;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, logger: LoggerService);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    initForm(): void;
    get currentMetric(): AbstractControl;
    /**
     * Returns the valid metric including cases when current selected metric does not exist eny more.
     */
    get properMetric(): string;
    /**
     * Add your custom form controls here
     *
     * @param form
     */
    protected addCustomFormControls(form: FormGroup): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DonutChartFormatterConfiguratorComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DonutChartFormatterConfiguratorComponent>;
}

declare class DonutContentPercentageConfigurationComponent extends DonutChartFormatterConfiguratorComponent {
    private pizzagnaService;
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, logger: LoggerService, pizzagnaService: PizzagnaService);
    static ɵfac: i0.ɵɵFactoryDeclaration<DonutContentPercentageConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DonutContentPercentageConfigurationComponent, "nui-donut-content-configurator", never, {}, {}, never, never, false, never>;
}

declare class DonutContentSumFormatterComponent implements OnChanges {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    sum: number;
    constructor(changeDetector: ChangeDetectorRef);
    data: IFormatterData[];
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DonutContentSumFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DonutContentSumFormatterComponent, "nui-dashboards-donut-content-sum-formatter", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * Use this function to apply endpoints on status data returned by a data source so that when the status
 * chart is zoomed (filtered), each status visualization is ensured to have valid start and end values
 *
 * @param timeframeFilter The timeframe used for filtering the data
 * @param filteredSeriesData The series data after the filter is applied
 * @param originalSeriesData The superset of series data with no filter applied
 *
 * @returns The filtered data including start and end data points applied to each series
 */
declare function applyStatusEndpoints(timeframeFilter: ITimeframe, filteredSeriesData: ITimeseriesWidgetData[], originalSeriesData: ITimeseriesWidgetData[]): ITimeseriesWidgetData[];

declare function transformDifference(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformChangePoint(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformFloatingAverage(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformLoessSmoothing(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformNormalize(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformLinReg(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformLoessStandardize(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformPercentileStd(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function transformStandardize(data: ITimeseriesWidgetSeriesData[], hasPercentile?: boolean): ITimeseriesWidgetSeriesData[];

declare function metricsSeriesMeasurementsMinMax(series: ITimeseriesWidgetData<any>[], axisUnits: UnitOption): {
    min: number;
    max: number;
};
declare function hasTimeseriesWidgetSummaryLegend(type: TimeseriesChartTypes): boolean;
declare const SUMMARY_LEGEND_BCG_COLOR = "var(--nui-color-chart-sum)";
declare const SUMMARY_LEGEND_COLOR = "var(--nui-color-text-inverse)";

/**
 * This provider allows a system wide definition of widget refresh rates.
 */
declare class RefresherSettingsService {
    private _refreshRateSeconds;
    refreshRateSeconds$: BehaviorSubject<number>;
    /**
     * This is a system wide definition of refresh rate. Widgets have to be configured to use
     * the system settings to leverage this value.
     */
    get refreshRateSeconds(): number;
    set refreshRateSeconds(value: number);
    static ɵfac: i0.ɵɵFactoryDeclaration<RefresherSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RefresherSettingsService>;
}

interface IRefresherProperties extends IProperties {
    interval?: number;
    enabled?: boolean;
    overrideDefaultSettings?: boolean;
    eventDef?: EventDefinition<any>;
}
/**
 * This provider emits the REFRESH event every X milliseconds
 */
declare class Refresher implements OnDestroy, IConfigurable {
    protected eventBus: EventBus<IWidgetEvent>;
    protected ngZone: NgZone;
    protected refresherSettings: RefresherSettingsService;
    private intervalRef?;
    protected enabled: boolean;
    protected overrideDefaultSettings: boolean;
    protected interval: number;
    protected eventDef: EventDefinition<unknown>;
    readonly destroy$: Subject<void>;
    constructor(eventBus: EventBus<IWidgetEvent>, ngZone: NgZone, refresherSettings: RefresherSettingsService);
    updateConfiguration(properties: IRefresherProperties): void;
    ngOnDestroy(): void;
    private initializeInterval;
    protected performAction(): void;
    private getInterval;
    private clearInterval;
    static ɵfac: i0.ɵɵFactoryDeclaration<Refresher, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Refresher>;
}

declare class DataSourceAdapter<T extends IFilteringOutputs = IFilteringOutputs> implements IConfigurable, OnDestroy {
    eventBus: EventBus<IEvent>;
    dataSource: IDataSource<T>;
    protected pizzagnaService: PizzagnaService;
    protected componentId: string;
    protected lastValue: T;
    protected readonly destroy$: Subject<void>;
    protected dataSourceConfiguration: Record<string, any>;
    private propertyPath;
    constructor(eventBus: EventBus<IEvent>, dataSource: IDataSource<T>, pizzagnaService: PizzagnaService);
    protected setupRefreshListener(): void;
    protected handleRefresh(): void;
    protected handleDataSourceUpdate(value: T | IDataSourceOutput<T>): void;
    ngOnDestroy(): void;
    updateConfiguration(properties: IProperties): void;
    protected updateAdapterProperties(properties: IProperties): void;
    protected updateDataSourceProperties(properties: IProperties): void;
    protected updateOutput(value: T | undefined): void;
    protected processOutput(value: T | undefined): T | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceAdapter<any>, [null, { optional: true; }, null]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataSourceAdapter<any>>;
}

declare class TimeseriesDataSourceAdapter extends DataSourceAdapter {
    private seriesIndex;
    constructor(eventBus: EventBus<IEvent>, dataSource: IDataSource, pizzagnaService: PizzagnaService);
    updateConfiguration(properties: ITimeseriesDataSourceAdapterConfiguration): void;
    protected processOutput(value: IFilteringOutputs): IFilteringOutputs;
    /**
     * Builds the series set by mapping the series selected in the configurator to the data received from the data source.
     * @param data
     */
    private buildSeriesSet;
}

declare class TableDataSourceAdapter<T extends IFilteringOutputs> extends DataSourceAdapter<T> {
    protected virtualViewport: VirtualViewportManager;
    private dataPath;
    private dataFieldsPath;
    private totalItemsPath;
    constructor(eventBus: EventBus<IEvent>, dataSource: IDataSource, pizzagnaService: PizzagnaService, virtualViewport: VirtualViewportManager);
    protected setupRefreshListener(): void;
    protected updateAdapterProperties(properties: IProperties): void;
    protected updateOutput(output: IFilteringOutputs | undefined): void;
}

interface IUrlInteractionHandlerProperties extends IInteractionHandlerProperties {
    url: string;
    newWindow?: boolean;
}
declare class WindowObject extends Window {
}
declare class UrlInteractionHandler extends InteractionHandler<IUrlInteractionHandlerProperties, any> {
    private window;
    private logger;
    private urlInteractionService;
    constructor(eventBus: EventBus<IEvent>, window: WindowObject, logger: LoggerService, urlInteractionService: UrlInteractionService);
    protected handleInteraction(interaction: IInteractionPayload<any>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UrlInteractionHandler, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UrlInteractionHandler>;
}

declare class DonutContentRawFormatterComponent implements OnChanges {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    sum: number;
    convertedValue: string;
    conversionThreshold: number;
    private unitConversionPipe;
    constructor(changeDetector: ChangeDetectorRef, unitConversionService: UnitConversionService);
    data: IFormatterData[];
    config: IProportionalWidgetConfig;
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DonutContentRawFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DonutContentRawFormatterComponent, "nui-donut-content-raw-formatter", never, { "data": { "alias": "data"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

declare class IconFormatterComponent implements OnChanges, IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    iconService: IconService;
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef, iconService: IconService);
    isValid: boolean;
    iconFound: boolean;
    data?: IFormatterData;
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconFormatterComponent, "nui-dashboards-icon-formatter", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

interface ISiUnitsPrefix {
    power: number;
    prefix: string;
    label: string;
}

declare class SiUnitsFormatterComponent implements OnChanges {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    static SHIFT_POINT_DEFAULT: number;
    data: IFormatterData;
    elementClass: string;
    value: string;
    modifier: string | undefined;
    constructor(changeDetector: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    protected processSiUnitsValue(value: string): void;
    protected getTransformedValue(value: string, prefix: ISiUnitsPrefix | undefined): string;
    protected getTransformPrefix(origin: number): ISiUnitsPrefix | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SiUnitsFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SiUnitsFormatterComponent, "nui-dashboards-si-units-formatter", never, { "data": { "alias": "data"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare abstract class FormatterConfiguratorComponent implements IFormatterConfigurator, IHasChangeDetector, IHasForm, OnChanges {
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    protected formBuilder: FormBuilder;
    logger: LoggerService;
    formatter: IFormatter;
    formatterDefinition: IFormatterDefinition;
    dataFields: IDataField[];
    formArrayName: string;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    dropdownItems: Record<string, IDataField[]>;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, logger: LoggerService);
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * This method pregenerates lists of dropdown items for all required formatter columns mappings based on their type
     */
    mapDropdownItems(): void;
    get dataFieldIds(): FormGroup;
    initForm(): void;
    protected updateForm(): void;
    /**
     * Add your custom form controls here
     *
     * @param form
     */
    protected addCustomFormControls(form: FormGroup): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormatterConfiguratorComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormatterConfiguratorComponent>;
}

declare class LinkConfiguratorComponent extends FormatterConfiguratorComponent implements IHasChangeDetector {
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, logger: LoggerService);
    initForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkConfiguratorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinkConfiguratorComponent, "nui-link-configurator", never, {}, {}, never, never, false, never>;
}

/** @ignore */
declare class ValueSelectorComponent extends FormatterConfiguratorComponent {
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, logger: LoggerService);
    static ɵfac: i0.ɵɵFactoryDeclaration<ValueSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ValueSelectorComponent, "nui-value-selector", never, {}, {}, never, never, false, never>;
}

declare class LinkFormatterComponent implements OnChanges, IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    data: ILinkFormatterData;
    targetSelf?: boolean;
    isValid: boolean;
    constructor(changeDetector: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinkFormatterComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "targetSelf": { "alias": "targetSelf"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class StatusWithIconFormatterComponent implements OnChanges, IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef);
    isValid: boolean;
    data: {
        name: string;
        icon: string;
        data: number[];
        link?: string;
    };
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StatusWithIconFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StatusWithIconFormatterComponent, "nui-dashboards-status-icon-formatter", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RawFormatterComponent {
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    constructor(changeDetector: ChangeDetectorRef);
    data: IFormatterData;
    elementClass: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RawFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RawFormatterComponent, "nui-dashboards-raw-formatter", never, { "data": { "alias": "data"; "required": false; }; "elementClass": { "alias": "elementClass"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PercentageFormatterComponent extends RawFormatterComponent {
    static lateLoadKey: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PercentageFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PercentageFormatterComponent, "nui-dashboards-percentage-formatter", never, {}, {}, never, never, false, never>;
}

declare class KpiDescriptionConfigurationComponent implements OnInit, OnChanges, IHasChangeDetector, IHasForm {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    static lateLoadKey: string;
    defaultColor: {
        label: string;
        color: string;
    };
    componentId: string;
    configurableUnits: boolean;
    label: string;
    backgroundColor: string;
    units: string;
    backgroundColors: IPaletteColor[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    subtitle$: Observable<string>;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KpiDescriptionConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KpiDescriptionConfigurationComponent, "nui-kpi-description-configuration", never, { "componentId": { "alias": "componentId"; "required": false; }; "configurableUnits": { "alias": "configurableUnits"; "required": false; }; "label": { "alias": "label"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "units": { "alias": "units"; "required": false; }; "backgroundColors": { "alias": "backgroundColors"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class RiskScoreTileDescriptionConfigurationComponent implements OnInit, OnChanges, IHasChangeDetector, IHasForm {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    static lateLoadKey: string;
    readonly MAX_DESCRIPTION_LENGTH = 150;
    componentId: string;
    label: string;
    minValue: number;
    maxValue: number;
    description: string;
    useStaticLabel: boolean;
    staticLabel: string;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    subtitle$: Observable<string>;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RiskScoreTileDescriptionConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RiskScoreTileDescriptionConfigurationComponent, "nui-risk-score-tile-description-configuration", never, { "componentId": { "alias": "componentId"; "required": false; }; "label": { "alias": "label"; "required": false; }; "minValue": { "alias": "minValue"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; "description": { "alias": "description"; "required": false; }; "useStaticLabel": { "alias": "useStaticLabel"; "required": false; }; "staticLabel": { "alias": "staticLabel"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class ThresholdsConfigurationComponent implements OnInit, OnDestroy, OnChanges, IHasChangeDetector, IHasForm {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    private logger;
    private cd;
    static lateLoadKey: string;
    criticalThresholdValue: number;
    warningThresholdValue: number;
    showThresholds: boolean;
    reversedThresholds: boolean;
    formReady: EventEmitter<FormGroup<any>>;
    thresholdOptions: {
        value: boolean;
        displayValue: string;
    }[];
    /**
     * this value is added because of the setTimeout in RadioButtonComponent which will be removed in v10 - NUI-4843.
     * when setTimeout is removed this hack can be removed as well
     * @deprecated - remove in scope of NUI-4843
     * */
    radioButtonGroupValue: boolean;
    form: FormGroup;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, logger: LoggerService, cd: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getThresholdsSubtitle(showThreshold: boolean): string;
    ngOnDestroy(): void;
    private validateRadioButtonsGroupValue;
    private handleWarningThreshold;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThresholdsConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ThresholdsConfigurationComponent, "nui-thresholds-configuration", never, { "criticalThresholdValue": { "alias": "criticalThresholdValue"; "required": false; }; "warningThresholdValue": { "alias": "warningThresholdValue"; "required": false; }; "showThresholds": { "alias": "showThresholds"; "required": false; }; "reversedThresholds": { "alias": "reversedThresholds"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class TitleAndDescriptionConfigurationComponent implements IHasChangeDetector, IHasForm, OnInit, OnChanges {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    private logger;
    static lateLoadKey: string;
    title: string;
    url: string;
    subtitle: string;
    description: string;
    collapsible: boolean;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, logger: LoggerService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getSecondaryText(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleAndDescriptionConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TitleAndDescriptionConfigurationComponent, "nui-title-and-description-configuration", never, { "title": { "alias": "title"; "required": false; }; "url": { "alias": "url"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "description": { "alias": "description"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class WidgetConfiguratorSectionComponent extends BaseLayout implements OnInit, OnDestroy, IHasForm {
    private formBuilder;
    static lateLoadKey: string;
    headerTextTemplate: TemplateRef<any>;
    headerButtonsTemplate: TemplateRef<any>;
    nodes: string[];
    headerText: string;
    formReady: EventEmitter<FormGroup<any>>;
    formDestroy: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    constructor(changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService, formBuilder: FormBuilder);
    getNodes(): string[];
    ngOnInit(): void;
    onEvent(componentId: string, event: IEvent): void;
    addFormGroup(name: string, formGroup: FormGroup): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetConfiguratorSectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetConfiguratorSectionComponent, "nui-widget-configurator-section", never, { "headerTextTemplate": { "alias": "headerTextTemplate"; "required": false; }; "headerButtonsTemplate": { "alias": "headerButtonsTemplate"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; "headerText": { "alias": "headerText"; "required": false; }; }, { "formReady": "formReady"; "formDestroy": "formDestroy"; }, never, ["[headerText]", "[headerButtons]", "*"], false, never>;
}

declare class PreviewService {
    private _preview;
    get preview(): IPizzagnaLayer;
    set preview(value: IPizzagnaLayer);
    previewChanged: Subject<IPizzagnaLayer>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PreviewService>;
}

declare class WidgetEditorComponent implements OnInit, OnDestroy, IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    private previewService;
    configurator: ConfiguratorComponent;
    static lateLoadKey: string;
    static readonly TITLE_PATH = "header.properties.title";
    formPizzagna: IPizzagna;
    formRoot: string;
    private _formPizzagnaComponent;
    set formPizzagnaComponent(value: PizzagnaComponent);
    form: FormGroup;
    navigationControl: BehaviorSubject<IDashwizWaitEvent>;
    busy: boolean;
    configuratorTitle: string;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, previewService: PreviewService, configurator: ConfiguratorComponent);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onPreviewPizzagnaUpdate(configLayer: IPizzagnaLayer): void;
    onFinish(): void;
    onCancel(): void;
    private toggleBusy;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetEditorComponent, "nui-widget-editor", never, { "formPizzagna": { "alias": "formPizzagna"; "required": false; }; "formRoot": { "alias": "formRoot"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WidgetClonerComponent implements OnInit, OnDestroy, AfterViewInit, IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    configurator: ConfiguratorComponent;
    private previewService;
    private formBuilder;
    private widgetTypesService;
    private scrollDispatcher;
    static lateLoadKey: string;
    formPizzagna?: IPizzagna;
    cloneSelectionComponentType: Function;
    form: FormGroup;
    widgetTemplate: IWidget;
    navigationControl: BehaviorSubject<IDashwizWaitEvent>;
    busy: boolean;
    scrolled: boolean;
    isFormDisplayed: boolean;
    private readonly destroy$;
    private resetForm$;
    constructor(changeDetector: ChangeDetectorRef, configurator: ConfiguratorComponent, previewService: PreviewService, formBuilder: FormBuilder, widgetTypesService: WidgetTypesService, scrollDispatcher: ScrollDispatcher);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onPreviewPizzagnaUpdate(configLayer: IPizzagnaLayer): void;
    canFinish(): boolean;
    onFinish(): void;
    onCancel(): void;
    onStepNavigated(event: IDashwizStepNavigatedEvent): void;
    onSelect(widget: IWidget): void;
    private toggleBusy;
    private resetForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetClonerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetClonerComponent, "nui-widget-cloner", never, { "formPizzagna": { "alias": "formPizzagna"; "required": false; }; "cloneSelectionComponentType": { "alias": "cloneSelectionComponentType"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DescriptionConfigurationComponent implements OnInit, OnDestroy, OnChanges, IHasChangeDetector {
    private formBuilder;
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    label: string;
    isActive: string;
    width: number;
    isWidthMessageDisplayed: boolean;
    formReady: EventEmitter<FormGroup>;
    formDestroy: EventEmitter<FormGroup>;
    form: FormGroup;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    stub(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DescriptionConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DescriptionConfigurationComponent, "nui-table-column-description-configuration", never, { "label": { "alias": "label"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "width": { "alias": "width"; "required": false; }; "isWidthMessageDisplayed": { "alias": "isWidthMessageDisplayed"; "required": false; }; }, { "formReady": "formReady"; "formDestroy": "formDestroy"; }, never, never, false, never>;
}

declare class DescriptionConfigurationV2Component implements IHasChangeDetector, ControlValueAccessor, OnDestroy, OnInit {
    private formBuilder;
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    formControl: AbstractControl;
    isWidthMessageDisplayed: boolean;
    form: FormGroup;
    changeFn: Function;
    private readonly destroy$;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef);
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    validate(c: FormControl): ValidationErrors | null;
    writeValue(obj: ITableWidgetColumnConfig): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    stub(): void;
    isWidthMessageDisplayedForThisColumn(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DescriptionConfigurationV2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DescriptionConfigurationV2Component, "nui-description-configuration-v2", never, { "formControl": { "alias": "formControl"; "required": false; }; "isWidthMessageDisplayed": { "alias": "isWidthMessageDisplayed"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PresentationConfigurationComponent implements IHasChangeDetector, OnInit, OnDestroy, OnChanges, AfterViewInit {
    private formBuilder;
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    private formattersRegistryCommon;
    /**
     * @deprecated  will be removed in the scope of NUI-5839
     */
    private tableFormattersRegistryService;
    static lateLoadKey: string;
    private _providedFormatters;
    private _formatters;
    formatter: IFormatter;
    set formatters(formatters: Array<IFormatterDefinition>);
    get formatters(): IFormatterDefinition[];
    dataFieldIds: string[];
    private _dataFields;
    set dataFields(dataFields: Array<IDataField>);
    get dataFields(): IDataField[];
    formReady: EventEmitter<FormGroup>;
    formDestroy: EventEmitter<FormGroup>;
    form: FormGroup;
    formatterForm: FormGroup;
    formatterConfigurator: string | null;
    formatterConfiguratorProps: IFormatterConfigurator;
    readonly formatterFormGroupName = "formatter";
    subtitleText: string;
    private onDestroy$;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formattersRegistryCommon: FormatterRegistryService, 
    /**
     * @deprecated  will be removed in the scope of NUI-5839
     */
    tableFormattersRegistryService: TableFormatterRegistryService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getSelectedFormatterDefinition(): IFormatterDefinition | null;
    getSelectedDataField(): IDataField | null;
    onFormReady(form: FormGroup): void;
    private updateSubtitle;
    /**
     * Creates portal for dynamic configuration of formatter value.
     * @returns ComponentPortal
     */
    private createFormatterConfigurator;
    private updateAvailableFormatters;
    private subscribeToFormattersRegistry;
    private handleFormattersUpdate;
    /**
     * Fallback for table,
     *
     * nothing should go wrong, but in case "FORMATTERS_REGISTRY" is lost, get table registry
     */
    private get formattersRegistry();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PresentationConfigurationComponent, [null, null, null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PresentationConfigurationComponent, "nui-table-column-presentation-configuration", never, { "formatter": { "alias": "formatter"; "required": false; }; "formatters": { "alias": "formatters"; "required": false; }; "dataFieldIds": { "alias": "dataFieldIds"; "required": false; }; "dataFields": { "alias": "dataFields"; "required": false; }; }, { "formReady": "formReady"; "formDestroy": "formDestroy"; }, never, never, false, never>;
}

declare class PresentationConfigurationV2Component implements IHasChangeDetector, OnInit, OnDestroy, OnChanges, DoCheck, ControlValueAccessor {
    private formBuilder;
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    private eventBus;
    private formattersRegistryCommon;
    /**
     * @deprecated  will be removed in the scope of NUI-5839
     */
    private tableFormattersRegistryService;
    static lateLoadKey: string;
    set formatters(formatters: Array<IFormatterDefinition>);
    get formatters(): IFormatterDefinition[];
    dataFieldIds: string[];
    formControl: AbstractControl;
    set dataFields(dataFields: Array<IDataField>);
    get dataFields(): IDataField[];
    get formatter(): IFormatter;
    form: FormGroup;
    propertiesForm: FormGroup;
    formatterConfigurator: string | null;
    formatterConfiguratorProps: IFormatterConfigurator;
    subtitleText: string;
    private _dataFields;
    private onDestroy$;
    private providedFormatters;
    private _formatters;
    private changeFn;
    private touchFn;
    private propertiesFormReady;
    private input;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, eventBus: EventBus<IEvent>, formattersRegistryCommon: FormatterRegistryService, 
    /**
     * @deprecated  will be removed in the scope of NUI-5839
     */
    tableFormattersRegistryService: TableFormatterRegistryService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    writeValue(obj: IFormatter): void;
    validate(c: FormControl): ValidationErrors | null;
    getSelectedFormatterDefinition(): IFormatterDefinition | null;
    getSelectedDataField(): IDataField | null;
    ngDoCheck(): void;
    onFormReady(form: FormGroup): void;
    onValueChange(): void;
    private updateSubtitle;
    /**
     * Creates portal for dynamic configuration of formatter value.
     * @returns ComponentPortal
     */
    private createFormatterConfigurator;
    private updateAvailableFormatters;
    private subscribeToFormattersRegistry;
    private handleFormattersUpdate;
    /**
     * Fallback for table,
     *
     * nothing should go wrong, but in case "FORMATTERS_REGISTRY" is lost, get table registry
     */
    private get formattersRegistry();
    static ɵfac: i0.ɵɵFactoryDeclaration<PresentationConfigurationV2Component, [null, null, null, null, { optional: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PresentationConfigurationV2Component, "nui-presentation-configuration-v2", never, { "formatters": { "alias": "formatters"; "required": false; }; "dataFieldIds": { "alias": "dataFieldIds"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TimeseriesTileDescriptionConfigurationComponent implements OnInit, OnDestroy, OnChanges, IHasChangeDetector, IHasForm {
    private formBuilder;
    changeDetector: ChangeDetectorRef;
    static lateLoadKey: string;
    label: string;
    formReady: EventEmitter<FormGroup>;
    formDestroy: EventEmitter<FormGroup>;
    form: FormGroup;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesTileDescriptionConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeseriesTileDescriptionConfigurationComponent, "nui-table-column-description-configuration", never, { "label": { "alias": "label"; "required": false; }; }, { "formReady": "formReady"; "formDestroy": "formDestroy"; }, never, never, false, never>;
}

declare class TimeseriesTileIndicatorDataConfigurationComponent implements IHasChangeDetector, IHasForm, OnInit, OnDestroy, OnChanges {
    changeDetector: ChangeDetectorRef;
    configuratorHeading: ConfiguratorHeadingService;
    private formBuilder;
    private pizzagnaService;
    static lateLoadKey: string;
    componentId: string;
    selectedSeriesId: string;
    allSeries: ITimeseriesWidgetData[];
    availableSeries: ITimeseriesWidgetData[];
    formReady: EventEmitter<FormGroup>;
    formDestroy: EventEmitter<FormGroup>;
    set selectedSeries(value: ITimeseriesWidgetData | undefined);
    get selectedSeries(): ITimeseriesWidgetData | undefined;
    form: FormGroup;
    private readonly destroy$;
    private _selectedSeries?;
    constructor(changeDetector: ChangeDetectorRef, configuratorHeading: ConfiguratorHeadingService, formBuilder: FormBuilder, pizzagnaService: PizzagnaService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onSelect(selectedSeries: ITimeseriesWidgetData): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesTileIndicatorDataConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimeseriesTileIndicatorDataConfigurationComponent, "nui-timeseries-tile-indicator-data-configuration", never, { "componentId": { "alias": "componentId"; "required": false; }; "selectedSeriesId": { "alias": "selectedSeriesId"; "required": false; }; "allSeries": { "alias": "allSeries"; "required": false; }; "availableSeries": { "alias": "availableSeries"; "required": false; }; }, { "formReady": "formReady"; "formDestroy": "formDestroy"; }, never, never, false, never>;
}

declare class RefresherConfigurationComponent implements OnInit, OnChanges, OnDestroy, IHasChangeDetector, IHasForm {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    private logger;
    refresherSettings: RefresherSettingsService;
    private cd;
    static lateLoadKey: string;
    enabled: boolean;
    interval: number;
    minSeconds: number;
    maxSeconds: number;
    overrideDefaultSettingsCaption: string;
    overrideDefaultSettings: boolean;
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    private destroyed$;
    private refreshRateComp;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, logger: LoggerService, refresherSettings: RefresherSettingsService, cd: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    getHeaderSubtitle(): string;
    getDurationLabel(seconds: number): string;
    private resetInterval;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefresherConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RefresherConfigurationComponent, "nui-refresher-configuration", never, { "enabled": { "alias": "enabled"; "required": false; }; "interval": { "alias": "interval"; "required": false; }; "minSeconds": { "alias": "minSeconds"; "required": false; }; "maxSeconds": { "alias": "maxSeconds"; "required": false; }; "overrideDefaultSettingsCaption": { "alias": "overrideDefaultSettingsCaption"; "required": false; }; "overrideDefaultSettings": { "alias": "overrideDefaultSettings"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class BackgroundColorRulesConfigurationComponent implements IHasChangeDetector, IHasForm, OnChanges, OnInit, OnDestroy {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    static lateLoadKey: string;
    rules: IKpiColorRules[];
    backgroundColors: IPaletteColor[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    formLocal: FormGroup;
    availableComparators: IComparatorsDict;
    palette: Partial<IPaletteColor[]>;
    height: number;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, comparatorsRegistry: KpiColorComparatorsRegistryService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getColorRulesSubtitle(): string;
    getLabel(item: ComparatorTypes | string): string;
    removeRule(controlIndex: number): void;
    addRule(): void;
    drop(event: CdkDragDrop<string[]>): void;
    cdkDragStarted(event: CdkDragStart): void;
    ngOnDestroy(): void;
    private initDefaultRulesGroup;
    private move;
    static ɵfac: i0.ɵɵFactoryDeclaration<BackgroundColorRulesConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BackgroundColorRulesConfigurationComponent, "nui-background-color-rules-configuration", never, { "rules": { "alias": "rules"; "required": false; }; "backgroundColors": { "alias": "backgroundColors"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class GroupingConfigurationComponent implements OnInit, OnChanges, IHasChangeDetector, IHasForm, OnDestroy {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    private eventBus;
    static lateLoadKey: string;
    groups: string[];
    groupBy: string[];
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    selectData: Array<Array<string>>;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, eventBus: EventBus<IEvent>);
    get getGroupByControl(): FormArray;
    get getDrillStateControl(): FormArray;
    get getGroupsControl(): FormControl;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    createControl(value?: string): FormControl;
    addGrouping(): void;
    removeRule(index: number): void;
    isAddRestricted(): boolean;
    getSubtitle(): string;
    ngOnDestroy(): void;
    private onDataSourceCreated;
    private fillGroupsOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupingConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GroupingConfigurationComponent, "nui-grouping-configuration", never, { "groups": { "alias": "groups"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class EntityFormattingConfigurationComponent implements OnInit, OnChanges {
    changeDetector: ChangeDetectorRef;
    private formBuilder;
    static lateLoadKey: string;
    mappingKeys: string[];
    dataFieldIds: {
        [key: string]: string;
    };
    formReady: EventEmitter<FormGroup<any>>;
    form: FormGroup;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get getFieldMappingsControl(): FormGroup;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityFormattingConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityFormattingConfigurationComponent, "nui-entity-formatting-configuration", never, { "mappingKeys": { "alias": "mappingKeys"; "required": false; }; "dataFieldIds": { "alias": "dataFieldIds"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

interface IAggregatorConfiguratorProperties {
    metrics: IDataField[];
    activeMetricId?: string;
    [key: string]: any;
}
declare class AggregatorMetricSelectorConfigurationComponent implements OnInit, OnChanges, IHasChangeDetector {
    changeDetector: ChangeDetectorRef;
    protected formBuilder: FormBuilder;
    protected logger: LoggerService;
    static lateLoadKey: string;
    metrics: IDataField[];
    activeMetricId: string;
    formReady: EventEmitter<any>;
    form: FormGroup;
    meticsSelect: SelectV2Component;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, logger: LoggerService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    unsetMetric(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AggregatorMetricSelectorConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AggregatorMetricSelectorConfigurationComponent, "nui-aggregator-configurator", never, { "metrics": { "alias": "metrics"; "required": false; }; "activeMetricId": { "alias": "activeMetricId"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class DonutContentConfigurationComponent implements OnInit, OnChanges, IHasChangeDetector, OnDestroy {
    private formBuilder;
    changeDetector: ChangeDetectorRef;
    private eventBus;
    private contentFormattersRegistry;
    private aggregatorRegistry;
    static lateLoadKey: string;
    chartType: ProportionalWidgetChartTypes;
    formatter: IFormatter;
    aggregator: IProportionalDonutContentAggregator;
    formReady: EventEmitter<any>;
    shown: boolean;
    form: FormGroup<{
        formatter: FormGroup<{
            componentType: _angular_forms.FormControl<string | null>;
            properties: _angular_forms.FormControl<null>;
        }>;
        aggregator: FormGroup<{
            aggregatorType: _angular_forms.FormControl<string | null>;
            properties: _angular_forms.FormControl<null>;
        }>;
    }>;
    formatters: IFormatterDefinition[];
    aggregators: IProportionalDonutContentAggregatorDefinition[];
    dataFields: IDataField[];
    currentFormatterDefinition: IFormatterDefinition | undefined;
    formatterConfiguratorProps: IFormatterConfigurator;
    currentAggregatorDefinition: IProportionalDonutContentAggregatorDefinition | undefined;
    aggregatorConfiguratorProps: IAggregatorConfiguratorProperties;
    private readonly destroy$;
    constructor(formBuilder: FormBuilder, changeDetector: ChangeDetectorRef, eventBus: EventBus<IEvent>, contentFormattersRegistry: ProportionalDonutContentFormattersRegistryService, aggregatorRegistry: ProportionalContentAggregatorsRegistryService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    onFormReady(formControlName: string, form: FormGroup): void;
    get subtitleText(): string;
    private setFromRegistry;
    private watchFormChanges;
    private updateAggregatorConfiguratorProps;
    static ɵfac: i0.ɵɵFactoryDeclaration<DonutContentConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DonutContentConfigurationComponent, "nui-donut-content-configuration", never, { "chartType": { "alias": "chartType"; "required": false; }; "formatter": { "alias": "formatter"; "required": false; }; "aggregator": { "alias": "aggregator"; "required": false; }; }, { "formReady": "formReady"; }, never, never, false, never>;
}

declare class FieldMapperAggregatorConfiguratorComponent extends AggregatorMetricSelectorConfigurationComponent implements OnInit, OnChanges, OnDestroy, IHasChangeDetector {
    protected eventBus: EventBus<IEvent>;
    static lateLoadKey: string;
    chartSeriesDataFieldId: string;
    chartSeriesDataFields: IDataField[];
    form: FormGroup;
    private readonly destroy$;
    constructor(changeDetector: ChangeDetectorRef, formBuilder: FormBuilder, logger: LoggerService, eventBus: EventBus<IEvent>);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FieldMapperAggregatorConfiguratorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FieldMapperAggregatorConfiguratorComponent, "nui-field-mapper-aggregator-configurator", never, { "chartSeriesDataFieldId": { "alias": "chartSeriesDataFieldId"; "required": false; }; }, {}, never, never, false, never>;
}

/**
 * Component that provides wizard functionality.
 */
declare class DashwizComponent implements OnInit, AfterContentInit, AfterViewChecked, OnDestroy, DoCheck, IDashwizComponent {
    private changeDetector;
    private componentFactoryResolver;
    private logger;
    private dashwizService;
    private scrollDispatcher;
    private static placeholderFinishText;
    steps: QueryList<DashwizStepComponent>;
    stepTitles: QueryList<ElementRef>;
    dynamicStep: any;
    /**
     * Set to true to hide the wizard header including the step breadcrumbs.
     * (default: false)
     */
    hideHeader: boolean;
    /**
     * Set to true to show the "Next" button at any point during the wizard process.
     * (default: false)
     */
    canProceed: boolean;
    /**
     * Set to true to show the "Finish" button at any point during the wizard process.
     * (default: false)
     */
    canFinish: boolean;
    /**
     * Overrides the default text on the finish step button.
     * (default: 'Action')
     */
    finishText: string;
    /**
     * Use this to stretch lines between step labels according to largest label width.
     * (default: false)
     */
    stretchStepLines: boolean;
    /**
     * Optional components to use for the buttons for each step
     */
    buttonComponentTypes: string[];
    /**
     * Evaluated when a step is selected.
     */
    stepNavigated: EventEmitter<IDashwizStepNavigatedEvent>;
    /**
     * Evaluated when the user attempts to cancel the wizard.
     */
    cancel: EventEmitter<boolean>;
    /**
     * Evaluated when the user completes the wizard.
     */
    finish: EventEmitter<any>;
    /**
     * Emits when next button is clicked.
     */
    next: EventEmitter<any>;
    /**
     * Emits when Back button is clicked.
     */
    back: EventEmitter<any>;
    /**
     * Use this BehaviorSubject to control navigability between steps
     */
    navigationControl: BehaviorSubject<IDashwizWaitEvent>;
    currentStep: DashwizStepComponent;
    stepLineWidth: number;
    stepIndex: number;
    buttonProperties: IDashwizButtonsComponent;
    scrolled: boolean;
    private stepNavigatedEvent;
    private previousStepIndex;
    private futureStep?;
    private arraySteps;
    constructor(changeDetector: ChangeDetectorRef, componentFactoryResolver: ComponentFactoryResolver, logger: LoggerService, dashwizService: DashwizService, scrollDispatcher: ScrollDispatcher);
    ngOnInit(): void;
    ngDoCheck(): void;
    ngAfterContentInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    addStepDynamic(wizardStep: IDashwizStepComponent, indexToInsert: number): void;
    disableStep(step: DashwizStepComponent): void;
    enableStep(step: DashwizStepComponent): void;
    hideStep(step: DashwizStepComponent): void;
    showStep(step: DashwizStepComponent): void;
    goToStep(stepIndex: number): void;
    selectStep(step: DashwizStepComponent): void;
    onBack: () => void;
    onNext: () => void;
    onFinish: () => void;
    onCancel: () => void;
    buttonPortalActionMap: Record<string, Function>;
    enterAnotherStep(): void;
    onButtonPortalOutput(event: IEvent): void;
    private disableFollowingSteps;
    private enableFollowingSteps;
    private handleStepControl;
    private getLargestLabelWidth;
    static ɵfac: i0.ɵɵFactoryDeclaration<DashwizComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DashwizComponent, "nui-dashwiz", never, { "hideHeader": { "alias": "hideHeader"; "required": false; }; "canProceed": { "alias": "canProceed"; "required": false; }; "canFinish": { "alias": "canFinish"; "required": false; }; "finishText": { "alias": "finishText"; "required": false; }; "stretchStepLines": { "alias": "stretchStepLines"; "required": false; }; "buttonComponentTypes": { "alias": "buttonComponentTypes"; "required": false; }; "navigationControl": { "alias": "navigationControl"; "required": false; }; }, { "stepNavigated": "stepNavigated"; "cancel": "cancel"; "finish": "finish"; "next": "next"; "back": "back"; }, ["steps"], ["*"], false, never>;
}

declare class WidgetConfiguratorSectionCoordinatorService {
    private accordions;
    registerAccordion(accordion: WidgetEditorAccordionComponent): void;
    private closeAllAccordions;
    private removeAccordion;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetConfiguratorSectionCoordinatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetConfiguratorSectionCoordinatorService>;
}

/** @ignore */
declare class WidgetEditorAccordionComponent implements OnInit, OnDestroy {
    private accordionCoordinator;
    cd: ChangeDetectorRef;
    showOpenStateIcon: boolean;
    state: AccordionState;
    openToggle: EventEmitter<boolean>;
    open: boolean;
    openSubject: Subject<void>;
    destroySubject: Subject<void>;
    constructor(accordionCoordinator: WidgetConfiguratorSectionCoordinatorService, cd: ChangeDetectorRef);
    ngOnInit(): void;
    openChange(isOpened: boolean): void;
    closeAccordion(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetEditorAccordionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetEditorAccordionComponent, "nui-widget-editor-accordion", never, { "showOpenStateIcon": { "alias": "showOpenStateIcon"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "openToggle": "openToggle"; }, never, ["[accordionHeader], nui-widget-editor-accordion-header", "*"], false, never>;
}

declare class WidgetEditorAccordionHeaderComponent {
    headerIcon?: string;
    iconColor?: string;
    subtitle: string;
    headerTitle: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetEditorAccordionHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetEditorAccordionHeaderComponent, "nui-widget-editor-accordion-header", never, { "headerIcon": { "alias": "headerIcon"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "headerTitle": { "alias": "headerTitle"; "required": false; }; }, {}, never, never, false, never>;
}

/** @ignore */
declare class ItemsDynamicComponent extends BaseLayout implements IHasChangeDetector, IHasForm<FormArray>, OnInit, OnDestroy {
    private formBuilder;
    static lateLoadKey: string;
    items: IItemConfiguration[];
    moveButtons: boolean;
    nodes: string[];
    headerPrefix: string;
    formReady: EventEmitter<FormArray<any>>;
    itemsChange: EventEmitter<any>;
    form: FormArray;
    height: number;
    headerMap: Map<string, string>;
    constructor(changeDetector: ChangeDetectorRef, pizzagnaService: PizzagnaService, logger: LoggerService, formBuilder: FormBuilder);
    getItemForNode(node: IComponentConfiguration): IItemConfiguration | undefined;
    getNodes(): string[];
    ngOnInit(): void;
    onEvent(componentId: string, event: IEvent): void;
    onFormReady(item: IItemConfiguration, form: FormGroup, index: number): void;
    onFormDestroy(form: FormGroup): void;
    trackBy(index: number, item: IItemConfiguration): string;
    removeItem(item: IItemConfiguration | undefined, index: number): void;
    moveItem(index: number, toIndex: number): void;
    drop(event: CdkDragDrop<string[]>): void;
    cdkDragStarted(event: CdkDragStart): void;
    private moveFormValues;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ItemsDynamicComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ItemsDynamicComponent, "nui-items-dynamic", never, { "items": { "alias": "items"; "required": false; }; "moveButtons": { "alias": "moveButtons"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; "headerPrefix": { "alias": "headerPrefix"; "required": false; }; }, { "formReady": "formReady"; "itemsChange": "itemsChange"; }, never, never, false, never>;
}

declare class ConfiguratorHeadingComponent implements OnChanges {
    el: ElementRef;
    private heading;
    configuratorTitle: string;
    disableCloseButton: boolean;
    close: EventEmitter<any>;
    constructor(el: ElementRef, heading: ConfiguratorHeadingService);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfiguratorHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfiguratorHeadingComponent, "nui-configurator-heading", never, { "configuratorTitle": { "alias": "configuratorTitle"; "required": false; }; "disableCloseButton": { "alias": "disableCloseButton"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare enum TimeUnit {
    Second = "second",
    Minute = "minute",
    Hour = "hour"
}

interface NumberValidationParams {
    min?: number;
    max?: number;
    whole?: boolean;
}

/**
 * As per Wolfi, this is a candidate for reworking into a general time interval selector implemented as a Web Component
 */
declare class RefreshRateConfiguratorComponent implements ControlValueAccessor, OnInit, OnDestroy {
    private fb;
    private cd;
    minSeconds: number;
    maxSeconds: number;
    possibleUnits: TimeUnit[];
    unitItems: any[];
    displayedUnitItems: any[];
    form: FormGroup;
    numberControl: FormControl;
    unitControl: FormControl;
    currentUnit: TimeUnit | null;
    valueChangeFix: typeof noop;
    private onChange;
    private destroy$;
    constructor(fb: FormBuilder, cd: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    getNumberMin(): number | undefined;
    getNumberMax(): number | undefined;
    writeValue(seconds: number): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    resetUnits(): void;
    private generateUnitItems;
    private filterUnitItems;
    private createForm;
    private updateError;
    private emitValueChange;
    private isRangeValid;
    isNumberValid(): boolean;
    getNumberValidationMessage(): string;
    getLocalizedNumberValidationMessage(params: NumberValidationParams): string;
    validate(): ValidationErrors | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefreshRateConfiguratorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RefreshRateConfiguratorComponent, "nui-refresh-rate-configurator", never, { "minSeconds": { "alias": "minSeconds"; "required": false; }; "maxSeconds": { "alias": "maxSeconds"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AddDataPipe implements PipeTransform {
    transform(origin: object | Array<any> | undefined, value: any, key?: string): object | Array<any> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddDataPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AddDataPipe, "nuiAddData", false>;
}

declare class PizzagnaRootPipe implements PipeTransform {
    private widgetTypesService;
    constructor(widgetTypesService: WidgetTypesService);
    transform(widget: IWidget | null, key?: "configurator" | "widget"): string | null | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<PizzagnaRootPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<PizzagnaRootPipe, "nuiPizzagnaRoot", false>;
}

declare class WidgetEditorAccordionFormStatePipe implements PipeTransform {
    transform(form: FormGroup | AbstractControl | null): Observable<AccordionState>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetEditorAccordionFormStatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WidgetEditorAccordionFormStatePipe, "nuiWidgetEditorAccordionFormState", false>;
}

declare class WidgetConfiguratorSectionHeaderPipe implements PipeTransform {
    private readonly defaultHeaderPrefix;
    transform(headerText: string | undefined, index: number, headerPrefix?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetConfiguratorSectionHeaderPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WidgetConfiguratorSectionHeaderPipe, "nuiWidgetConfiguratorSectionHeader", false>;
}

declare class FormHeaderIconPipePipe implements PipeTransform {
    static readonly ERROR_ICON_DEFAULT = "status_critical";
    transform(form: FormGroup | AbstractControl | null, defaultIcon: string, errorIcon?: string): Observable<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormHeaderIconPipePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FormHeaderIconPipePipe, "nuiFormHeaderIconPipe", false>;
}

declare class DropAreaComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<DropAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropAreaComponent, "nui-drop-area", never, {}, {}, never, never, false, never>;
}

declare class NuiDashboardConfiguratorModule {
    constructor(componentRegistry: ComponentRegistryService);
    static ɵfac: i0.ɵɵFactoryDeclaration<NuiDashboardConfiguratorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NuiDashboardConfiguratorModule, [typeof ConfiguratorComponent, typeof FormStackComponent, typeof DashwizButtonsComponent, typeof DataSourceConfigurationComponent, typeof DataSourceConfigurationV2Component, typeof DataSourceErrorComponent, typeof KpiTilesConfigurationComponent, typeof RiskScoreTilesConfigurationComponent, typeof EmbeddedContentConfigurationComponent, typeof InfoMessageConfigurationComponent, typeof ProportionalChartOptionsEditorComponent, typeof ProportionalChartOptionsEditorV2Component, typeof TableFiltersEditorComponent, typeof TableScrollTypeEditorComponent, typeof TimeseriesMetadataConfigurationComponent, typeof TimeseriesSeriesCollectionConfigurationComponent, typeof TableColumnsConfigurationComponent, typeof TableColumnsConfigurationV2Component, typeof TableColumnConfigurationComponent, typeof TableDataSourceErrorComponent, typeof DonutContentPercentageFormatterComponent, typeof DonutContentPercentageConfigurationComponent, typeof DonutContentSumFormatterComponent, typeof DonutContentRawFormatterComponent, typeof IconFormatterComponent, typeof SiUnitsFormatterComponent, typeof LinkConfiguratorComponent, typeof ValueSelectorComponent, typeof LinkFormatterComponent, typeof PreviewPlaceholderComponent, typeof StatusWithIconFormatterComponent, typeof RawFormatterComponent, typeof PercentageFormatterComponent, typeof KpiDescriptionConfigurationComponent, typeof RiskScoreTileDescriptionConfigurationComponent, typeof ThresholdsConfigurationComponent, typeof TitleAndDescriptionConfigurationComponent, typeof WidgetConfiguratorSectionComponent, typeof WidgetEditorComponent, typeof WidgetClonerComponent, typeof DescriptionConfigurationComponent, typeof DescriptionConfigurationV2Component, typeof PresentationConfigurationComponent, typeof PresentationConfigurationV2Component, typeof TimeseriesTileDescriptionConfigurationComponent, typeof TimeseriesTileIndicatorDataConfigurationComponent, typeof RefresherConfigurationComponent, typeof BackgroundColorRulesConfigurationComponent, typeof GroupingConfigurationComponent, typeof EntityFormattingConfigurationComponent, typeof DonutContentConfigurationComponent, typeof AggregatorMetricSelectorConfigurationComponent, typeof FieldMapperAggregatorConfiguratorComponent, typeof DashwizComponent, typeof DashwizStepComponent, typeof WidgetEditorAccordionComponent, typeof WidgetEditorAccordionHeaderComponent, typeof ItemsDynamicComponent, typeof ConfiguratorHeadingComponent, typeof RefreshRateConfiguratorComponent, typeof AddDataPipe, typeof PizzagnaRootPipe, typeof WidgetEditorAccordionFormStatePipe, typeof WidgetConfiguratorSectionHeaderPipe, typeof FormHeaderIconPipePipe, typeof DropAreaComponent], [typeof i67.ScrollingModule, typeof NuiDashboardsCommonModule, typeof _angular_forms.ReactiveFormsModule, typeof i70.GridsterModule, typeof i71.DragDropModule, typeof i3.PortalModule, typeof i73.NuiBusyModule, typeof NuiPizzagnaModule, typeof i73.NuiIconModule, typeof i73.NuiMenuModule, typeof i73.NuiPopupModule, typeof i73.NuiDialogModule, typeof i73.NuiSpinnerModule, typeof i73.NuiTextboxModule, typeof i73.NuiFormFieldModule, typeof i73.NuiButtonModule, typeof i73.NuiOverlayAdditionsModule, typeof i73.NuiSelectV2Module, typeof i73.NuiRadioModule, typeof i73.NuiCheckboxModule, typeof i73.NuiValidationMessageModule, typeof i73.NuiExpanderModule, typeof i73.NuiPanelModule, typeof i73.NuiDividerModule, typeof i73.NuiSwitchModule, typeof i73.NuiMessageModule, typeof i73.NuiWizardModule, typeof i73.NuiSorterModule, typeof i73.NuiSearchModule, typeof i73.NuiRepeatModule, typeof i73.NuiImageModule, typeof i73.NuiColorPickerModule], [typeof ConfiguratorComponent, typeof FormStackComponent, typeof DashwizButtonsComponent, typeof DataSourceConfigurationComponent, typeof DataSourceConfigurationV2Component, typeof DataSourceErrorComponent, typeof KpiTilesConfigurationComponent, typeof RiskScoreTilesConfigurationComponent, typeof EmbeddedContentConfigurationComponent, typeof InfoMessageConfigurationComponent, typeof ProportionalChartOptionsEditorComponent, typeof ProportionalChartOptionsEditorV2Component, typeof TableFiltersEditorComponent, typeof TableScrollTypeEditorComponent, typeof TimeseriesMetadataConfigurationComponent, typeof TimeseriesSeriesCollectionConfigurationComponent, typeof TableColumnsConfigurationComponent, typeof TableColumnsConfigurationV2Component, typeof TableColumnConfigurationComponent, typeof TableDataSourceErrorComponent, typeof DonutContentPercentageFormatterComponent, typeof DonutContentPercentageConfigurationComponent, typeof DonutContentSumFormatterComponent, typeof DonutContentRawFormatterComponent, typeof IconFormatterComponent, typeof SiUnitsFormatterComponent, typeof LinkConfiguratorComponent, typeof ValueSelectorComponent, typeof LinkFormatterComponent, typeof PreviewPlaceholderComponent, typeof StatusWithIconFormatterComponent, typeof RawFormatterComponent, typeof PercentageFormatterComponent, typeof KpiDescriptionConfigurationComponent, typeof RiskScoreTileDescriptionConfigurationComponent, typeof ThresholdsConfigurationComponent, typeof TitleAndDescriptionConfigurationComponent, typeof WidgetConfiguratorSectionComponent, typeof WidgetEditorComponent, typeof WidgetClonerComponent, typeof DescriptionConfigurationComponent, typeof DescriptionConfigurationV2Component, typeof PresentationConfigurationComponent, typeof PresentationConfigurationV2Component, typeof TimeseriesTileDescriptionConfigurationComponent, typeof TimeseriesTileIndicatorDataConfigurationComponent, typeof RefresherConfigurationComponent, typeof BackgroundColorRulesConfigurationComponent, typeof GroupingConfigurationComponent, typeof EntityFormattingConfigurationComponent, typeof DonutContentConfigurationComponent, typeof AggregatorMetricSelectorConfigurationComponent, typeof FieldMapperAggregatorConfiguratorComponent, typeof DashwizComponent, typeof DashwizStepComponent, typeof WidgetEditorAccordionComponent, typeof WidgetEditorAccordionHeaderComponent, typeof ItemsDynamicComponent, typeof ConfiguratorHeadingComponent, typeof RefreshRateConfiguratorComponent, typeof AddDataPipe, typeof PizzagnaRootPipe, typeof WidgetEditorAccordionFormStatePipe, typeof WidgetConfiguratorSectionHeaderPipe, typeof FormHeaderIconPipePipe, typeof DropAreaComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NuiDashboardConfiguratorModule>;
}

declare class NuiDashboardsModule {
    constructor(widgetTypesService: WidgetTypesService, componentRegistry: ComponentRegistryService, eventRegistry: EventRegistryService, kpiFormattersRegistry: KpiFormattersRegistryService, riskScoreFormattersRegistry: RiskScoreFormattersRegistryService);
    static ɵfac: i0.ɵɵFactoryDeclaration<NuiDashboardsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NuiDashboardsModule, [typeof DashboardComponent, typeof EmbeddedContentComponent, typeof GridsterItemWidgetIdDirective, typeof KpiComponent, typeof RiskScoreTileComponent, typeof LineChartComponent, typeof LoadingComponent, typeof ProportionalWidgetComponent, typeof StackComponent, typeof StackedAreaChartComponent, typeof StackedBarChartComponent, typeof StackedPercentageAreaChartComponent, typeof StatusBarChartComponent, typeof TableWidgetComponent, typeof DelayedMousePresenceDetectionDirective, typeof TemplateLoadErrorComponent, typeof TilesComponent, typeof TimeframeSelectionComponent, typeof TimeseriesWidgetComponent, typeof WidgetBodyComponent, typeof WidgetBodyContentComponent, typeof WidgetComponent, typeof WidgetEditorDirective, typeof WidgetHeaderComponent, typeof ListWidgetComponent, typeof ListLeafItemComponent, typeof ListGroupItemComponent, typeof ListNavigationBarComponent, typeof WidgetSearchComponent, typeof ProportionalDonutContentComponent, typeof TimeseriesInspectionMenuComponent], [typeof NuiDashboardsCommonModule, typeof i70.GridsterModule, typeof i73.NuiBusyModule, typeof i73.NuiButtonModule, typeof i35.NuiChartsModule, typeof NuiDashboardConfiguratorModule, typeof i73.NuiIconModule, typeof i73.NuiImageModule, typeof i73.NuiMenuModule, typeof NuiPizzagnaModule, typeof i73.NuiPopupModule, typeof i73.NuiProgressModule, typeof i73.NuiTableModule, typeof i73.NuiTimeFrameBarModule, typeof i67.ScrollingModule, typeof i73.NuiTimeFramePickerModule, typeof _angular_forms.ReactiveFormsModule, typeof i73.NuiSpinnerModule, typeof i73.NuiTooltipModule, typeof i73.NuiSearchModule, typeof i73.NuiCommonModule, typeof i73.NuiRepeatModule, typeof i73.NuiRiskScoreModule, typeof i73.NuiSelectModule, typeof i73.NuiPopoverModule, typeof i73.NuiPaginatorModule, typeof i73.NuiMessageModule], [typeof DashboardComponent, typeof EmbeddedContentComponent, typeof GridsterItemWidgetIdDirective, typeof KpiComponent, typeof RiskScoreTileComponent, typeof LineChartComponent, typeof LoadingComponent, typeof ProportionalWidgetComponent, typeof StackComponent, typeof StackedAreaChartComponent, typeof StackedBarChartComponent, typeof StackedPercentageAreaChartComponent, typeof StatusBarChartComponent, typeof TableWidgetComponent, typeof DelayedMousePresenceDetectionDirective, typeof TemplateLoadErrorComponent, typeof TilesComponent, typeof TimeframeSelectionComponent, typeof TimeseriesWidgetComponent, typeof WidgetBodyComponent, typeof WidgetBodyContentComponent, typeof WidgetComponent, typeof WidgetEditorDirective, typeof WidgetHeaderComponent, typeof ListWidgetComponent, typeof ListLeafItemComponent, typeof ListGroupItemComponent, typeof ListNavigationBarComponent, typeof WidgetSearchComponent, typeof ProportionalDonutContentComponent, typeof TimeseriesInspectionMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NuiDashboardsModule>;
}

declare const DATA_SOURCE_OUTPUT: EventDefinition<any>;
declare const DATA_SOURCE_DESTROYED: EventDefinition<IComponentIdPayload>;
declare const DATA_SOURCE_CHANGE: EventDefinition<unknown>;
declare const DATA_SOURCE_CREATED: EventDefinition<any>;

/**
 * Checks whether given form has a field that should be visually marked as invalid.
 * Form is not in an error state if it's untouched even if it's invalid at that moment,
 * a user must first interact with the form before it can be considered as invalid.
 * 'invalid' form property should not be used for the purpose of this function,
 * it can be affected by its children form statuses, which can be considered as valid (untouched).
 *
 * @param parent
 */
declare function hasControlInErrorState(parent: AbstractControl): boolean;

declare class KpiWidgetColorService {
    /**
     *
     * @param color Background color
     * @return Calculated text color based on background color
     */
    static getTextColor(color: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<KpiWidgetColorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KpiWidgetColorService>;
}

declare class WidgetClonerService {
    private configuratorService;
    private componentPortalService;
    private ref;
    constructor(configuratorService: ConfiguratorService, componentPortalService: ComponentPortalService);
    open(cloner: IWidgetSelector): Observable<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetClonerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetClonerService>;
}

declare const CONFIGURATOR_CONVERTER: InjectionToken<IConfiguratorConverter>;
interface IConfiguratorForm {
    pizzagna: IPizzagna;
    formGroup: FormGroup;
    previousValue: any;
}
interface IConfiguratorConverter {
    buildForm(): any;
    toPreview(form: FormGroup): any;
}
interface IConverterFormPartsProperties {
    previewPath: string;
    keys: string[];
    /** In case you need to put data in different place use this property */
    previewOutputPath?: string;
}

declare abstract class BaseConverter implements AfterViewInit, IConfiguratorConverter, OnDestroy {
    protected eventBus: EventBus<IEvent>;
    private previewService;
    protected pizzagnaService: PizzagnaService;
    component: any;
    componentId: string;
    readonly destroy$: Subject<void>;
    constructor(eventBus: EventBus<IEvent>, previewService: PreviewService, pizzagnaService: PizzagnaService);
    ngAfterViewInit(): void;
    abstract buildForm(): void;
    abstract toPreview(form: FormGroup): void;
    setComponent(component: any, componentId: string): void;
    getPreview(): IPizzagnaLayer;
    updatePreview(preview: IPizzagnaLayer): void;
    updateFormPizzagna(pizzagna: IPizzagna): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseConverter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseConverter>;
}

declare class KpiTilesConverterService extends BaseConverter implements AfterViewInit {
    private shouldReadForm;
    constructor(eventBus: EventBus<IEvent>, previewService: PreviewService, pizzagnaService: PizzagnaService);
    ngAfterViewInit(): void;
    buildForm(): void;
    toPreview(form: FormGroup): void;
    protected getTileConfiguration(id: string, componentType: string): IComponentConfiguration;
    static ɵfac: i0.ɵɵFactoryDeclaration<KpiTilesConverterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KpiTilesConverterService>;
}

declare class TimeseriesSeriesConverterService extends BaseConverter implements AfterViewInit, OnDestroy {
    private indicatorDataKey;
    private previewSeriesPath;
    private formSeriesComponentPath;
    private dataSourceSeries$;
    private selectedSeriesIds$;
    private shouldReadForm;
    constructor(eventBus: EventBus<IEvent>, previewService: PreviewService, pizzagnaService: PizzagnaService);
    buildForm(): void;
    toPreview(form: FormGroup): void;
    ngOnDestroy(): void;
    private updateAvailableSeries;
    private subscribeToAvailableDataFieldsChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeseriesSeriesConverterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TimeseriesSeriesConverterService>;
}

declare class TitleAndDescriptionConverterService extends BaseConverter implements AfterViewInit {
    static readonly PROPERTIES_PATH = "configuration.titleAndDescription.properties";
    constructor(eventBus: EventBus<IEvent>, previewService: PreviewService, pizzagnaService: PizzagnaService);
    ngAfterViewInit(): void;
    buildForm(): void;
    toPreview(form: FormGroup): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleAndDescriptionConverterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TitleAndDescriptionConverterService>;
}

declare class ProportionalWidgetChartOptionsConverterService extends BaseConverter implements AfterViewInit {
    private readonly PROPERTIES_PATH;
    constructor(eventBus: EventBus<IEvent>, previewService: PreviewService, pizzagnaService: PizzagnaService);
    ngAfterViewInit(): void;
    buildForm(): void;
    toPreview(form: FormGroup): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProportionalWidgetChartOptionsConverterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProportionalWidgetChartOptionsConverterService>;
}

interface IPercentageAggregatorProperties extends IProportionalDonutContentAggregatorProperties {
    /** if "true" it'll be 58 not 0.58 */
    base100?: boolean;
}
/**
 * Aggregator for the Proportional Widget with Donut chart type.
 *
 * Receives all the metrics from the donut and gets the active metric percentage.
 */
declare const percentageAggregator: IProportionalAggregatorFn;

/**
 * Receives all the metrics from the donut and gets their sum.
 */
declare const sumAggregator: IProportionalAggregatorFn;

interface IFieldMapperAggregatorProperties extends IProportionalDonutContentAggregatorProperties {
    chartSeriesDataFieldId?: string;
}
declare const fieldMapper: IProportionalAggregatorFn;

interface IValueChange {
    previousValue: any;
    currentValue: any;
}
/**
 * This function takes a source object with a prioritized list of changes. Goes through and detects the changes on every one of these structures and builds
 * a new object that respects immutability and updates object references only where necessary. This is used to merge lasagna overlays into a component state
 * that maintains its immutability and high performance of change detection.
 *
 * @param result
 * @param changes
 */
declare function mergeChanges<T>(result: T, ...changes: IValueChange[]): T;

/**
 *
 * Takes formatter "dataFieldIds" from "properties" and maps the data to the formatter input.
 * Might be used for nuiComponentPortal directive for formatter "properties"
 *
 * @param formatter
 * @param data
 */
declare function mapDataToFormatterProperties<T extends {
    [key: string]: any;
}>(formatter: IFormatter, data: T): {
    data: IFormatterData;
};

/**
 * Formatter for timeserie label dates
 */
declare const timeSeriesDatetimeFormatter: (date: Date) => string;

/**
 * Component configuration for the refresher configurator node
 */
declare const REFRESHER_CONFIGURATOR: IComponentConfiguration;

/**
 * Node keys for common errors
 */
declare enum ErrorNodeKey {
    ErrorUnknown = "errorUnknown",
    ErrorForbidden = "errorForbidden",
    ErrorNotFound = "errorNotFound"
}

/**
 * Component definition for the widget header node
 */
declare const WIDGET_HEADER: IComponentConfiguration;
/**
 * Component definition for the loading node
 */
declare const WIDGET_LOADING: IComponentConfiguration;
/**
 * Component configuration definition for the basic widget body node
 */
declare const WIDGET_BODY: IComponentConfiguration;
/**
 * A map of error codes to widget error node keys
 * --
 * An error code doesn't have to be an HTTP status code; it may be any string that matches an expected
 * data source error type. Additionally, the node keys may be any string as long as they correspond to an
 * error configuration node defined in the widget structure.
 */
declare const ERROR_FALLBACK_MAP: Record<string, ErrorNodeKey>;
/**
 * An index of common error configurations
 */
declare const ERROR_NODES: Record<string, IComponentConfiguration>;
/**
 * Retrieves an index of the basic widget body content nodes including fallback nodes
 *
 * @param mainContentNodeKey The key corresponding to the main body content node
 * @param fallbackAdapterId The id for the adapter responsible for activating fallback content in case of an error
 * @param fallbackMap A map of node keys to fallback content definitions
 * @param fallbackNodes An index of fallback content definitions
 *
 * @returns An index of component configurations
 */
declare function widgetBodyContentNodes(mainContentNodeKey: string, fallbackAdapterId?: string, fallbackMap?: Record<string, string>, fallbackNodes?: Record<string, IComponentConfiguration>): Record<string, IComponentConfiguration>;

/**
 * A provider configuration for the dashboard event proxy
 */
declare const EVENT_PROXY: IProviderConfiguration;
/**
 * Retrieves a provider configuration for the interval refresher
 *
 * @param enabled Specify whether the adapter should be active by default
 * @param interval Specify the interval (in seconds) at which the refresher should invoke the data source adapter
 *
 * @returns A provider configuration for the refresher
 */
declare function refresher(enabled?: boolean, interval?: number): IProviderConfiguration;

declare const DEFAULT_KPI_FORMATTERS: IFormatterDefinition[];

declare const DEFAULT_LEGEND_FORMATTERS: IFormatterDefinition[];
declare const DEFAULT_PROPORTIONAL_CONTENT_FORMATTERS: IFormatterDefinition[];
declare const DEFAULT_PROPORTIONAL_CONTENT_AGGREGATORS: IProportionalDonutContentAggregatorDefinition[];

declare const DONUT_CONTENT_CONFIGURATION_SLICE: {
    presentation: {
        id: string;
        componentType: string;
        properties: {
            headerText: string;
            nodes: string[];
        };
    };
    chartOptionsEditor: {
        id: string;
        componentType: string;
        properties: {
            chartTypes: {
                id: string;
                label: string;
            }[];
            legendPlacementOptions: {
                id: LegendPlacement;
                label: string;
            }[];
        };
        providers: {
            converter: {
                providerId: string;
                properties: {
                    formParts: {
                        previewPath: string;
                        keys: string[];
                    }[];
                };
            };
            broadcaster: {
                providerId: string;
                properties: {
                    configs: IBroadcasterConfig[];
                };
            };
        };
    };
    donutContentConfiguration: {
        id: string;
        componentType: string;
        providers: {
            converter: {
                providerId: string;
                properties: {
                    formParts: {
                        previewPath: string;
                        keys: string[];
                    }[];
                };
            };
        };
    };
};

declare const CHART_PALETTE_CS3_ALTERNATIVE_NAMES: string[];
declare const CHART_PALETTE_CS_S_EXTENDED_ALTERNATIVE_NAMES: string[];
declare const chartPaletteColorMap: Record<string, string>;
declare const DEFAULT_KPI_TILE_COLOR = "var(--nui-color-bg-secondary)";
declare const DEFAULT_KPI_BACKGROUND_COLORS: {
    color: string;
    label: string;
}[];

export { AccordionState, AddDataPipe, AggregatorMetricSelectorConfigurationComponent, BackgroundColorRulesConfigurationComponent, BaseConverter, BaseLayout, CHANGE_SELECTION, CHART_METRIC_REMOVE, CHART_PALETTE_CS3_ALTERNATIVE_NAMES, CHART_PALETTE_CS_S_EXTENDED_ALTERNATIVE_NAMES, CONFIGURATOR_CONVERTER, ComponentPortalDirective, ComponentPortalService, ComponentRegistryService, ConfiguratorComponent, ConfiguratorHeadingComponent, ConfiguratorHeadingService, ConfiguratorService, DASHBOARD_EDIT_MODE, DASHBOARD_EVENT_BUS, DATA_SOURCE, DATA_SOURCE_BUSY, DATA_SOURCE_CHANGE, DATA_SOURCE_CREATED, DATA_SOURCE_DESTROYED, DATA_SOURCE_INVOKED, DATA_SOURCE_OUTPUT, DEFAULT_COMPARATORS, DEFAULT_KPI_BACKGROUND_COLORS, DEFAULT_KPI_FORMATTERS, DEFAULT_KPI_TILE_COLOR, DEFAULT_LEGEND_FORMATTERS, DEFAULT_PIZZAGNA_ROOT, DEFAULT_PROPORTIONAL_CONTENT_AGGREGATORS, DEFAULT_PROPORTIONAL_CONTENT_FORMATTERS, DEFAULT_REFRESH_INTERVAL, DEFAULT_UNIT_CONVERSION_THRESHOLD, DONUT_CONTENT_CONFIGURATION_SLICE, DRILLDOWN, DashboardComponent, DashboardUnitConversionPipe, DashwizButtonsComponent, DashwizComponent, DashwizStepComponent, DataSourceAdapter, DataSourceConfigurationComponent, DataSourceConfigurationV2Component, DataSourceErrorComponent, DelayedMousePresenceDetectionDirective, DescriptionConfigurationComponent, DescriptionConfigurationV2Component, DonutChartFormatterConfiguratorComponent, DonutContentConfigurationComponent, DonutContentPercentageConfigurationComponent, DonutContentPercentageFormatterComponent, DonutContentRawFormatterComponent, DonutContentSumFormatterComponent, DropAreaComponent, DynamicComponentCreator, ERROR_FALLBACK_MAP, ERROR_NODES, EVENT_PROXY, EmbeddedContentComponent, EmbeddedContentConfigurationComponent, EmbeddedContentMode, EntityFormattingConfigurationComponent, ErrorNodeKey, EventRegistryService, FORMATTERS_REGISTRY, FieldMapperAggregatorConfiguratorComponent, FormHeaderIconPipePipe, FormStackComponent, FormatterConfiguratorComponent, FormatterRegistryService, GridsterItemWidgetIdDirective, GroupingConfigurationComponent, HEADER_LINK_PROVIDER, HttpStatusCode, INTERACTION, IconFormatterComponent, InfoMessageConfigurationComponent, InteractionHandler, ItemsDynamicComponent, KpiColorComparatorsRegistryService, KpiComponent, KpiDescriptionConfigurationComponent, KpiFormatterTypes, KpiFormattersRegistryService, KpiTilesConfigurationComponent, KpiTilesConverterService, KpiWidgetColorService, KpiWidgetFontSizes, KpiWidgetThresholdColors, LegendPlacement, LineChartComponent, LinkConfiguratorComponent, LinkFormatterComponent, ListGroupItemComponent, ListLeafItemComponent, ListNavigationBarComponent, ListWidgetComponent, LoadingComponent, NOVA_CONFIGURATOR_DATA_SOURCE_MANAGER, NOVA_DASHBOARD_EVENT_PROXY, NOVA_DATASOURCE_ADAPTER, NOVA_DATASOURCE_INTERVAL_REFRESHER, NOVA_DRILLDOWN_DATASOURCE_ADAPTER, NOVA_EVENT_BUS_DEBUGGER, NOVA_GENERIC_ARRAY_CONVERTER, NOVA_GENERIC_CONVERTER, NOVA_KPI_COLOR_PRIORITIZER, NOVA_KPI_DATASOURCE_ADAPTER, NOVA_KPI_FORMATTERS_REGISTRY, NOVA_KPI_SCALE_SYNC_BROKER, NOVA_KPI_SECTION_CONVERTER, NOVA_KPI_STATUS_CONTENT_FALLBACK_ADAPTER, NOVA_KPI_TILES_CONVERTER, NOVA_LOADING_ADAPTER, NOVA_PIZZAGNA_BROADCASTER, NOVA_PROPORTIONAL_CONTENT_FORMATTERS_REGISTRY, NOVA_PROPORTIONAL_WIDGET_CHART_OPTIONS_CONVERTER, NOVA_RISK_SCORE_FORMATTERS_REGISTRY, NOVA_STATUS_CONTENT_FALLBACK_ADAPTER, NOVA_TABLE_COLUMNS_CONVERTER, NOVA_TABLE_DATASOURCE_ADAPTER, NOVA_TABLE_FILTERS_CONVERTER, NOVA_TABLE_FORMATTERS_REGISTRY, NOVA_TABLE_SCROLL_TYPE_CONVERTER, NOVA_TEST_REGISTRY, NOVA_TIMESERIES_DATASOURCE_ADAPTER, NOVA_TIMESERIES_METADATA_CONVERTER, NOVA_TIMESERIES_SERIES_CONVERTER, NOVA_TIMESERIES_TILE_INDICATOR_DATA_CONVERTER, NOVA_TITLE_AND_DESCRIPTION_CONVERTER, NOVA_URL_INTERACTION_HANDLER, NOVA_VIRTUAL_VIEWPORT_MANAGER, NuiDashboardConfiguratorModule, NuiDashboardsCommonModule, NuiDashboardsModule, NuiPizzagnaModule, PIZZAGNA_EVENT_BUS, PREVIEW_EVENT, PercentageFormatterComponent, PizzagnaComponent, PizzagnaLayer, PizzagnaRootPipe, PizzagnaService, PresentationConfigurationComponent, PresentationConfigurationV2Component, PreviewOverlayComponent, PreviewPlaceholderComponent, PreviewService, ProportionalChartOptionsEditorComponent, ProportionalChartOptionsEditorV2Component, ProportionalContentAggregatorsRegistryService, ProportionalDonutContentComponent, ProportionalDonutContentFormattersRegistryService, ProportionalLegendFormattersRegistryService, ProportionalWidgetChartOptionsConverterService, ProportionalWidgetChartTypes, ProportionalWidgetComponent, ProviderRegistryService, REFRESH, REFRESHER_CONFIGURATOR, RawFormatterComponent, RefreshRateConfiguratorComponent, Refresher, RefresherConfigurationComponent, RefresherSettingsService, RiskScoreFormatterTypes, RiskScoreFormattersRegistryService, RiskScoreTileComponent, RiskScoreTileDescriptionConfigurationComponent, RiskScoreTilesConfigurationComponent, SCROLL_NEXT_PAGE, SELECTED_ITEMS, SELECTION, SET_NEXT_PAGE, SET_PROPERTY_VALUE, SET_TIMEFRAME, SUMMARY_LEGEND_BCG_COLOR, SUMMARY_LEGEND_COLOR, ScrollType, SiUnitsFormatterComponent, StackComponent, StackedAreaChartComponent, StackedBarChartComponent, StackedPercentageAreaChartComponent, StatusBarChartComponent, StatusWithIconFormatterComponent, TEST_REGISTRY, TIMESERIES_INSPECTION_MENU_CLEAR, TIMESERIES_INSPECTION_MENU_CLOSE, TIMESERIES_INSPECTION_MENU_EXPLORE, TIMESERIES_INSPECTION_MENU_SYNCHRONIZE, TIMESERIES_INSPECTION_MENU_ZOOM_IN, TIMESERIES_INSPECTION_MENU_ZOOM_OUT, TableColumnConfigurationComponent, TableColumnsConfigurationComponent, TableColumnsConfigurationV2Component, TableDataSourceAdapter, TableDataSourceErrorComponent, TableFiltersEditorComponent, TableFormatterRegistryService, TableScrollTypeEditorComponent, TableWidgetComponent, TemplateLoadErrorComponent, ThresholdsConfigurationComponent, TilesComponent, TimeframeSelectionComponent, TimeframeSerializationService, TimeseriesChartPreset, TimeseriesChartPresetService, TimeseriesChartTypes, TimeseriesDataSourceAdapter, TimeseriesInspectionMenuComponent, TimeseriesInteractionType, TimeseriesMetadataConfigurationComponent, TimeseriesScaleType, TimeseriesSeriesCollectionConfigurationComponent, TimeseriesSeriesConverterService, TimeseriesTileDescriptionConfigurationComponent, TimeseriesTileIndicatorDataConfigurationComponent, TimeseriesTransformer, TimeseriesWidgetComponent, TimeseriesWidgetProjectType, TitleAndDescriptionConfigurationComponent, TitleAndDescriptionConverterService, UnitTestRegistryService, UrlInteractionHandler, UrlInteractionService, ValueSelectorComponent, WIDGET_BODY, WIDGET_CREATE, WIDGET_EDIT, WIDGET_HEADER, WIDGET_LOADING, WIDGET_POSITION_CHANGE, WIDGET_READY, WIDGET_REMOVE, WIDGET_RESIZE, WIDGET_SEARCH, WellKnownDataSourceFeatures, WellKnownPathKey, WellKnownProviders, WidgetBodyComponent, WidgetBodyContentComponent, WidgetClonerComponent, WidgetClonerService, WidgetComponent, WidgetConfigurationService, WidgetConfiguratorSectionComponent, WidgetConfiguratorSectionHeaderPipe, WidgetEditorAccordionComponent, WidgetEditorAccordionFormStatePipe, WidgetEditorAccordionHeaderComponent, WidgetEditorComponent, WidgetEditorDirective, WidgetEditorService, WidgetErrorComponent, WidgetHeaderComponent, WidgetSearchComponent, WidgetToDashboardEventProxyService, WidgetTypesService, WindowObject, XYChartComponent, applyStatusEndpoints, chartPaletteColorMap, fieldMapper, getPizzagnaPropertyPath, hasControlInErrorState, hasTimeseriesWidgetSummaryLegend, mapDataToFormatterProperties, mergeChanges, metricsSeriesMeasurementsMinMax, percentageAggregator, refresher, sumAggregator, timeSeriesDatetimeFormatter, transformChangePoint, transformDifference, transformFloatingAverage, transformLinReg, transformLoessSmoothing, transformLoessStandardize, transformNormalize, transformPercentileStd, transformStandardize, widgetBodyContentNodes };
export type { BroadcasterTrackOnType, ComparatorFn, ComparatorTypes, DeepPartial, IAddFormattersOptions, IAggregatorConfiguratorProperties, IBackgroundColorComparator, IBroadcasterConfig, IBroker, IBrokerUserConfig, IBrokerValue, IChartPreset, IComparatorsDict, IComponentConfiguration, IComponentIdPayload, IComponentPortalBundle, IComponentWithLateLoadKey, IConfigurable, IConfigurator, IConfiguratorConverter, IConfiguratorForm, IConfiguratorSource, IConverterFormPartsProperties, IDashboard, IDashboardBelowFoldLazyLoadingConfig, IDashboardPersistenceHandler, IDashwizButtonsComponent, IDashwizComponent, IDashwizStepComponent, IDashwizStepNavigatedEvent, IDashwizWaitEvent, IDataSourceBusyPayload, IDataSourceError, IDataSourceOutput, IDataSourceOutputPayload, IDonutContentConfig, IDrilldownComponentConfiguration, IDrilldownComponentsConfiguration, IFieldMapperAggregatorProperties, IFormatter, IFormatterConfigurator, IFormatterDefinition, IFormatterDefinitionProperties, IFormatterProperties, IHasChangeDetector, IHasComponent, IHasForm, IHeaderLinkProvider, IInfoMessage, IInfoMessageProperties, IInteractionHandlerProperties, IInteractionPayload, IItemConfiguration, IKpiColorRules, IKpiConfiguration, IKpiData, IKpiFormatterProperties, IKpiFormattersConfiguration, IKpiItemConfiguration, IKpiThresholdsConfig, IKpiWidgetIndicatorData, ILegendFormat, ILegendPlacementOption, ILinkDefinition, IListWidgetConfiguration, INavigationBarButtons, INavigationBarConfig, IPageSizeSetMenuOption, IPaginatorState, IPaletteColor, IPercentageAggregatorProperties, IPizza, IPizzagna, IPizzagnaLayer, IPizzagnaProperty, IPortalEnvironment, IPreviewEventPayload, IProperties, IProportionalAggregatorFn, IProportionalAggregatorOrigin, IProportionalDataFieldsConfig, IProportionalDonutContentAggregator, IProportionalDonutContentAggregatorDefinition, IProportionalDonutContentAggregatorProperties, IProportionalWidgetChartEditorOptions, IProportionalWidgetChartOptions, IProportionalWidgetChartTypeConfiguration, IProportionalWidgetConfig, IProportionalWidgetData, IProviderConfiguration, IProviderConfigurationForDisplay, IProviderProperties, IRefresherProperties, IRegistryAddOptions, IRemoveMetricPayload, IRiskScoreConfiguration, IRiskScoreData, IRiskScoreFormatterProperties, IRiskScoreFormattersConfiguration, IRiskScoreItemConfiguration, ISearchOnKeyUp, ISerializableTimeframe, ISetPropertyPayload, IStaticProviders, ITableFormatterDefinition, ITableWidgetColumnConfig, ITableWidgetConfig, ITableWidgetPaginatorConfig, ITableWidgetSorterConfig, ITickLabelConfig, ITimeSpanOption, ITimeseriesChartTypeOption, ITimeseriesDataSourceAdapterConfiguration, ITimeseriesItemConfiguration, ITimeseriesOutput, ITimeseriesScaleConfig, ITimeseriesScalesConfig, ITimeseriesWidgetConfig, ITimeseriesWidgetData, ITimeseriesWidgetSeries, ITimeseriesWidgetSeriesData, ITimeseriesWidgetStatusData, ITimeseriesZoomPluginExploreData, IUrlInteractionHandlerProperties, IValueChange, IWidget, IWidgetEditor, IWidgetErrorDisplayProperties, IWidgetEvent, IWidgetMetadata, IWidgetPayload, IWidgetResizePayload, IWidgetSearchConfiguration, IWidgetSelector, IWidgetTemplateSelector, IWidgetToDashboardEventProxyConfiguration, IWidgetTypeDefinition, IWidgets, TableWidgetSelectionConfig, TimeseriesWidgetZoomPlugin, WidgetRemovalOperation, WidgetUpdateOperation };