mapa-library-ui 0.90.2 → 1.0.0

package/index.d.ts

@@ -1,5 +1,1880 @@
+import { FormControl, NgModel, AbstractControl, FormGroup } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { EventEmitter, AfterViewInit, ElementRef, OnChanges, Renderer2, SimpleChanges, InjectionToken, Provider, PipeTransform, OnInit, ChangeDetectorRef, Injector, TemplateRef, ApplicationRef } from '@angular/core';
+import { ApexAxisChartSeries, ApexChart, ApexTitleSubtitle, ApexXAxis, ApexStroke, ApexFill, ApexMarkers, ApexYAxis, ApexLegend, ApexResponsive } from 'ng-apexcharts';
+import { MatInput } from '@angular/material/input';
+import { MatPaginator, MatPaginatorIntl, PageEvent } from '@angular/material/paginator';
+import * as rxjs from 'rxjs';
+import { ReplaySubject } from 'rxjs';
+import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
+import * as mapa_library_ui from 'mapa-library-ui';
+import { MatAccordion } from '@angular/material/expansion';
+import { MatDialogRef, MatDialog, MatDialogConfig } from '@angular/material/dialog';
+import { MatCheckboxChange } from '@angular/material/checkbox';
+import { MatSelect } from '@angular/material/select';
+import { Sort, MatSort } from '@angular/material/sort';
+import { MatTableDataSource, MatTable } from '@angular/material/table';
+import { MatIconRegistry } from '@angular/material/icon';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { HttpClient } from '@angular/common/http';
+import { SelectionModel } from '@angular/cdk/collections';
+
+interface ElementSearch {
+    placeholder?: string;
+    noEntriesFoundLabel?: string;
+    formControl?: FormControl;
+    toggleAllCheckbox?: boolean;
+}
+
+interface ActionButton {
+    label: string;
+    action: EventEmitter<boolean>;
+}
+
+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 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 DropdownTree extends ElementBase {
+    controlType: string;
+}
+
+declare class InputText extends ElementBase {
+    controlType: string;
+}
+
+declare class RadioButton extends ElementBase {
+    controlType: string;
+}
+
+declare class SlideToggle extends ElementBase {
+    controlType: string;
+}
+
+declare class Textarea extends ElementBase {
+    controlType: string;
+}
+
+interface ButtonIcon {
+    id: number;
+    icon: string;
+    description: string;
+    originList?: string;
+}
+
+interface Breadpiece {
+    title: string;
+    url?: string;
+}
+
+type ChartOptions = {
+    series: ApexAxisChartSeries;
+    chart: ApexChart;
+    title: ApexTitleSubtitle;
+    xaxis: ApexXAxis;
+    stroke?: ApexStroke;
+    fill?: ApexFill;
+    markers?: ApexMarkers;
+    yaxis?: ApexYAxis;
+    legend?: ApexLegend;
+    responsive?: ApexResponsive[];
+    dropdown?: {
+        element: Dropdown;
+        formControl: FormControl;
+    };
+};
+
+interface Classification$1 {
+    classificationId?: number;
+    classificationName?: string;
+    classificationColor?: string;
+    classificationBg?: string;
+}
+
+interface DialogData {
+    title: string;
+    description: string;
+    actions: {
+        close?: string;
+        save?: string;
+    };
+    imgBase64?: string;
+    isReportRegistration?: boolean;
+    button?: string;
+}
+
+interface MenuActionItem {
+    image?: string;
+    icon?: string;
+    route?: string;
+    showText?: boolean;
+    svg?: string;
+    text: string;
+    action: string;
+    disabled?: boolean;
+}
+interface MenuActionEvent<TData = unknown> {
+    action: string;
+    data: TData;
+}
+
+interface TableColumnStatus {
+    label?: string[];
+    color?: string[];
+    textColor?: string[];
+    style?: "square" | "round";
+}
+interface TableColumn {
+    key: string;
+    label: string;
+    sort?: boolean;
+    status?: TableColumnStatus;
+    mask?: string;
+    width?: string;
+    collapse?: string;
+    align?: string;
+    class?: string;
+    classification?: Classification$1;
+}
+
+interface TableCellStyleClass {
+    key: string;
+    class: string;
+}
+interface TableRowData extends Record<string, unknown> {
+    actions?: MenuActionItem[] | string | null;
+    menu?: MenuActionItem[] | null;
+    position?: number;
+    rowStyleClass?: string;
+    styleClass?: TableCellStyleClass;
+}
+interface SelectedTableRow<TData = TableRowData> {
+    row: TData;
+}
+
+interface RowClickEvent<TData = TableRowData> {
+    row: TData;
+    action: string;
+}
+
+declare class MatInputAutosizeDirective implements AfterViewInit {
+    private childMatInput;
+    private childNgModel;
+    inputElement: HTMLInputElement;
+    hiddenText: Text;
+    private readonly destroyRef;
+    matInputAutosizeMaxWidth?: string | null;
+    matInputAutosizeMinWidth: string;
+    matInputAutosizeFontStyle?: string | null;
+    constructor(el: ElementRef<HTMLInputElement>, childMatInput: MatInput, childNgModel: NgModel);
+    ngAfterViewInit(): void;
+    checkErrors(): void;
+    overwriteParentWidth(): void;
+    createHiddenTextContainer(): void;
+    setOwnStyles(): void;
+    subscribeToChanges(): void;
+    changeHiddenText: (newValue: unknown) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatInputAutosizeDirective, [null, { self: true; }, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatInputAutosizeDirective, "[matInputAutosize]", never, { "matInputAutosizeMaxWidth": { "alias": "matInputAutosizeMaxWidth"; "required": false; }; "matInputAutosizeMinWidth": { "alias": "matInputAutosizeMinWidth"; "required": false; }; "matInputAutosizeFontStyle": { "alias": "matInputAutosizeFontStyle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BubblePaginationDirective implements AfterViewInit, OnChanges {
+    private readonly matPag;
+    private elementRef;
+    private ren;
+    pageIndexChangeEmitter: EventEmitter<number>;
+    showFirstButton: boolean;
+    showLastButton: boolean;
+    renderButtonsNumber: number;
+    appCustomLength: number;
+    hideDefaultArrows: boolean;
+    bubblePageIndex: number;
+    private dotsEndRef;
+    private dotsStartRef;
+    private bubbleContainerRef;
+    private buttonsRef;
+    private readonly destroyRef;
+    constructor(matPag: MatPaginator, elementRef: ElementRef, ren: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private renderButtons;
+    private changeActiveButtonStyles;
+    private styleDefaultPagination;
+    private createBubbleDivRef;
+    private buildButtons;
+    private removeButtons;
+    private createButton;
+    private createDotsElement;
+    private switchPage;
+    private updateButtonsOnPageEvent;
+    private rebuildButtons;
+    private getNeededButtons;
+    private getActivePageIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BubblePaginationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BubblePaginationDirective, "[appBubblePagination]", never, { "showFirstButton": { "alias": "showFirstButton"; "required": false; }; "showLastButton": { "alias": "showLastButton"; "required": false; }; "renderButtonsNumber": { "alias": "renderButtonsNumber"; "required": false; }; "appCustomLength": { "alias": "appCustomLength"; "required": false; }; "hideDefaultArrows": { "alias": "hideDefaultArrows"; "required": false; }; "bubblePageIndex": { "alias": "bubblePageIndex"; "required": false; }; }, { "pageIndexChangeEmitter": "pageIndexChangeEmitter"; }, never, 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]>;
+}>;
+declare const MAPA_UI_TEXTS: InjectionToken<Partial<{
+    common: Partial<{
+        selectAll: string;
+    }>;
+    filters: Partial<{
+        clear: string;
+        submit: string;
+    }>;
+    datepicker: Partial<{
+        startDatePlaceholder: string;
+        endDatePlaceholder: string;
+    }>;
+    capability: Partial<{
+        groupAverageTitle: string;
+        individualAverageTitle: string;
+        conceptTitle: string;
+        resultTitle: string;
+        positiveIndicatorsTitle: string;
+        negativeIndicatorsTitle: string;
+        riskIndicatorsTitle: string;
+        precipitationRiskTitle: string;
+        negligenceRiskTitle: string;
+        negativeDirectionLabel: string;
+        positiveDirectionLabel: string;
+    }>;
+    paginator: Partial<{
+        itemsPerPage: string;
+        nextPage: string;
+        previousPage: string;
+        rangeLabel: (page: number, pageSize: number, length: number) => string;
+        showingRangeLabel: (page: number, pageSize: number, length: number) => string;
+    }>;
+    validation: Partial<{
+        cnpj: ValidationTextResolver;
+        cpf: ValidationTextResolver;
+        email: ValidationTextResolver;
+        max: ValidationTextResolver;
+        maxLength: ValidationTextResolver;
+        min: ValidationTextResolver;
+        minLength: ValidationTextResolver;
+        pattern: ValidationTextResolver;
+        required: ValidationTextResolver;
+    }>;
+}>>;
+declare const MAPA_UI_DEFAULT_TEXTS: MapaUiTexts;
+declare function mergeMapaUiTexts(customTexts?: PartialMapaUiTexts | null): MapaUiTexts;
+declare function provideMapaUiTexts(texts: PartialMapaUiTexts): Provider;
+
+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 ValidationMessageResolverService {
+    private readonly i18n;
+    private readonly errorOrder;
+    constructor(i18n: MapaI18nService);
+    resolveFirstError(control?: AbstractControl | null, errors?: Errors): string | null;
+    private resolveErrorMessage;
+    private getCustomMessage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationMessageResolverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationMessageResolverService>;
+}
+
+declare class MapaFormErrorsComponent {
+    private readonly validationMessageResolver;
+    control?: AbstractControl | null;
+    errors?: Errors;
+    constructor(validationMessageResolver: ValidationMessageResolverService);
+    get message(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaFormErrorsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaFormErrorsComponent, "mapa-form-errors", never, { "control": { "alias": "control"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function sanitizeHtmlContent(sanitizer: DomSanitizer, value?: string | null): string;
+declare class HtmlSanitizerService {
+    private readonly sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    sanitize(value?: string | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlSanitizerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HtmlSanitizerService>;
+}
+
+declare class SafeHtmlPipe implements PipeTransform {
+    private readonly htmlSanitizer;
+    constructor(htmlSanitizer: HtmlSanitizerService);
+    transform(value?: string | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+
+declare class CPFPipe implements PipeTransform {
+    transform(cpfValue: string | number | null | undefined): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CPFPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CPFPipe, "cpf", true>;
+}
+
+interface BigObject<T> {
+    [index: string]: T;
+}
+interface MaskType {
+    text?: string;
+    textMask: false | (string | RegExp)[] | ((raw: string) => (string | RegExp)[]);
+    numberToString?: Function;
+    textMaskFunction?: Function;
+}
+interface Masks {
+    aih: MaskType;
+    cartaocredito: MaskType;
+    celular: MaskType;
+    cep: MaskType;
+    certidao: MaskType;
+    chassi: MaskType;
+    cid: MaskType;
+    cnae: MaskType;
+    cnh: MaskType;
+    cnhespelho: MaskType;
+    renachestadual: MaskType;
+    renachseguranca: MaskType;
+    cnpj: MaskType;
+    cns: MaskType;
+    contabanco: MaskType;
+    cpf: MaskType;
+    cpfcnpj: MaskType;
+    currency: MaskType;
+    data: MaskType;
+    datahora: MaskType;
+    date: MaskType;
+    datetime: MaskType;
+    ect: MaskType;
+    endereco: MaskType;
+    iptu: MaskType;
+    number: MaskType;
+    porcentagem: MaskType;
+    pispasep: MaskType;
+    placa: MaskType;
+    processo: MaskType;
+    renavam: MaskType;
+    rg: MaskType;
+    sped: MaskType;
+    telefone: MaskType;
+    time: MaskType;
+    titulo: MaskType;
+    utils: MaskType;
+}
+interface MasksIE {
+    [index: string]: MaskType;
+}
+
+declare function isPresent(obj: any): boolean;
+declare function isArray(value: any): value is any[];
+declare function isString(value: any): value is string | String;
+declare function isNumber(value: any): boolean;
+declare function isNil(value: any): boolean;
+declare function processCaretTraps(mask: any): {
+    maskWithoutCaretTraps: any;
+    indexes: number[];
+};
+declare const modulo11: (value: string) => number;
+declare const modulo11Custom: (string: string, size: number, maxMult?: number, by10?: boolean) => string;
+declare const modulo11a: (string: string, size: number, mod: number) => number;
 /**
- * Generated bundle index. Do not edit.
+ *
+ * @param input
+ * ^ - Match line start
+  (\d) - match first digit and capture it in back reference #1 i.e. \1
+  (?!..) is a negative lookahead
+  (?!\1+$) means disallow the match if first digit is followed by same digit (captured group) till end.
+  \d{11}$ match next 11 digit followed by line end
  */
-/// <amd-module name="mapa-library-ui" />
-export * from './public-api';
+declare function allNumbersAreSame(inputValue: string): boolean;
+declare function getAllDigits(input: string): string;
+declare function getAllWords(input: string): string;
+declare function currencyToNumber(input: string | number): number;
+declare function numberToCurrency(value: number): string;
+declare function slugify(value: string): string;
+/**
+ *
+ * @param string  ex. 12345
+ * @param size   11
+ * @param fill   0
+ *
+ * Returns: 00000012345
+ */
+declare function fillString(string: string, size: number, fill: string): string;
+declare function randArray(array: string | any[]): any;
+declare function rand(length: number, ...ranges: any[]): string;
+declare function randomNumber(begin: number, end: number): number;
+declare function randomLetter(size?: number, onlyCapitals?: boolean): string;
+declare function randomLetterOrNumber(size?: number, onlyCapitals?: boolean): string;
+declare const randomEstadoSigla: () => any;
+declare const CORES: string[];
+declare function getSpecialProperty<TModel, TKey extends keyof TModel>(model: TModel, key: TKey): TModel[TKey];
+/**
+ *
+ */
+declare const makeGenericFaker: (val: any, options?: BigObject<Function> | null) => () => any;
+
+declare function validate_aih(aih: string): boolean;
+declare function validate_celular(cel: any): boolean;
+declare const CEPRange: BigObject<RegExp>;
+declare function validate_cep(cep: string): boolean;
+declare function cep_ranges(cep: string | number): boolean;
+declare function validate_certidao(value: string): boolean;
+/**
+ *
+ * @param chassi
+ */
+declare function validate_chassi(chassi: string): boolean;
+/**
+ *
+ * II - Número do Espelho da CNH - segundo número de identificação nacional,
+ * que será formado por 9 (nove) caracteres mais 1 (um) dígito verificador de segurança,
+ * autorizado e controlado pelo DENATRAN, e identificará cada espelho de CNH expedida.
+ * https://www.gov.br/infraestrutura/pt-br/assuntos/transito/conteudo-denatran/resolucoes-contran
+ * https://www.gov.br/infraestrutura/pt-br/assuntos/transito/conteudo-contran/resolucoes/resolucao5112014.pdf
+ * 598: https://www.gov.br/infraestrutura/pt-br/assuntos/transito/conteudo-contran/resolucoes/resolucao59820162.pdf
+ * @param value
+ */
+declare function validate_cnhespelho(value: string): boolean;
+/**
+ *
+ * III – Número do formulário RENACH - número de identificação
+* estadual, documento de coleta de dados do candidato/condutor gerado a cada serviço,
+* composto, obrigatoriamente, por 11 (onze) caracteres, sendo as duas primeiras
+* posições formadas pela sigla da Unidade de Federação expedidora, facultada a
+* utilização da última posição como dígito verificador de segurança.
+*  a) O número do formulário RENACH identificará a Unidade da
+* Federação onde o condutor foi habilitado ou realizou alterações de dados no seu
+* cadastro pela última vez.
+*  b) O Formulário RENACH que dá origem às informações na
+* BINCO e autorização para a impressão da CNH deverá ficar arquivado em seg
+* 598 - https://www.gov.br/infraestrutura/pt-br/assuntos/transito/conteudo-contran/resolucoes/resolucao59820162.pdf
+* 718 - https://www.gov.br/infraestrutura/pt-br/assuntos/transito/conteudo-contran/resolucoes/resolucao7182017.pdf
+* @param value
+ */
+declare function validate_renachestadual(value: string): boolean;
+declare function validate_renachseguranca(value: string): boolean;
+/**
+ * BINCO
+ * I – o primeiro número de identificação nacional – Registro Nacional,
+ * será gerado pelo sistema informatizado da Base Índice Nacional de Condutores –
+ * BINCO, composto de 9 (nove) caracteres mais 2 (dois) dígitos verificadores de
+ * segurança, sendo único para cada condutor e o acompanhará durante toda a
+ * sua existência como condutor, não sendo permitida a sua reutilização para
+ * outro condutor.
+ * @param value
+ * @returns
+ */
+declare function validate_cnh(value: string): boolean;
+declare function validate_cnpj(cnpj: any): boolean;
+/**
+ * Referencia: http://www.receita.fazenda.gov.br/aplicacoes/atcta/funcoes.js
+ * @param strCPF
+ * @returns
+ */
+declare function validate_cpf(strCPF: any): boolean;
+declare function validate_cns(value: string): boolean;
+declare function validate_cartaocredito(input: string | number): boolean;
+/**
+ *     A hash of valid CC abbreviations and regular expressions
+    mc: Mastercard
+    ec: Eurocard
+    vi: Visa
+    ax: American Express
+    dc: Diners Club
+    bl: Carte Blanch
+    di: Discover
+    jcb: JCB
+    er: Enroute
+*/
+declare const creditCardValidator: BigObject<RegExp>;
+declare function validate_currency(currency: string | number): boolean;
+declare function validate_datetime(time: string | number, options?: any): boolean;
+declare function validate_datahora(time: string | number, options?: any): boolean;
+declare function validate_ect(number: string): boolean;
+declare function validate_number(number: string): boolean;
+declare function validate_porcentagem(porcentagem: string): boolean;
+declare function validate_processo(processo: any): boolean;
+declare function validate_pispasep(number: string): boolean;
+declare function validate_renavam(renavam: any): boolean;
+declare function validate_rg(rg: string): any;
+declare function validate_sped(sped: string): boolean;
+declare function validate_telefone(tel: any): boolean;
+declare function validate_time(time: string | number, options?: any): boolean;
+declare function validate_titulo(titulo: any): boolean;
+declare const validateBr: BigObject<Function>;
+
+declare const utilsBr: {
+    isPresent: typeof isPresent;
+    isArray: typeof isArray;
+    isString: typeof isString;
+    isNumber: typeof isNumber;
+    isNil: typeof isNil;
+    processCaretTraps: typeof processCaretTraps;
+    allNumbersAreSame: typeof allNumbersAreSame;
+    getAllDigits: typeof getAllDigits;
+    getAllWords: typeof getAllWords;
+    currencyToNumber: typeof currencyToNumber;
+    modulo11: (value: string) => number;
+    numberToCurrency: typeof numberToCurrency;
+    slugify: typeof slugify;
+    fillString: typeof fillString;
+    randArray: typeof randArray;
+    rand: typeof rand;
+    randomNumber: typeof randomNumber;
+    randomLetter: typeof randomLetter;
+    randomLetterOrNumber: typeof randomLetterOrNumber;
+    getSpecialProperty: typeof getSpecialProperty;
+    MASKS: BigObject<mapa_library_ui.MaskType>;
+    MASKSIE: BigObject<mapa_library_ui.MaskType>;
+    PLACAS_RANGE: string[][];
+    ESTADOS: {
+        name: string;
+        shortname: string;
+        slug: string;
+    }[];
+};
+declare const maskBr: BigObject<Function>;
+
+/**
+ *
+ * @param uf - UF do número da guia. Ex: 35(SP), 81(PE)
+ * @param ano - ANO do número da guia. Ex: 2018, 2019
+ * @param tipo - TIPO da guia. Aih = 1, APAC = 2
+ */
+declare function create_aih(value: string | number | any[]): string;
+declare function create_certidao(value: string): any;
+declare function create_cnhespelho(value: string): string;
+declare function create_renachestadual(value: string): string | false;
+/**
+ *
+ * @param value
+ * @returns
+ */
+declare function create_renachseguranca(value: string): string | false;
+/**
+ * Dígito verificador da CNH não é mais o módulo 11 conforme últimas resoluções
+ * @param value
+ * @returns
+ */
+declare function create_cnh(value: string): string | false;
+declare function create_cnpj(cnpj: string): false | number[];
+declare function create_cns(number: string): string;
+declare function create_cpf(strCPF: string): string | false;
+declare function create_cartaocredito(number: string): number;
+declare function create_ect(number: string): number;
+declare function create_pispasep(number: string): number;
+declare function create_renavam(renavam: string): number;
+/**
+ *
+ * Font: http://ghiorzi.org/index.htm
+ * @param number
+ */
+declare function create_processo(number: string): string;
+declare function create_titulo_atual(titulo: string): string;
+declare function create_titulo(titNum: string): any;
+
+declare const ESTADOS_SIGLA: any;
+type EstadosType = 'ac' | 'al' | 'am' | 'ap' | 'ba' | 'ce' | 'df' | 'es' | 'go' | 'ma' | 'mg' | 'ms' | 'mt' | 'pa' | 'pb' | 'pe' | 'pi' | 'pr' | 'rj' | 'rn' | 'ro' | 'rr' | 'rs' | 'sc' | 'se' | 'sp' | 'to';
+declare const ESTADOS: {
+    name: string;
+    shortname: string;
+    slug: string;
+}[];
+
+/**
+ * BASED ON https://github.com/gammasoft/ie/
+ */
+declare const generateInscricaoEstadual: BigObject<Function>;
+declare function validate_inscricaoestadual(ie: string | Array<string>, estado: any): any;
+declare const MASKSIE: BigObject<MaskType>;
+
+declare function create_iptu_ctba(number: string): number;
+declare function create_iptu_sp(number: string): number;
+declare const faker_iptu: (estado: string | number, cidade: string | number) => any;
+declare const IPTUCREATE: BigObject<BigObject<Function>>;
+
+declare const IPTUMASKS: BigObject<BigObject<MaskType>>;
+
+declare function validate_iptu_ctba(value: string | any[]): boolean;
+/**
+ * Índice Cadastral, ou inscrição imobiliária,  é o número de identificação do imóvel no cadastro da Prefeitura de Contagem.
+ * O índice é composto por 12 (doze) ou 13 (treze) números, sendo: 2 (dois) para a zona fiscal;
+ * 3 (três) ou 4 (quatro) para a quadra fiscal; 4 (quatro) para o lote fiscal; e 3 (três) para a unidade.
+ */
+declare function validate_iptu_contagem(number: any): boolean;
+declare function validate_iptu_sp(value: string | any[]): boolean;
+declare const IPTUVALIDATE: BigObject<BigObject<Function>>;
+
+declare const create_iptu: (number: string, estado: string | number, cidade: string | number) => any;
+declare const mask_iptu: (number: string, estado: string, cidade: string) => string | mapa_library_ui.MaskType;
+declare const validate_iptu: (number: string, estado: string | number, cidade: string | number) => any;
+
+declare const LOCALIZACAO_RUAS: string[];
+declare const LOCALIZACAO_LOGRADOUROS: string[];
+declare const LOCALIZACAO_COMPLEMENTOS: string[];
+declare const LOCALIZACAO_BAIRROS: string[];
+declare const LOCALIZACAO_ESTADOS: {
+    nome: string;
+    uf: string;
+}[];
+declare const LOCALIZACAO_CIDADES: string[][];
+
+declare const PLACAS_RANGE: string[][];
+declare const PLACAS_INVALID: {
+    start: string;
+    end: string;
+};
+declare function validate_placa(placa: string | number, incluiMercosul?: boolean): boolean;
+
+declare function rg_sp(number: string): any;
+declare function rg_rj(number: string): number;
+
+declare const AIH_ESTADOS: {
+    AC: string;
+    AL: string;
+    AP: string;
+    AM: string;
+    BA: string;
+    CE: string;
+    DF: string;
+    ES: string;
+    GO: string;
+    MA: string;
+    MT: string;
+    MS: string;
+    MG: string;
+    PA: string;
+    PB: string;
+    PR: string;
+    PE: string;
+    PI: string;
+    RJ: string;
+    RN: string;
+    RS: string;
+    RO: string;
+    RR: string;
+    SC: string;
+    SP: string;
+    SE: string;
+    TO: string;
+};
+declare const AIH_TIPOS: {
+    '1': string;
+    '2': string;
+    '3': string;
+    '4': string;
+    '5': string;
+};
+declare const CID_NAME: {
+    'A00-B99': string;
+    'C00-D48': string;
+    'D50-D89': string;
+    'E00-E90': string;
+    'F00-F99': string;
+    'G00-G99': string;
+    'H00-H59': string;
+    'H60-H95': string;
+    'I00-I99': string;
+    'J00-J99': string;
+    'K00-K93': string;
+    'L00-L99': string;
+    'M00-M99': string;
+    'N00-N99': string;
+    'O00-O99': string;
+    'P00-P96': string;
+    'Q00-Q99': string;
+    'R00-R99': string;
+    'S00-T98': string;
+    'V01-Y98': string;
+    'Z00-Z99': string;
+    'U00-U99': string;
+};
+declare const CID_REGEX: {
+    'A00-B99': RegExp;
+    'C00-D48': RegExp;
+    'D50-D89': RegExp;
+    'E00-E90': RegExp;
+    'F00-F99': RegExp;
+    'G00-G99': RegExp;
+    'H00-H59': RegExp;
+    'H60-H95': RegExp;
+    'I00-I99': RegExp;
+    'J00-J99': RegExp;
+    'K00-K93': RegExp;
+    'L00-L99': RegExp;
+    'M00-M99': RegExp;
+    'N00-N99': RegExp;
+    'O00-O99': RegExp;
+    'P00-P96': RegExp;
+    'Q00-Q99': RegExp;
+    'R00-R99': RegExp;
+    'S00-T98': RegExp;
+    'V01-Y98': RegExp;
+    'Z00-Z99': RegExp;
+    'U00-U99': RegExp;
+};
+
+type BenchmarkingChart = {
+    name: string;
+    interval: number;
+    direction: 'Positiva' | 'Negativa' | string;
+    classificationColor: string;
+    classificationId: number;
+    marks?: {
+        name: string;
+        value: number;
+        color: string;
+    }[];
+};
+interface BenchmarkMark {
+    name: string;
+    percentage: number;
+    color: string;
+}
+interface Benchmark {
+    id: number;
+    name: string;
+    marks: BenchmarkMark[];
+}
+interface Classification {
+    classificationId: number;
+    classificationName: string;
+    classificationColor: string;
+}
+interface EvaluationBenchmarkResult {
+    id: number;
+    name: string;
+    interval: number;
+    average: number;
+    percentage: number;
+    direction: 'Positiva' | 'Negativa' | string;
+    benchmarks: Benchmark[];
+    classification: Classification;
+}
+
+declare class MapaBenchmarkChartComponent {
+    data: BenchmarkingChart[];
+    scaleLabels: number[];
+    constructor();
+    setUnlabeledItem(item: BenchmarkingChart): BenchmarkingChart;
+    getWidth(item: BenchmarkingChart): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaBenchmarkChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaBenchmarkChartComponent, "mapa-benchmark-chart", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaBenchmarkIndicatorComponent {
+    item: BenchmarkingChart;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaBenchmarkIndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaBenchmarkIndicatorComponent, "mapa-benchmark-indicator", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaBreadcrumbComponent {
+    items: Breadpiece[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaBreadcrumbComponent, "mapa-breadcrumb", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+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>;
+}
+
+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>;
+}
+
+interface CapabilityClassification {
+    id: number;
+    name: string;
+    color: string;
+    positive: boolean;
+}
+
+interface CapabilityItem {
+    competenceId?: number;
+    indicatorId?: number;
+    name?: string;
+    indicatorName?: string;
+    indicatorConcept?: string;
+    dimensionName?: string;
+    interval?: number;
+    escoreT?: number;
+    classification?: Classification$1;
+    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(): mapa_library_ui.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(): mapa_library_ui.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(): mapa_library_ui.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>;
+}
+
+declare class MapaChartComponent implements OnInit, OnChanges {
+    options: Partial<ChartOptions>;
+    private colors;
+    chartOptions: Partial<ChartOptions>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private generateChart;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaChartComponent, "mapa-chart", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CheckboxComponent {
+    color: 'primary' | 'basic' | null | undefined;
+    formControl: FormControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "mapa-checkbox", never, { "color": { "alias": "color"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface MapaDatepickerValue {
+    startDate: string | null;
+    endDate: string | null;
+}
+type MapaDatepickerFormGroup = FormGroup<{
+    startDate: FormControl<MapaDatepickerValue["startDate"]>;
+    endDate: FormControl<MapaDatepickerValue["endDate"]>;
+}>;
+type MapaDatepickerRangeValue = {
+    startDate: Date | null;
+    endDate: Date | null;
+};
+type MapaDatepickerRangeFormGroup = FormGroup<{
+    startDate: FormControl<MapaDatepickerRangeValue["startDate"]>;
+    endDate: FormControl<MapaDatepickerRangeValue["endDate"]>;
+}>;
+declare const MY_DATE_FORMATS: {
+    parse: {
+        dateInput: string;
+    };
+    display: {
+        dateInput: string;
+        monthYearLabel: string;
+        dateA11yLabel: string;
+        monthYearA11yLabel: string;
+    };
+};
+declare class DatepickerComponent implements OnInit {
+    private readonly i18n;
+    private readonly cdr;
+    formGroup: MapaDatepickerFormGroup;
+    private readonly destroyRef;
+    private readonly defaultDaysBack;
+    readonly formDatepicker: MapaDatepickerRangeFormGroup;
+    constructor(i18n: MapaI18nService, cdr: ChangeDetectorRef);
+    get texts(): mapa_library_ui.MapaUiTexts;
+    ngOnInit(): void;
+    get startDatePlaceholder(): string;
+    get endDatePlaceholder(): string;
+    private syncRangeForm;
+    private updateExternalForm;
+    private areDatesEqual;
+    cleanDatepicker(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerComponent, "mapa-datepicker", never, { "formGroup": { "alias": "formGroup"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaDialogComponent {
+    data: any;
+    private dialogRef;
+    private sanitizer;
+    isReportRegistration: boolean;
+    dataEmitter: EventEmitter<DialogData>;
+    imgBase64: SafeResourceUrl;
+    isSave: boolean;
+    dialogData: DialogData;
+    htmlDescription: string;
+    constructor(data: any, dialogRef: MatDialogRef<MapaDialogComponent>, sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    close(): void;
+    save(): void;
+    emitData(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaDialogComponent, "mapa-dialog", never, { "isReportRegistration": { "alias": "isReportRegistration"; "required": false; }; }, { "dataEmitter": "dataEmitter"; }, never, never, true, never>;
+}
+declare function openDialog(dialog: MatDialog, dialogData: DialogData, config?: MatDialogConfig): rxjs.Observable<any>;
+
+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(): mapa_library_ui.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>;
+}
+
+interface DataNode extends ElementTreeNode {
+}
+declare class MapaDropdownTreeComponent implements OnInit, OnChanges, AfterViewInit {
+    private readonly cdr;
+    formGroup: FormGroup;
+    element: DropdownTree;
+    elementOption: Dropdown;
+    formControl: FormControl<unknown>;
+    openedChange: EventEmitter<boolean>;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getFormControl(element: Dropdown): FormControl<unknown>;
+    private syncElementOption;
+    formatTree(tree: ElementTreeNode[], childrenLevel?: number): ElementOption[];
+    formatTreeChildren(children: ElementTreeNode[], childrenLevel: number): ElementOption[];
+    triggerOpenedChange(event: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaDropdownTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaDropdownTreeComponent, "mapa-dropdown-tree", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "element": { "alias": "element"; "required": false; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+declare class MapaEmptyStateComponent {
+    title: string;
+    subtitle: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaEmptyStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaEmptyStateComponent, "mapa-empty", never, { "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FiltersComponent {
+    private readonly i18n;
+    form: FormGroup;
+    elements: ElementBase[];
+    selectedValues: EventEmitter<Record<string, unknown>>;
+    constructor(i18n: MapaI18nService);
+    get texts(): mapa_library_ui.MapaUiTexts;
+    get clearFiltersLabel(): string;
+    get submitFiltersLabel(): string;
+    getFormControl(filterKey: string): FormControl<unknown>;
+    clearFilters(): void;
+    emitSelectedValues(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FiltersComponent, "mapa-filters", never, { "form": { "alias": "form"; "required": false; }; "elements": { "alias": "elements"; "required": false; }; }, { "selectedValues": "selectedValues"; }, never, never, true, never>;
+}
+
+declare class MapaFormComponent {
+    formGroup: FormGroup;
+    elements: ElementBase[];
+    emitter: EventEmitter<ElementBase>;
+    getFormControl(element: ElementBase): FormControl<unknown>;
+    onOptionSelected(optionValue: ElementOption): void;
+    emitSuffix(element: ElementBase): void;
+    triggerOpenedChange(element: ElementBase, event: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaFormComponent, "mapa-form", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "elements": { "alias": "elements"; "required": false; }; }, { "emitter": "emitter"; }, never, never, true, never>;
+}
+
+interface Candidate {
+    name: string;
+    cpf?: string;
+    general?: number;
+}
+interface Dimension$2 {
+    dimensionName: string;
+    direction: string;
+    escoreT?: number;
+    average?: number;
+    percentage?: number;
+    percentil?: number;
+    sort?: boolean;
+    classificationId?: number;
+    classificationColor?: string;
+    classificationName?: string;
+    classification?: Classification$1;
+    count?: number;
+    dimensionClassificationMessage?: string;
+}
+interface GroupReportItem {
+    candidate: Candidate;
+    dimensions?: Dimension$2[];
+}
+interface GroupReportDimensionValue {
+    label?: number | string;
+    classification?: Classification$1;
+}
+interface GroupReportDimensionCell {
+    direction: string;
+    value?: GroupReportDimensionValue;
+}
+type GroupReportRowValue = GroupReportDimensionCell | number | string | undefined;
+interface GroupReportRow extends Record<string, GroupReportRowValue> {
+    name: string;
+    cpf?: string;
+    general?: number;
+}
+
+declare class MapaGroupReportComponent implements OnChanges, AfterViewInit {
+    groupReport: GroupReportItem[];
+    showGroupReportGeneral: boolean;
+    onSortChange: EventEmitter<Sort>;
+    sort: MatSort;
+    dataSource: MatTableDataSource<GroupReportRow>;
+    displayedColumns: string[];
+    columns: TableColumn[];
+    data: GroupReportRow[];
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    trackColumn(index: number, column: TableColumn): string;
+    handleSortChange(sort: Sort): void;
+    getDimensionCell(row: GroupReportRow, key: string): GroupReportDimensionCell | undefined;
+    getDimensionClassification(row: GroupReportRow, key: string): Classification$1 | undefined;
+    getDimensionLabel(row: GroupReportRow, key: string): number | string;
+    getGeneralValue(row: GroupReportRow): number | null;
+    private refreshTableState;
+    private getSortValue;
+    private isGroupReportDimensionCell;
+    private generateColumns;
+    private generateGroupData;
+    private getColumnKey;
+    private getDimensionDisplayValue;
+    private getDimensionClassificationFromDimension;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaGroupReportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaGroupReportComponent, "mapa-group-report", never, { "groupReport": { "alias": "groupReport"; "required": false; }; "showGroupReportGeneral": { "alias": "showGroupReportGeneral"; "required": false; }; }, { "onSortChange": "onSortChange"; }, 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 class MapaInputComponent {
+    formControl: FormControl<unknown>;
+    element: InputText;
+    type: string;
+    suffix: EventEmitter<void>;
+    hasValue(): boolean;
+    clearValue(): void;
+    suffixEmit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaInputComponent, "mapa-input", never, { "formControl": { "alias": "formControl"; "required": false; }; "element": { "alias": "element"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "suffix": "suffix"; }, never, never, true, never>;
+}
+
+interface MenuItem extends MenuActionItem {
+}
+declare class MapaMenuComponent {
+    items: MenuItem[];
+    data?: unknown;
+    emitMenu: EventEmitter<MenuActionEvent<unknown>>;
+    trigger: MatMenuTrigger;
+    toggleMenu(): void;
+    clickMenu(item: MenuItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaMenuComponent, "mapa-menu", never, { "items": { "alias": "items"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "emitMenu": "emitMenu"; }, never, never, true, never>;
+}
+
+declare class MapaNavListComponent {
+    options: ElementOption[];
+    label: string;
+    clicked: EventEmitter<ElementOption>;
+    selected: ElementOption;
+    emit(option: ElementOption): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaNavListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaNavListComponent, "mapa-nav-list", never, { "options": { "alias": "options"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+}
+
+declare class RadioButtonComponent implements OnInit, OnChanges {
+    formControl: FormControl;
+    element: ElementBase;
+    optionSelected: EventEmitter<ElementOption>;
+    selectedOption: ElementOption;
+    options: ElementOption[];
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onChange(optionValue: ElementOption): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "mapa-radio-button", never, { "formControl": { "alias": "formControl"; "required": false; }; "element": { "alias": "element"; "required": false; }; }, { "optionSelected": "optionSelected"; }, never, never, true, never>;
+}
+
+interface ReportItemMenuItem extends MenuActionItem {
+}
+interface ReportItem {
+    id: string;
+    icon: string;
+    description: string;
+    menu?: ReportItemMenuItem[];
+}
+declare class ReportItemComponent implements OnChanges {
+    itemData?: ReportItem | ReportItem[];
+    menuItems: ReportItemMenuItem[];
+    clicked: EventEmitter<string>;
+    emitMenu: EventEmitter<MenuActionEvent<ReportItem>>;
+    id: string;
+    description: string;
+    icon: string;
+    get item(): ReportItem | undefined;
+    get resolvedMenuItems(): ReportItemMenuItem[];
+    ngOnChanges(changes: SimpleChanges): void;
+    private syncItemData;
+    onClick(action: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReportItemComponent, "mapa-report-item", never, { "itemData": { "alias": "itemData"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; }, { "clicked": "clicked"; "emitMenu": "emitMenu"; }, never, never, true, never>;
+}
+
+interface Dimension$1 {
+    dimensionName: string;
+    direction: string;
+    escoreT?: number;
+    average?: number;
+    percentage?: number;
+    percentil?: number;
+    dimensionClassificationMessage?: string;
+    dimensionConcept?: string;
+    classification?: Classification$1;
+}
+interface ProgressBar$1 {
+    interval?: number;
+    classification?: Classification$1;
+}
+interface Scale$1 {
+    scaleName: string;
+    interval?: number;
+    classification?: Classification$1;
+    scaleConcept?: string;
+    scaleDirection?: string;
+    average?: number;
+    percentage?: number;
+    dimensions: Dimension$1[];
+}
+interface Competence$1 {
+    competenceName: string;
+    scales: Scale$1[];
+    percentage?: number;
+}
+
+declare class MapaScaleComponent {
+    private readonly i18n;
+    data: Competence$1[];
+    showProgressbar: boolean;
+    constructor(i18n: MapaI18nService);
+    get texts(): mapa_library_ui.MapaUiTexts;
+    get conceptTitle(): string;
+    getProgressbarData(scale: Scale$1): ProgressBar$1;
+    getIntervalbarData(scale: Scale$1): Capability;
+    isPositive(dimension: Dimension$2): boolean;
+    showSummarized(scale: Scale$1 | undefined): boolean;
+    getCompetenceImg(competence: Competence$1): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaScaleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaScaleComponent, "mapa-scale", never, { "data": { "alias": "data"; "required": false; }; "showProgressbar": { "alias": "showProgressbar"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaProgressbarComponent {
+    data: ProgressBar$1;
+    showInterval: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaProgressbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaProgressbarComponent, "mapa-progressbar", never, { "data": { "alias": "data"; "required": false; }; "showInterval": { "alias": "showInterval"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MapaDetailsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaDetailsComponent, "mapa-details", never, {}, {}, never, never, true, never>;
+}
+
+declare class SlideToggleComponent implements OnInit, OnChanges {
+    formControl: FormControl;
+    element: ElementBase;
+    optionSelected: EventEmitter<ElementOption>;
+    selectedOption: ElementOption;
+    options: ElementOption[];
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onChange(optionValue: ElementOption): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlideToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlideToggleComponent, "mapa-slide-toggle", never, { "formControl": { "alias": "formControl"; "required": false; }; "element": { "alias": "element"; "required": false; }; }, { "optionSelected": "optionSelected"; }, never, never, true, never>;
+}
+
+declare class MapaSvgIconComponent implements OnChanges {
+    private httpClient;
+    private cdr;
+    name?: string;
+    color?: string;
+    svgIcon: string;
+    private readonly destroyRef;
+    constructor(httpClient: HttpClient, cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    private applyColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaSvgIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaSvgIconComponent, "mapa-svg-icon", never, { "name": { "alias": "name"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function customPaginatorFactory(i18n: MapaI18nService, injector: Injector): MatPaginatorIntl;
+
+declare class MapaTableComponent implements AfterViewInit, OnChanges {
+    private cdr;
+    private readonly i18n;
+    columns: TableColumn[];
+    data: TableRowData[];
+    pageIndex: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+    checkbox: boolean | undefined;
+    selection: SelectionModel<TableRowData> | undefined;
+    actions?: MenuItem[] | undefined;
+    filterControl: FormControl<string | null> | undefined;
+    menuItems: MenuItem[];
+    menu: boolean | undefined;
+    showPaginator: boolean;
+    paginatorShowFirstButton: boolean;
+    paginatorShowLastButton: boolean;
+    paginatorRenderButtonsNumber: number;
+    paginatorHideDefaultArrows: boolean;
+    trigger: MatMenuTrigger;
+    table?: MatTable<TableRowData>;
+    rowClick: EventEmitter<RowClickEvent>;
+    selectedRows: EventEmitter<SelectedTableRow[]>;
+    onChangePage: EventEmitter<PageEvent>;
+    onSortChange: EventEmitter<Sort>;
+    paginator: MatPaginator;
+    sort: MatSort;
+    dataSource: MatTableDataSource<TableRowData>;
+    displayedColumns: string[];
+    currentSort: Sort | undefined;
+    desktopTableVisible: boolean;
+    private readonly destroyRef;
+    private filterControlSubscription?;
+    constructor(cdr: ChangeDetectorRef, i18n: MapaI18nService);
+    get texts(): mapa_library_ui.MapaUiTexts;
+    get selectAllLabel(): string;
+    get paginatorPageIndex(): number;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private refreshTableState;
+    private rebuildDesktopTable;
+    trackColumn(index: number, column: TableColumn): string;
+    setupFilter(): void;
+    isAllSelected(): boolean;
+    toggleAllRows(): void;
+    checkboxLabel(row?: TableRowData): string;
+    sortData(column: TableColumn): void;
+    sortDataFunction(sort: Sort): void;
+    emitRowClick(row: TableRowData, action: string): void;
+    toggleSelection(row: TableRowData): void;
+    getSelectedValues(): void;
+    generateColumns(): void;
+    columnExists(columns: TableColumn[], key: string): boolean;
+    generateGroupData(): void;
+    isBoolean(column: TableColumn, row: TableRowData): boolean;
+    isMaskedData(column: TableColumn, row: TableRowData): boolean;
+    getValueAsDate(column: TableColumn, row: TableRowData): Date;
+    getCellClass(column: TableColumn, row: TableRowData): string;
+    getCellBg(column: TableColumn, row: TableRowData): string;
+    getCellTextColor(column: TableColumn, row: TableRowData): string;
+    getValue(row: {
+        value?: string | number | null;
+    }): string;
+    changePage(event: PageEvent): void;
+    toggleMenu(): void;
+    getBackgroundColor(column: TableColumn, row: TableRowData): string;
+    getTextColor(column: TableColumn, row: TableRowData): string;
+    hasCustomClass(column: TableColumn, row: TableRowData, key: string): boolean;
+    getCustomClass(column: TableColumn, row: TableRowData, key: string): string;
+    hasCellStyleClass(row: TableRowData, key: string): boolean;
+    getCellStyleClass(row: TableRowData, key: string): string;
+    handleMenu(selected: MenuActionEvent<unknown>): void;
+    hasIndividualMenu(row: TableRowData | undefined): boolean;
+    getMenuItems(row: TableRowData | undefined): MenuItem[];
+    getActionItems(row: TableRowData | undefined): MenuItem[];
+    getStatusLabel(column: TableColumn, row: TableRowData): string;
+    getCellContent(row: TableRowData, key: string): string;
+    hasActionsColumn(): boolean;
+    hasMenuColumn(): boolean;
+    setSvgName(image: string): string;
+    private getColumnValue;
+    private getColumnRecord;
+    private getRecordStringValue;
+    private getStatusIndex;
+    private getFilterValue;
+    private getMenuActionItems;
+    private isMenuItem;
+    private isTableRowData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaTableComponent, "mapa-table", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "pageIndex": { "alias": "pageIndex"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "totalCount": { "alias": "totalCount"; "required": false; }; "totalPages": { "alias": "totalPages"; "required": false; }; "checkbox": { "alias": "checkbox"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "filterControl": { "alias": "filterControl"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "showPaginator": { "alias": "showPaginator"; "required": false; }; "paginatorShowFirstButton": { "alias": "paginatorShowFirstButton"; "required": false; }; "paginatorShowLastButton": { "alias": "paginatorShowLastButton"; "required": false; }; "paginatorRenderButtonsNumber": { "alias": "paginatorRenderButtonsNumber"; "required": false; }; "paginatorHideDefaultArrows": { "alias": "paginatorHideDefaultArrows"; "required": false; }; }, { "rowClick": "rowClick"; "selectedRows": "selectedRows"; "onChangePage": "onChangePage"; "onSortChange": "onSortChange"; }, never, never, true, never>;
+}
+
+interface Tag {
+    bgColor?: string | null | undefined;
+    color?: "highlight" | "selected" | string | null | undefined;
+    size?: "small" | string | null | undefined;
+    fontSize?: string | null | undefined;
+}
+declare class TagComponent {
+    tag: Tag | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagComponent, "mapa-tag", never, { "tag": { "alias": "tag"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MapaTextareaComponent {
+    formControl: FormControl;
+    element: Textarea;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaTextareaComponent, "mapa-textarea", never, { "formControl": { "alias": "formControl"; "required": false; }; "element": { "alias": "element"; "required": false; }; }, {}, never, 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 LowReliabilityReport {
+    instrument?: string;
+    date?: string;
+    isExpirationDate?: boolean;
+}
+declare class MapaWarningComponent implements OnInit, OnChanges {
+    lowReliabilityReports: LowReliabilityReport[];
+    showFirstLine: boolean;
+    showSecondLine: boolean;
+    expirationDateReports: string[];
+    nonExpirationDateReports: string[];
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    updateVisibilityFlags(): void;
+    generateReportArrays(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaWarningComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaWarningComponent, "mapa-warning", never, { "lowReliabilityReports": { "alias": "lowReliabilityReports"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface Dimension {
+    dimensionName: string;
+    direction: string;
+    escoreT?: number;
+    average?: number;
+    percentage?: number;
+    percentil?: number;
+    dimensionClassificationMessage?: string;
+    dimensionConcept?: string;
+    classification?: Classification$1;
+}
+interface ProgressBar {
+    interval?: number;
+    classification?: Classification$1;
+}
+interface Scale {
+    scaleName: string;
+    interval?: number;
+    classification?: Classification$1;
+    scaleConcept?: string;
+    scaleDirection?: string;
+    average?: number;
+    percentage?: number;
+    dimensions: Dimension[];
+}
+interface Competence {
+    competenceName: string;
+    scales: Scale[];
+    percentage?: number;
+}
+
+declare class MapaScaleParameterizationComponent {
+    private readonly i18n;
+    data: Competence[];
+    showProgressbar: boolean;
+    showInterval: boolean;
+    showDots: boolean;
+    accordion: MatAccordion;
+    expanded: Set<number>;
+    constructor(i18n: MapaI18nService);
+    get texts(): mapa_library_ui.MapaUiTexts;
+    get conceptTitle(): string;
+    toggleAll(): void;
+    getProgressbarData(scale: Scale): ProgressBar;
+    getIntervalbarData(scale: Scale): Capability;
+    isPositive(dimension: Dimension$2): boolean;
+    showSummarized(scale: Scale | undefined): boolean;
+    showMore(index: number): void;
+    getCompetenceImg(competence: Competence): string;
+    getDimensionsAsCapability(scale: Scale): Capability;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapaScaleParameterizationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapaScaleParameterizationComponent, "mapa-scale-parameterization", never, { "data": { "alias": "data"; "required": false; }; "showProgressbar": { "alias": "showProgressbar"; "required": false; }; "showInterval": { "alias": "showInterval"; "required": false; }; "showDots": { "alias": "showDots"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { AIH_ESTADOS, AIH_TIPOS, BubblePaginationDirective, ButtonComponent, ButtonIconComponent, CEPRange, CID_NAME, CID_REGEX, CORES, CPFPipe, CapabilityClassificationService, CheckboxComponent, DatepickerComponent, Dropdown, DropdownTree, ESTADOS, ESTADOS_SIGLA, ElementBase, FiltersComponent, HtmlSanitizerService, IPTUCREATE, IPTUMASKS, IPTUVALIDATE, IconComponent, InputText, LOCALIZACAO_BAIRROS, LOCALIZACAO_CIDADES, LOCALIZACAO_COMPLEMENTOS, LOCALIZACAO_ESTADOS, LOCALIZACAO_LOGRADOUROS, LOCALIZACAO_RUAS, MAPA_UI_DEFAULT_TEXTS, MAPA_UI_TEXTS, MASKSIE, MY_DATE_FORMATS, MapaBenchmarkChartComponent, MapaBenchmarkIndicatorComponent, MapaBreadcrumbComponent, MapaCapabilityComparativeChartComponent, MapaCapabilityComparativeComponent, MapaCapabilityComparativeHeaderComponent, MapaCapabilityDetailComponent, MapaCapabilityDotComponent, MapaCapabilityExpandComponent, MapaCapabilityIndicatorChartComponent, MapaCapabilityIndicatorComponent, MapaCapabilityIndicatorListComponent, MapaCapabilityIntervalBarComponent, MapaCapabilityIntervalComponent, MapaChartComponent, MapaDetailsComponent, MapaDialogComponent, MapaDropdownComponent, MapaDropdownTreeComponent, MapaEmptyStateComponent, MapaFormComponent, MapaFormErrorsComponent, MapaGroupReportComponent, MapaI18nService, MapaInputComponent, MapaMenuComponent, MapaNavListComponent, MapaProgressbarComponent, MapaScaleComponent, MapaScaleParameterizationComponent, MapaSvgIconComponent, MapaTableComponent, MapaTextareaComponent, MapaTooltipComponent, MapaTooltipDirective, MapaWarningComponent, MatInputAutosizeDirective, PLACAS_INVALID, PLACAS_RANGE, RadioButton, RadioButtonComponent, ReportItemComponent, SafeHtmlPipe, SlideToggle, SlideToggleComponent, TagComponent, Textarea, ValidationMessageResolverService, allNumbersAreSame, buildDetailedIndicatorSections, buildIndicatorCollections, cep_ranges, create_aih, create_cartaocredito, create_certidao, create_cnh, create_cnhespelho, create_cnpj, create_cns, create_cpf, create_ect, create_iptu, create_iptu_ctba, create_iptu_sp, create_pispasep, create_processo, create_renachestadual, create_renachseguranca, create_renavam, create_titulo, create_titulo_atual, creditCardValidator, currencyToNumber, customPaginatorFactory, faker_iptu, fillString, generateInscricaoEstadual, getAllDigits, getAllWords, getSpecialProperty, isArray, isNil, isNumber, isPresent, isString, makeGenericFaker, maskBr, mask_iptu, mergeMapaUiTexts, modulo11, modulo11Custom, modulo11a, normalizeLookup, normalizeText, numberToCurrency, openDialog, processCaretTraps, provideMapaUiTexts, rand, randArray, randomEstadoSigla, randomLetter, randomLetterOrNumber, randomNumber, rg_rj, rg_sp, sanitizeHtmlContent, slugify, utilsBr, validateBr, validate_aih, validate_cartaocredito, validate_celular, validate_cep, validate_certidao, validate_chassi, validate_cnh, validate_cnhespelho, validate_cnpj, validate_cns, validate_cpf, validate_currency, validate_datahora, validate_datetime, validate_ect, validate_inscricaoestadual, validate_iptu, validate_iptu_contagem, validate_iptu_ctba, validate_iptu_sp, validate_number, validate_pispasep, validate_placa, validate_porcentagem, validate_processo, validate_renachestadual, validate_renachseguranca, validate_renavam, validate_rg, validate_sped, validate_telefone, validate_time, validate_titulo };
+export type { ActionButton, Benchmark, BenchmarkMark, BenchmarkingChart, Classification as BenchmarkingClassification, BigObject, Breadpiece, ButtonIcon, Candidate, Capability, CapabilityClassification, CapabilityComparative, CapabilityItem, ChartOptions, Classification$1 as Classification, Competence$1 as Competence, DataNode, DetailedIndicatorItem, DetailedIndicatorSection, DialogData, Dimension$1 as Dimension, ElementOption, ElementSearch, ElementTreeNode, Errors, EstadosType, EvaluationBenchmarkResult, Dimension$2 as GroupReportDimension, GroupReportItem, IndicatorCollectionOptions, IndicatorCollections, Indicators, LowReliabilityReport, MapaDatepickerFormGroup, MapaDatepickerValue, MapaUiTexts, MaskType, Masks, MasksIE, MenuActionEvent, MenuActionItem, MenuItem, PartialMapaUiTexts, ProgressBar$1 as ProgressBar, ReportItem, ReportItemMenuItem, RowClickEvent, Scale$1 as Scale, Competence as ScaleParameterizationCompetence, Dimension as ScaleParameterizationDimension, ProgressBar as ScaleParameterizationProgressBar, Scale as ScaleParameterizationScale, SelectedTableRow, Status, TableCellStyleClass, TableColumn, TableColumnStatus, TableRowData, Tag, ValidationMessageContext, ValidationTextResolver };