mapa-library-ui 0.90.2 → 1.0.1

package/src/lib/components/button-icon/index.d.ts

@@ -1,5 +1,26 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="mapa-library-ui/src/lib/components/button-icon" />
-export * from './button-icon';
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, EventEmitter, SimpleChanges } from '@angular/core';
+import { SafeResourceUrl, DomSanitizer } from '@angular/platform-browser';
+
+interface ButtonIcon {
+    id: number;
+    icon: string;
+    description: string;
+    originList?: string;
+}
+
+declare class ButtonIconComponent implements OnInit, OnChanges {
+    private sanitizer;
+    data: ButtonIcon;
+    clicked: EventEmitter<ButtonIcon>;
+    imgBase64: SafeResourceUrl;
+    onClick(data: ButtonIcon): void;
+    constructor(sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonIconComponent, "mapa-button-icon", never, { "data": { "alias": "data"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+}
+
+export { ButtonIconComponent };

package/src/lib/components/capability/index.d.ts

@@ -1,5 +1,574 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="mapa-library-ui/src/lib/components/capability" />
-export * from './capability';
+import * as i0 from '@angular/core';
+import { EventEmitter, OnInit, OnChanges, AfterViewInit, ChangeDetectorRef, SimpleChanges, TemplateRef, ElementRef, ApplicationRef } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { MatCheckboxChange } from '@angular/material/checkbox';
+import { MatSelect } from '@angular/material/select';
+import * as rxjs from 'rxjs';
+import { ReplaySubject } from 'rxjs';
+import { MatIconRegistry } from '@angular/material/icon';
+import { DomSanitizer } from '@angular/platform-browser';
+import { MatAccordion } from '@angular/material/expansion';
+
+declare class ButtonComponent {
+    color: 'primary' | 'accent' | 'basic' | null | undefined;
+    disabled: boolean;
+    clicked: EventEmitter<void>;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "mapa-button", never, { "color": { "alias": "color"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+}
+
+interface ValidationMessageContext {
+    actualLength?: number;
+    max?: number;
+    min?: number;
+    requiredLength?: number;
+}
+type ValidationTextResolver = string | ((context?: ValidationMessageContext) => string);
+interface MapaUiTexts {
+    common: {
+        selectAll: string;
+    };
+    filters: {
+        clear: string;
+        submit: string;
+    };
+    datepicker: {
+        startDatePlaceholder: string;
+        endDatePlaceholder: string;
+    };
+    capability: {
+        groupAverageTitle: string;
+        individualAverageTitle: string;
+        conceptTitle: string;
+        resultTitle: string;
+        positiveIndicatorsTitle: string;
+        negativeIndicatorsTitle: string;
+        riskIndicatorsTitle: string;
+        precipitationRiskTitle: string;
+        negligenceRiskTitle: string;
+        negativeDirectionLabel: string;
+        positiveDirectionLabel: string;
+    };
+    paginator: {
+        itemsPerPage: string;
+        nextPage: string;
+        previousPage: string;
+        rangeLabel: (page: number, pageSize: number, length: number) => string;
+        showingRangeLabel: (page: number, pageSize: number, length: number) => string;
+    };
+    validation: {
+        cnpj: ValidationTextResolver;
+        cpf: ValidationTextResolver;
+        email: ValidationTextResolver;
+        max: ValidationTextResolver;
+        maxLength: ValidationTextResolver;
+        min: ValidationTextResolver;
+        minLength: ValidationTextResolver;
+        pattern: ValidationTextResolver;
+        required: ValidationTextResolver;
+    };
+}
+type PartialMapaUiTexts = Partial<{
+    [K in keyof MapaUiTexts]: Partial<MapaUiTexts[K]>;
+}>;
+
+interface ElementTreeNode {
+    key: string;
+    value: string;
+    children?: ElementTreeNode[];
+    isLeaf?: boolean;
+}
+interface ElementOption {
+    key: string;
+    value: string;
+    children?: ElementOption[];
+    childrenLevel?: number | null;
+}
+
+interface ElementGroup {
+    label: string;
+    options: ElementOption[];
+}
+
+interface ActionButton {
+    label: string;
+    action: EventEmitter<boolean>;
+}
+
+interface ElementSearch {
+    placeholder?: string;
+    noEntriesFoundLabel?: string;
+    formControl?: FormControl;
+    toggleAllCheckbox?: boolean;
+}
+
+interface Errors {
+    required?: string;
+    minLength?: string;
+    cpf?: string;
+    cnpj?: string;
+    email?: string;
+    pattern?: string;
+    min?: string;
+    max?: string;
+    maxLength?: string;
+}
+
+interface Status {
+    label: string;
+}
+declare class ElementBase {
+    value: string;
+    key: string;
+    label: string;
+    required: boolean;
+    order: number;
+    controlType: string;
+    type: string;
+    placeholder?: string;
+    readonly: boolean;
+    hint?: string;
+    prefix?: string;
+    suffix?: string;
+    autosize?: boolean;
+    autosizeMinWidth?: string;
+    autosizeMaxWidth?: string;
+    autosizeMinRow?: number;
+    autosizeMaxRow?: number;
+    options: ElementOption[] | ElementGroup[];
+    tree: ElementTreeNode[];
+    multiple?: boolean;
+    search?: ElementSearch;
+    maxLength: string | number | null;
+    errors?: Errors;
+    actionButton?: ActionButton;
+    mask?: string;
+    autocomplete?: string;
+    clearValue?: boolean;
+    status?: Status[];
+    checkParent?: boolean;
+    checkChildren?: boolean;
+    openedChange?: EventEmitter<boolean>;
+    constructor(options?: {
+        value?: string;
+        key?: string;
+        label?: string;
+        required?: boolean;
+        order?: number;
+        controlType?: string;
+        type?: string;
+        placeholder?: string;
+        readonly?: boolean;
+        hint?: string;
+        prefix?: string;
+        suffix?: string;
+        autosize?: boolean;
+        autosizeMinWidth?: string;
+        autosizeMaxWidth?: string;
+        autosizeMinRow?: number;
+        autosizeMaxRow?: number;
+        options?: ElementOption[] | ElementGroup[];
+        tree?: ElementTreeNode[];
+        multiple?: boolean;
+        search?: ElementSearch;
+        maxLength?: string | number | null;
+        errors?: Errors;
+        actionButton?: ActionButton;
+        mask?: string;
+        autocomplete?: string;
+        clearValue?: boolean;
+        status?: Status[];
+        checkParent?: boolean;
+        checkChildren?: boolean;
+        openedChange?: EventEmitter<boolean>;
+    });
+}
+
+declare class Dropdown extends ElementBase {
+    controlType: string;
+}
+
+declare class MapaI18nService {
+    private readonly injector;
+    private readonly textsState;
+    readonly textsSignal: i0.Signal<MapaUiTexts>;
+    readonly texts$: rxjs.Observable<MapaUiTexts>;
+    constructor(customTexts: PartialMapaUiTexts | null);
+    get texts(): MapaUiTexts;
+    setTexts(texts: PartialMapaUiTexts): void;
+    resolveValidationText(key: keyof MapaUiTexts["validation"], context?: ValidationMessageContext): string;
+    private resolveText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaI18nService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MapaI18nService>;
+}
+
+declare class MapaDropdownComponent implements OnInit, OnChanges, AfterViewInit {
+    private readonly i18n;
+    private readonly cdr;
+    formControl: FormControl;
+    formControlSearch: FormControl;
+    element: Dropdown;
+    border: "soft" | "tag" | "highlight" | null | undefined;
+    openedChange: EventEmitter<boolean>;
+    dropdown: MatSelect;
+    filteredOptions: ReplaySubject<ElementOption[]>;
+    filteredGroups: ReplaySubject<ElementGroup[]>;
+    protected filteredOptionsCache: ElementOption[];
+    protected filteredGroupCache: ElementGroup[];
+    private readonly destroyRef;
+    isIndeterminate: boolean;
+    isChecked: boolean;
+    isOptionsGroup: boolean;
+    constructor(i18n: MapaI18nService, cdr: ChangeDetectorRef);
+    get texts(): MapaUiTexts;
+    get selectAllLabel(): string;
+    get selectedOptions(): ElementOption[];
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setOptions(): void;
+    protected filterOptionsFromGroup(group: ElementGroup, value: string): ElementOption[];
+    protected filterOptions(): void;
+    normalizeValue(value?: string | null): string;
+    triggerOpenedChange(event: boolean): void;
+    protected setToggleAllCheckboxState(): void;
+    toggleSelectAll(event: MatCheckboxChange): void;
+    isElementGroup(object: ElementGroup | ElementOption): object is ElementGroup;
+    isElementOption(object: unknown): object is ElementOption;
+    compareFn(c1: ElementOption | null, c2: ElementOption | null): boolean;
+    hasValue(): boolean;
+    clearValue(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaDropdownComponent, "mapa-dropdown", never, { "formControl": { "alias": "formControl"; "required": false; }; "formControlSearch": { "alias": "formControlSearch"; "required": false; }; "element": { "alias": "element"; "required": false; }; "border": { "alias": "border"; "required": false; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+declare class IconComponent {
+    private matIconRegistry;
+    private domSanitizer;
+    svg: string | null | undefined;
+    constructor(matIconRegistry: MatIconRegistry, domSanitizer: DomSanitizer);
+    ngOnChanges(): void;
+    registerCustomIcons(svg: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "mapa-icon", never, { "svg": { "alias": "svg"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare enum TooltipPosition {
+    ABOVE = "above",
+    BELOW = "below",
+    LEFT = "left",
+    RIGHT = "right",
+    DYNAMIC = "dynamic",
+    DEFAULT = "below"
+}
+declare enum TooltipTheme {
+    DARK = "dark",
+    LIGHT = "light",
+    DEFAULT = "light"
+}
+
+declare class MapaTooltipDirective {
+    private readonly elementRef;
+    private readonly appRef;
+    tooltip: TemplateRef<unknown>;
+    position: TooltipPosition;
+    theme: TooltipTheme;
+    showDelay: number;
+    hideDelay: number;
+    private componentRef;
+    private showTimeout?;
+    private hideTimeout?;
+    private touchTimeout?;
+    private readonly destroyRef;
+    private readonly environmentInjector;
+    constructor(elementRef: ElementRef<HTMLElement>, appRef: ApplicationRef);
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onMouseMove($event: MouseEvent): void;
+    onTouchStart($event: TouchEvent): void;
+    onTouchEnd(): void;
+    private initializeTooltip;
+    private setTooltipComponentProperties;
+    private showTooltip;
+    private setHideTooltipTimeout;
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MapaTooltipDirective, "[tooltip]", never, { "tooltip": { "alias": "tooltip"; "required": false; }; "position": { "alias": "position"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "showDelay": { "alias": "showDelay"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaTooltipComponent {
+    tooltip: TemplateRef<unknown>;
+    position: TooltipPosition;
+    theme: TooltipTheme;
+    visible: boolean;
+    left: number;
+    top: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaTooltipComponent, "lib-tooltip", never, {}, {}, never, never, true, never>;
+}
+
+interface CapabilityClassification {
+    id: number;
+    name: string;
+    color: string;
+    positive: boolean;
+}
+
+interface Classification {
+    classificationId?: number;
+    classificationName?: string;
+    classificationColor?: string;
+    classificationBg?: string;
+}
+
+interface CapabilityItem {
+    competenceId?: number;
+    indicatorId?: number;
+    name?: string;
+    indicatorName?: string;
+    indicatorConcept?: string;
+    dimensionName?: string;
+    interval?: number;
+    escoreT?: number;
+    classification?: Classification;
+    competenceName?: string;
+    scaleName?: string;
+    classificationId?: number;
+    classificationName?: string;
+    classificationColor?: string;
+    classificationFontSize?: string;
+    classificationBg?: string;
+    direction?: string | null;
+    risk?: boolean | null;
+    precipitation?: boolean | null;
+    negligence?: boolean | null;
+    indicatorOrder?: number;
+    description?: string;
+    average?: number;
+    concept?: string;
+    isIndividually?: boolean;
+    dimensionClassificationMessage?: string;
+}
+
+interface CapabilityComparative {
+    name: string;
+    groupAvg: number;
+    individualAvg: number;
+    indicators: {
+        name: string;
+        items: CapabilityItem[];
+    }[];
+}
+
+interface Capability extends CapabilityItem {
+    items: CapabilityItem[];
+    capabilityConcept?: {
+        concept?: string;
+        result?: string;
+    };
+}
+
+interface Indicators {
+    competenceId?: number;
+    competenceName: string;
+    indicators: CapabilityItem[];
+}
+
+interface DetailedIndicatorItem {
+    name: string;
+    concept: string;
+    interval: number;
+    classificationId?: number;
+    classificationName?: string;
+    classificationColor?: string;
+}
+interface DetailedIndicatorSection {
+    title: string;
+    items: DetailedIndicatorItem[];
+}
+interface IndicatorCollections {
+    all: CapabilityItem[];
+    positive: CapabilityItem[];
+    negative: CapabilityItem[];
+    precipitation: CapabilityItem[];
+    negligence: CapabilityItem[];
+}
+interface IndicatorCollectionOptions {
+    includeDirectionSign?: boolean;
+}
+declare function normalizeText(value?: string | null): string;
+declare function normalizeLookup(value?: string | null): string;
+declare function buildIndicatorCollections(indicators: Indicators[], options?: IndicatorCollectionOptions): IndicatorCollections;
+declare function buildDetailedIndicatorSections(indicators: Indicators[]): DetailedIndicatorSection[];
+
+declare class CapabilityClassificationService {
+    getByItem(item: CapabilityItem): CapabilityClassification;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CapabilityClassificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CapabilityClassificationService>;
+}
+
+declare class MapaCapabilityDotComponent {
+    classification: CapabilityClassificationService;
+    type: string;
+    item: CapabilityItem;
+    tooltip: boolean;
+    capability?: Capability;
+    constructor(classification: CapabilityClassificationService);
+    createTag(): {
+        size: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityDotComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityDotComponent, "mapa-capability-dot", never, { "type": { "alias": "type"; "required": false; }; "item": { "alias": "item"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "capability": { "alias": "capability"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityExpandComponent {
+    classification: CapabilityClassificationService;
+    private readonly i18n;
+    data: Capability;
+    constructor(classification: CapabilityClassificationService, i18n: MapaI18nService);
+    get texts(): MapaUiTexts;
+    get conceptTitle(): string;
+    get resultTitle(): string;
+    get negativeDirectionLabel(): string;
+    get positiveDirectionLabel(): string;
+    createTag(item: CapabilityItem): {
+        bgColor: string;
+        fontSize: string;
+        size: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityExpandComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityExpandComponent, "mapa-capability-expand", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityIndicatorComponent {
+    item: CapabilityItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityIndicatorComponent, "mapa-capability-indicator", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityIntervalComponent implements OnInit, OnChanges {
+    data: Capability;
+    showInterval: boolean;
+    paintLinear: string;
+    SVG: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[];
+    hasTransform: boolean;
+    indexTransform: number;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    getWidth(index: number): number;
+    getFill(i: number): string;
+    getFillGradient(): string;
+    getTransform(i: number): string;
+    getStartOffset(): number;
+    getStopOffset(): number;
+    getGradientX(): number;
+    isSVG(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityIntervalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityIntervalComponent, "mapa-capability-interval", never, { "data": { "alias": "data"; "required": false; }; "showInterval": { "alias": "showInterval"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityIntervalBarComponent {
+    data: Capability;
+    expanded?: boolean;
+    showInterval: boolean;
+    clicked: EventEmitter<void>;
+    isHovering: boolean;
+    isClicked: boolean;
+    isSVG(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityIntervalBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityIntervalBarComponent, "mapa-capability-interval-bar", never, { "data": { "alias": "data"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "showInterval": { "alias": "showInterval"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+}
+
+declare class MapaCapabilityComparativeComponent {
+    data: CapabilityComparative;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityComparativeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityComparativeComponent, "mapa-capability-comparative", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityComparativeChartComponent {
+    data: CapabilityComparative;
+    setCleanItem(item: CapabilityItem): CapabilityItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityComparativeChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityComparativeChartComponent, "mapa-capability-comparative-chart", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityComparativeHeaderComponent {
+    private readonly i18n;
+    data: CapabilityComparative;
+    constructor(i18n: MapaI18nService);
+    get texts(): MapaUiTexts;
+    get groupAverageTitle(): string;
+    get individualAverageTitle(): string;
+    getCapabilityData(item: number): Capability;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityComparativeHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityComparativeHeaderComponent, "mapa-capability-comparative-header", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityDetailComponent implements AfterViewInit, OnChanges, OnInit {
+    classification: CapabilityClassificationService;
+    data: Capability[];
+    showTags: boolean;
+    showProgressBar: boolean;
+    showInterval: boolean;
+    isExpanded: boolean;
+    accordion: MatAccordion;
+    expanded: Set<number>;
+    showTagInterval: boolean;
+    constructor(classification: CapabilityClassificationService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private syncExpandedState;
+    sortItemsByinterval(items: CapabilityItem[] | undefined): CapabilityItem[];
+    showMore(index: number): void;
+    toggleAll(): void;
+    createTag(item: Capability): {
+        bgColor: string;
+        fontSize: string;
+        size: string;
+    };
+    isSVG(item: Capability): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityDetailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityDetailComponent, "mapa-capability-detail", never, { "data": { "alias": "data"; "required": false; }; "showTags": { "alias": "showTags"; "required": false; }; "showProgressBar": { "alias": "showProgressBar"; "required": false; }; "showInterval": { "alias": "showInterval"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityIndicatorListComponent implements OnInit, OnChanges {
+    private readonly i18n;
+    data: CapabilityItem[];
+    dataPositive: CapabilityItem[];
+    dataNegative: CapabilityItem[];
+    dataRiskPrecipitation: CapabilityItem[];
+    dataRiskNegligence: CapabilityItem[];
+    constructor(i18n: MapaI18nService);
+    get texts(): MapaUiTexts;
+    get positiveIndicatorsTitle(): string;
+    get negativeIndicatorsTitle(): string;
+    get riskIndicatorsTitle(): string;
+    get precipitationRiskTitle(): string;
+    get negligenceRiskTitle(): string;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private buildIndicatorGroups;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityIndicatorListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityIndicatorListComponent, "mapa-capability-indicator-list", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaCapabilityIndicatorChartComponent {
+    classification: CapabilityClassificationService;
+    data: CapabilityItem[];
+    constructor(classification: CapabilityClassificationService);
+    setUnlabeledItem(item: CapabilityItem): CapabilityItem;
+    getWidth(item: CapabilityItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaCapabilityIndicatorChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaCapabilityIndicatorChartComponent, "mapa-capability-indicator-chart", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { ButtonComponent, CapabilityClassificationService, IconComponent, MapaCapabilityComparativeChartComponent, MapaCapabilityComparativeComponent, MapaCapabilityComparativeHeaderComponent, MapaCapabilityDetailComponent, MapaCapabilityDotComponent, MapaCapabilityExpandComponent, MapaCapabilityIndicatorChartComponent, MapaCapabilityIndicatorComponent, MapaCapabilityIndicatorListComponent, MapaCapabilityIntervalBarComponent, MapaCapabilityIntervalComponent, MapaDropdownComponent, MapaTooltipComponent, MapaTooltipDirective, buildDetailedIndicatorSections, buildIndicatorCollections, normalizeLookup, normalizeText };
+export type { Capability, CapabilityClassification, CapabilityComparative, CapabilityItem, DetailedIndicatorItem, DetailedIndicatorSection, IndicatorCollectionOptions, IndicatorCollections, Indicators };