@seniorsistemas/platform-components 5.3.2 → 5.3.3-develop-73308358

package/fesm2022/seniorsistemas-platform-components.mjs

@@ -0,0 +1,2432 @@
+import * as i0 from '@angular/core';
+import { Pipe, inject, InjectionToken, APP_INITIALIZER, Injector, NgModule, Injectable, ChangeDetectorRef, EventEmitter, Component, Input, Output, HostListener, ViewEncapsulation, ViewChild } from '@angular/core';
+import * as i2 from '@angular/common';
+import { LOCATION_INITIALIZED, CommonModule, DatePipe } from '@angular/common';
+import { FormGroup, FormControl, Validators, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import * as i1$3 from 'primeng/button';
+import { ButtonModule as ButtonModule$1 } from 'primeng/button';
+import * as i1$2 from 'primeng/dialog';
+import { DialogModule } from 'primeng/dialog';
+import * as i1$1 from 'primeng/tabview';
+import { TabViewModule } from 'primeng/tabview';
+import * as i5 from 'primeng/toast';
+import { ToastModule } from 'primeng/toast';
+import * as i2$2 from 'primeng/tooltip';
+import { TooltipModule } from 'primeng/tooltip';
+import * as i2$1 from 'primeng/api';
+import { MessageService } from 'primeng/api';
+import { LocaleService } from '@seniorsistemas/angular-components/locale';
+import * as i4 from '@seniorsistemas/angular-components/empty-state';
+import { EmptyStateModule } from '@seniorsistemas/angular-components/empty-state';
+import * as i3$1 from '@seniorsistemas/angular-components/button';
+import { ButtonModule } from '@seniorsistemas/angular-components/button';
+import * as i3 from '@seniorsistemas/angular-components/dynamic-form';
+import { TextField, FieldType, CurrencyField, SelectField, NumberField, RadioButtonField, CalendarField, AutocompleteField, DynamicFormModule } from '@seniorsistemas/angular-components/dynamic-form';
+import * as i1 from '@ngx-translate/core';
+import { TranslateService, TranslateModule } from '@ngx-translate/core';
+import { HttpClient, provideHttpClient, withInterceptorsFromDi, HttpParams, HttpHeaders, HttpResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { user, service } from '@seniorsistemas/senior-platform-data';
+import { CookieService } from 'ngx-cookie-service';
+import { Subject, BehaviorSubject, Observable, from, defer, forkJoin, throwError, of } from 'rxjs';
+import { map, takeUntil, filter, tap, mergeMap, catchError, shareReplay } from 'rxjs/operators';
+import { Router, NavigationEnd } from '@angular/router';
+import { ToastService } from '@seniorsistemas/angular-components/toast';
+import * as momentNs from 'moment';
+import { contains, equals, clone } from 'ramda';
+import * as jc from 'json-cycle';
+
+class MapValuesPipe {
+    transform(map, args = null) {
+        return Array.from(map.values());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MapValuesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: MapValuesPipe, name: "mapValues", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MapValuesPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'mapValues', pure: false }]
+        }] });
+
+let TranslatePipe$1 = class TranslatePipe {
+    translationService = inject(TranslateService);
+    transform(value, args) {
+        return this.translationService.instant(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, name: "translate", pure: false });
+};
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe$1, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'translate',
+                    pure: false,
+                }]
+        }] });
+
+const TranslationsConfig = new InjectionToken('translationConfig');
+const USER_INFO = 'com.senior.token';
+const LENGTH_DEFAULT = 2;
+class TranslationsModule {
+    static forRoot(translationsConfigs) {
+        return {
+            ngModule: TranslationsModule,
+            providers: [
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: factory,
+                    deps: [TranslateService, Injector, HttpClient, CookieService],
+                    multi: true
+                },
+                {
+                    provide: TranslationsConfig,
+                    useValue: translationsConfigs,
+                    multi: true
+                }
+            ]
+        };
+    }
+    static forChild(translationsConfigs) {
+        return {
+            ngModule: TranslationsModule,
+            providers: [
+                {
+                    provide: TranslationsConfig,
+                    useValue: translationsConfigs,
+                    multi: true
+                }
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: TranslationsModule, imports: [i1.TranslateModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationsModule, providers: [CookieService, provideHttpClient(withInterceptorsFromDi())], imports: [TranslateModule.forChild()] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationsModule, decorators: [{
+            type: NgModule,
+            args: [{ imports: [TranslateModule.forChild()], providers: [CookieService, provideHttpClient(withInterceptorsFromDi())] }]
+        }] });
+function resolveImmediately(resolve) {
+    resolve();
+}
+function resolveAfterTranslate(translate, locale, resolve) {
+    translate.use(locale).toPromise().then(() => resolve());
+}
+function factory(translate, injector, http, cookieService) {
+    async function performInit() {
+        let locale = 'pt-BR';
+        try {
+            const configs = getFlatArray(injector.get(TranslationsConfig, Promise.resolve(null)));
+            try {
+                let userData = JSON.parse(cookieService.get(USER_INFO));
+                if (userDataIsNull(userData)) {
+                    userData = await user.getUserData();
+                }
+                locale = getLocale(userData);
+            }
+            catch (ex) {
+                console.warn('Unable to obtain user locale');
+            }
+            const fallback = configs.reduce((result, cfg) => ({ ...result, ...cfg.fallback }), {});
+            const defaultsLanguages = configs.reduce((result, cfg) => ({ ...result, ...cfg.defaultsLanguages }), {});
+            translate.setTranslation(locale, fallback);
+            translate.setDefaultLang(locale);
+            let configTranslate = {};
+            if (defaultsLanguages) {
+                configTranslate = getConfigTranslate(defaultsLanguages, locale);
+            }
+            const translationsPromises = configs.map((config) => getTranslationsRequest(config, locale));
+            await Promise.all(translationsPromises).then((results) => {
+                const usedFallback = translate?.overriden;
+                results.forEach((file, index) => {
+                    setTranslations(file['content'], usedFallback, locale, index, configTranslate.fallbackByLocale);
+                });
+                return translate.use(locale).toPromise();
+            });
+            return { success: true, locale };
+        }
+        catch (_err) {
+            return { success: false, locale };
+        }
+    }
+    return () => new Promise((resolve) => {
+        const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve(null));
+        locationInitialized
+            .then(() => performInit())
+            .then(({ success, locale }) => {
+            if (success) {
+                resolveImmediately(resolve);
+            }
+            else {
+                resolveAfterTranslate(translate, locale, resolve);
+            }
+        });
+    });
+    function setTranslations(content, usedFallback, locale, index, fallbackByLocale) {
+        if (usedFallback) {
+            content && translate.setTranslation(locale, content, true);
+            translate.setTranslation(locale, fallbackByLocale, true);
+        }
+        else {
+            if (index === 0) {
+                translate.setTranslation(locale, fallbackByLocale, true);
+            }
+            content && translate.setTranslation(locale, content, true);
+        }
+    }
+    function getTranslationsRequest({ domain, service }, language) {
+        return new Promise(async (resolve) => {
+            try {
+                if (!domain && !service) {
+                    throw new Error(`domain and service not found`);
+                }
+                const params = new HttpParams().set('domainName', domain).set('serviceName', service).set('format', 'FLAT_JSON');
+                const headers = new HttpHeaders().set('Authorization', await user.getAuthHeader());
+                const url = 'platform/translation_hub/queries/getTranslationBundle';
+                const bundleFiles = await http
+                    .get(url, { headers, params })
+                    .toPromise()
+                    .then((res) => res.bundleFiles);
+                let languageBundle = language && bundleFiles.find((bundle) => bundle.language === language);
+                let overriden = false;
+                if (!languageBundle) {
+                    languageBundle = bundleFiles.find((bundle) => bundle.language === 'pt-BR');
+                    overriden = true;
+                }
+                if (!languageBundle) {
+                    return resolve({});
+                }
+                await http
+                    .get(languageBundle.url)
+                    .toPromise()
+                    .then((result) => {
+                    const translations = {
+                        overriden: overriden,
+                        content: result
+                    };
+                    resolve(translations);
+                });
+            }
+            catch (err) {
+                console.warn(`Error getting translation bundle for ${domain}/${service}. Using local fallback.`, err);
+                resolve({});
+            }
+        });
+    }
+    function getFlatArray(array) {
+        return array.reduce((result, item) => {
+            if (Array.isArray(item)) {
+                return [...result, ...item];
+            }
+            return [...result, item];
+        }, []);
+    }
+    function userDataIsNull(data) {
+        return !data || Object.keys(data).length === 0;
+    }
+    function getConfigTranslate(defaultsLanguages, locale) {
+        const languages = Object.keys(defaultsLanguages).map((key) => {
+            const language = {};
+            language['locale'] = key.replace('_', '-');
+            language['translation'] = defaultsLanguages[key];
+            return language;
+        }, []);
+        const result = { languages };
+        result['foundLocaleUser'] = languages.find((results) => results.locale === locale);
+        if (!result['foundLocaleUser']) {
+            result['foundLocaleUser'] = languages.find((results) => {
+                return results.locale.length === LENGTH_DEFAULT && results.locale === locale.split('-')[0];
+            });
+        }
+        if (result['foundLocaleUser']) {
+            result['fallbackByLocale'] = result['foundLocaleUser']['translation'];
+        }
+        return result;
+    }
+    function getLocale(userData) {
+        return userData.locale || 'pt-BR';
+    }
+}
+
+const fallback$1 = {
+    'platform.filter_service.cancel': 'Cancelar',
+    'platform.filter_service.try': 'Tentar Novamente',
+    'platform.filter_service.actions': 'Ações',
+    'platform.filter_service.save': 'Salvar',
+    'platform.filter_service.filter': 'Filtrar',
+    'platform.filter_service.error_state': 'O serviço de filtro está indisponível no momento e as informações apresentadas não são as mais recentes. Tente novamente mais tarde.',
+    'platform.filter_service.saved_filters_success': 'Filtros salvos com sucesso! Clique em "Filtrar" para visualizar o resultado.',
+    'platform.filter_service.saved_filters_error': 'Ocorreu um erro ao tentar salvar os filtros. Verifique os valores e tente novamente.',
+    'platform.filter_service.applied_filter_nochange': 'Não houve alterações no filtro.',
+    'platform.filter_service.applied_filter_change': 'Filtros aplicados com sucesso!',
+    'platform.filter_service.invalid_pattern': 'O valor não atende ao padrão especificado.',
+    'platform.filter_service.error_max_value': 'O valor excede o tamanho máximo especificado.',
+    'platform.filter_service.error_min_value': 'O valor é menor que o minímo especificado.',
+    'platform.filter_service.applied_filters_message': '{{totalActiveFilters}} filtros aplicados',
+    'platform.filter_service.applied_filter_message': '{{totalActiveFilters}} filtro aplicado',
+    'platform.filter_service.find_suggestions_error': 'Erro ao encontrar sugestões!',
+    'platform.filter_service.select': 'Selecionar',
+    'platform.filter_service.filters': 'Filtros',
+    'platform.filter_service.date_format': 'dd/mm/yy',
+    'platform.filter_service.hour_format': '24',
+    'platform.filter_service.clear': 'Limpar',
+    'platform.filter_service.today': 'Hoje',
+    'platform.filter_service.name_january': 'Janeiro',
+    'platform.filter_service.name_february': 'Fevereiro',
+    'platform.filter_service.name_march': 'Março',
+    'platform.filter_service.name_april': 'Abril',
+    'platform.filter_service.name_may': 'Maio',
+    'platform.filter_service.name_june': 'Junho',
+    'platform.filter_service.name_july': 'Julho',
+    'platform.filter_service.name_august': 'Agosto',
+    'platform.filter_service.name_september': 'Setembro',
+    'platform.filter_service.name_october': 'Outubro',
+    'platform.filter_service.name_november': 'Novembro',
+    'platform.filter_service.name_december': 'Dezembro',
+    'platform.filter_service.short_january': 'Jan',
+    'platform.filter_service.short_february': 'Fev',
+    'platform.filter_service.short_march': 'Mar',
+    'platform.filter_service.short_april': 'Abr',
+    'platform.filter_service.short_may': 'Mai',
+    'platform.filter_service.short_june': 'Jun',
+    'platform.filter_service.short_july': 'Jul',
+    'platform.filter_service.short_august': 'Ago',
+    'platform.filter_service.short_september': 'Set',
+    'platform.filter_service.short_october': 'Out',
+    'platform.filter_service.short_november': 'Nov',
+    'platform.filter_service.short_december': 'Dez',
+    'platform.filter_service.name_sunday': 'Domingo',
+    'platform.filter_service.name_monday': 'Segunda',
+    'platform.filter_service.name_tuesday': 'Terça',
+    'platform.filter_service.name_wednesday': 'Quarta',
+    'platform.filter_service.name_thursday': 'Quinta',
+    'platform.filter_service.name_friday': 'Sexta',
+    'platform.filter_service.name_saturday': 'Sábado',
+    'platform.filter_service.min_sunday': 'D',
+    'platform.filter_service.min_monday': 'S',
+    'platform.filter_service.min_tuesday': 'T',
+    'platform.filter_service.min_wednesday': 'Q',
+    'platform.filter_service.min_thursday': 'Q',
+    'platform.filter_service.min_friday': 'S',
+    'platform.filter_service.min_saturday': 'S',
+    'platform.filter_service.short_sunday': 'Dom',
+    'platform.filter_service.short_monday': 'Seg',
+    'platform.filter_service.short_tuesday': 'Ter',
+    'platform.filter_service.short_wednesday': 'Qua',
+    'platform.filter_service.short_thursday': 'Qui',
+    'platform.filter_service.short_friday': 'Sex',
+    'platform.filter_service.short_saturday': 'Sab',
+    'platform.filter_service.yes': 'Sim',
+    'platform.filter_service.no': 'Não',
+    'platform.filter_service.search_empty_message': 'Nenhum resultado encontrado'
+};
+
+const URL_PREFIX = 'platform/filter_service';
+const GET_FILTERS_URL = `${URL_PREFIX}/queries/getFilters`;
+const SAVE_FILTERS_URL = `${URL_PREFIX}/actions/saveUserFilters`;
+const SAVE_TICKED_FILTER_URL = `${URL_PREFIX}/actions/setTicketFilters`;
+const GET_FILTERS_BY_TICKET = `${URL_PREFIX}/queries/getFiltersByTicket`;
+
+const searchDisplayName = '$$__displayValue__';
+const searchKeyName = '$$__keyValue__';
+
+class AdvancedFilterService {
+    http = inject(HttpClient);
+    allowedOrigin = window.location.origin;
+    filtersObservable = new Subject();
+    contextsObservable = new BehaviorSubject([]);
+    ticketFilterObservable = new Subject();
+    destroy$ = new Subject();
+    ticketFilter;
+    visible;
+    contextsObserver = this.contextsObservable.asObservable();
+    filtersObserver = this.filtersObservable.asObservable();
+    ticketFilterObserver = this.ticketFilterObservable.asObservable();
+    constructor() {
+        this.contextsObservable.subscribe(contexts => contexts.length && this.getAndApplyFilters(contexts));
+    }
+    saveTickedFilters(filters) {
+        const requestBody = this.ticketFilter ? { filters, ticketFilter: this.ticketFilter } : { filters };
+        this.http
+            .post(SAVE_TICKED_FILTER_URL, requestBody)
+            .pipe(map(response => response.ticket))
+            .subscribe({
+            next: ticketFilter => {
+                this.ticketFilter = ticketFilter;
+                this.ticketFilterObservable.next({ ticketFilter });
+                // NOSONAR
+                window.parent.postMessage({ message: 'advanced-filter:success', payload: ticketFilter }, this.allowedOrigin);
+            },
+            error: err => {
+                this.ticketFilterObservable.next({ error: true, message: err });
+                // NOSONAR
+                window.parent.postMessage({ message: 'advanced-filter:error', payload: err }, this.allowedOrigin);
+            }
+        });
+    }
+    addContexts(...contexts) {
+        const currentContexts = this.contextsObservable.getValue();
+        this.contextsObservable.next([...currentContexts, ...contexts]);
+        return Observable.create(() => () => this.removeContexts(contexts));
+    }
+    removeContexts(contexts) {
+        const allContexts = this.contextsObservable.getValue();
+        const filteredContexts = allContexts.filter(context => contexts.indexOf(context) === -1);
+        this.contextsObservable.next(filteredContexts);
+    }
+    saveFilters(filters) {
+        return this.http.post(SAVE_FILTERS_URL, { filters });
+    }
+    searchFieldSuggestions(url, params, type) {
+        const headers = new HttpHeaders({ 'Content-Type': 'application/json; charset=utf-8' });
+        if (type === 'ENTITY') {
+            return this.http.get(url, { headers });
+        }
+        return this.http.post(url, params, { headers });
+    }
+    tryAgain(serviceContexts) {
+        this.getFilters(serviceContexts);
+    }
+    getAndApplyFilters(serviceContexts) {
+        this.getFilters(serviceContexts, true);
+    }
+    getFilters(serviceContexts, applyFilter) {
+        this.http
+            .post(GET_FILTERS_URL, { serviceContexts })
+            .pipe(map(response => this.mapFilters(response.filters)))
+            .subscribe(filters => this.filtersObservable.next({ filters, applyFilter }), //
+        //
+        err => this.filtersObservable.next({ error: true, message: err }));
+    }
+    mapFilters(filters) {
+        return filters.map(filter => {
+            try {
+                const value = filter.value && JSON.parse(filter.value);
+                if (value && filter.search && filter.search.basicSearch && filter.search.basicSearch.output) {
+                    this.mapValues(value, filter.search.basicSearch.output.keyFields, filter.search.basicSearch.output.displayFields);
+                }
+                else if (value && filter.search && filter.search.entitySearch && filter.search.entitySearch.output) {
+                    this.mapValues(value, filter.search.entitySearch.output.keyFields, filter.search.entitySearch.output.displayFields);
+                }
+                if (value) {
+                    if (this.isMultiple(filter)) {
+                        const valueInText = JSON.stringify(value);
+                        if ((valueInText.startsWith('[{') && valueInText.endsWith('}]')) || valueInText.length <= 4) {
+                            filter.value = valueInText;
+                        }
+                        else {
+                            filter.value = JSON.stringify('');
+                        }
+                    }
+                    else {
+                        filter.value = JSON.stringify(value);
+                    }
+                }
+            }
+            catch (ex) {
+                console.error(`Global: filter ${filter.name} has value error. `, ex);
+                filter.value = JSON.stringify('');
+            }
+            return filter;
+        });
+    }
+    isMultiple(filter) {
+        return (filter.type === 'SEARCH' &&
+            filter.search &&
+            ((filter.search.basicSearch && filter.search.basicSearch.output && filter.search.basicSearch.output.maxSelectedItems > 1) ||
+                (filter.search.entitySearch && filter.search.entitySearch.output && filter.search.entitySearch.output.maxSelectedItems > 1)));
+    }
+    mapValues(value, keyFields, displayFields) {
+        if (Array.isArray(value)) {
+            value.forEach(e => {
+                this.mapValue(e, keyFields, displayFields);
+            });
+        }
+        else {
+            this.mapValue(value, keyFields, displayFields);
+        }
+    }
+    mapValue(value, keyFields, displayFields) {
+        if (!value) {
+            return;
+        }
+        const ids = [];
+        const displays = [];
+        keyFields.filter(e => value[e] !== undefined).forEach(e => ids.push(value[e]));
+        displayFields.filter(e => value[e] !== undefined).forEach(e => displays.push(value[e]));
+        if (ids.length > 0 && displays.length > 0) {
+            value[searchKeyName] = ids.join(', ');
+            value[searchDisplayName] = displays.join(', ');
+        }
+        else {
+            value = [''];
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class Filter {
+    type;
+    required;
+    label;
+    domain;
+    scope;
+    name;
+    contexts;
+    services;
+    value;
+    enumItems;
+    defaultValue;
+    search;
+    tabIndex;
+    minValue;
+    maxValue;
+    dependsOn;
+    mask;
+    regExp;
+    constructor(type, required, label, domain, scope, name, contexts, services, value, enumItems, defaultValue, search, tabIndex, minValue, maxValue, dependsOn, mask, regExp) {
+        this.type = type;
+        this.required = required;
+        this.label = label;
+        this.domain = domain;
+        this.scope = scope;
+        this.name = name;
+        this.contexts = contexts;
+        this.services = services;
+        this.value = value;
+        this.enumItems = enumItems;
+        this.defaultValue = defaultValue;
+        this.search = search;
+        this.tabIndex = tabIndex;
+        this.minValue = minValue;
+        this.maxValue = maxValue;
+        this.dependsOn = dependsOn;
+        this.mask = mask;
+        this.regExp = regExp;
+    }
+}
+
+var FilterType;
+(function (FilterType) {
+    FilterType["STRING"] = "STRING";
+    FilterType["BOOLEAN"] = "BOOLEAN";
+    FilterType["INTEGER"] = "INTEGER";
+    FilterType["DOUBLE"] = "DOUBLE";
+    FilterType["DATE"] = "DATE";
+    FilterType["DATETIME"] = "DATETIME";
+    FilterType["TIME"] = "TIME";
+    FilterType["MONEY"] = "MONEY";
+    FilterType["ENUMERATION"] = "ENUMERATION";
+    FilterType["SEARCH"] = "SEARCH";
+})(FilterType || (FilterType = {}));
+
+var Scope;
+(function (Scope) {
+    Scope["DOMAIN"] = "DOMAIN";
+    Scope["SERVICE"] = "SERVICE";
+})(Scope || (Scope = {}));
+
+class FormFilter {
+    _value;
+    _valueObserver = new Subject();
+    valueChanges = this._valueObserver.asObservable();
+    name;
+    domain;
+    contexts;
+    services;
+    childs;
+    dependsOn;
+    filterControl;
+    type;
+    isMultiple;
+    defaultValue;
+    constructor({ value, ...config }) {
+        this._value = value;
+        Object.assign(this, config);
+    }
+    set value(value) {
+        this._value = value;
+        this._valueObserver.next(value);
+    }
+    get value() {
+        return this._value;
+    }
+}
+
+class TabView {
+    fields = [];
+    form;
+    name;
+    constructor(config) {
+        this.form = new FormGroup({});
+        Object.assign(this, config);
+    }
+}
+class ContextTab extends TabView {
+    activeFilters = 0;
+    domain;
+    get label() {
+        return `${this.name} (${this.activeFilters})`;
+    }
+}
+
+const FILTER_ID_SEPARATOR = ':';
+function getFilterId(domain, filterName) {
+    return `${domain}${FILTER_ID_SEPARATOR}${filterName}`;
+}
+function getTabId(domain, contextId) {
+    return `${domain}${FILTER_ID_SEPARATOR}${contextId}`;
+}
+
+// NOSONAR
+/**
+ *@description  Necessary because of https://github.com/rollup/rollup/issues/670
+ *
+ * */
+const moment$1 = momentNs.default || momentNs;
+const { DATETIME: DATETIME$1, TIME: TIME$1, DATE: DATE$1 } = FilterType;
+const parsers$1 = {
+    [DATE$1]: (value) => dateParser$1(value, 'YYYY-MM-DD'),
+    [TIME$1]: (value) => dateParser$1(value, 'HH:mm:ss'),
+    [DATETIME$1]: (value) => dateParser$1(value)
+};
+function parseFilterValue(value, type) {
+    const parser = parsers$1[type];
+    if (value !== undefined && value !== null && value !== '') {
+        return parser ? parser(value) : value;
+    }
+    return value;
+}
+function dateParser$1(value, format) {
+    const date = moment$1(value);
+    return format ? date.format(format) : date.format();
+}
+
+function jsonPath(obj, path) {
+    if (!obj || !path) {
+        return undefined;
+    }
+    const parts = path.replace(/^\$\./, '').split('.');
+    const current = parts[0];
+    const value = obj[current];
+    if (parts.length > 1) {
+        return jsonPath(value, parts.slice(1).join('.'));
+    }
+    return value;
+}
+
+const filterOperators = {
+    'contains': (attr, value) => `containing(${attr}, '${value}')`,
+    '=': (attr, value) => `${attr} eq ${value}`,
+    '!=': (attr, value) => `${attr} ne ${value}`,
+    '>': (attr, value) => `${attr} gt ${value}`,
+    '<': (attr, value) => `${attr} lt ${value}`,
+    '>=': (attr, value) => `${attr} ge ${value}`
+};
+
+function toUserFormat(value, type) {
+    let parsedValue;
+    if (type !== FilterType.SEARCH || !Array.isArray(value)) {
+        parsedValue = [(value === null || value === undefined) ? '' : value];
+    }
+    else if (Array.isArray(value)) {
+        if (value.length) {
+            parsedValue = value[0] === null ? [''] : value;
+        }
+        else {
+            parsedValue = [''];
+        }
+    }
+    else {
+        parsedValue = value ? value : [''];
+    }
+    return JSON.stringify(parsedValue);
+}
+function toFilterFormat(value, type) {
+    let parsedValue;
+    if (type !== FilterType.SEARCH) {
+        parsedValue = [(value === null || value === undefined) ? '' : value];
+    }
+    else if (Array.isArray(value)) {
+        /*
+        Deve enviar para o backend o valor contido no keyValue em array.
+    
+        Exemplo:
+        Quando tenho dois objetos selecionados [{1,'Base'},{2,'Other'}] deve enviar no padrão: [1,'Base'], [2,'Other']
+        */
+        parsedValue = [''];
+        if (value !== null && value.length > 0 && value[0] !== '') {
+            parsedValue = value.map(v => v[searchKeyName]);
+        }
+    }
+    else {
+        parsedValue = [value === null ? '' : value[searchKeyName]];
+    }
+    return JSON.stringify(parsedValue);
+}
+function fromJson(value, type, isNotMultiple) {
+    const parsedValue = JSON.parse(value);
+    if (type !== FilterType.SEARCH || isNotMultiple) {
+        return parsedValue[0];
+    }
+    return parsedValue;
+}
+function getSearchType(search) {
+    return search.basicSearch ? search.basicSearch : search.entitySearch;
+}
+
+/* sonar-ignore */
+/**
+ *@description  Necessary because of https://github.com/rollup/rollup/issues/670
+ *
+ * */
+const moment = momentNs.default || momentNs;
+const { DATE, DATETIME, TIME } = FilterType;
+const parsers = {
+    [DATE]: (v) => dateParser(v),
+    [DATETIME]: (v) => dateParser(v),
+    [TIME]: (v) => dateParser(v, 'HH:mm:ss')
+};
+function parseFormValue(value, type, search) {
+    const parser = parsers[type];
+    const parsedValue = JSON.parse(value);
+    const isNotMultiple = search && getSearchType(search).output.maxSelectedItems === 1;
+    let formValue;
+    if ((type === FilterType.INTEGER || type === FilterType.DOUBLE || type === FilterType.MONEY) && parsedValue[0] === '') {
+        formValue = null;
+    }
+    else if (type !== FilterType.SEARCH || isNotMultiple) {
+        formValue = parsedValue[0];
+    }
+    else {
+        formValue = parsedValue[0] ? parsedValue : [];
+    }
+    if (parser) {
+        return parser(formValue);
+    }
+    return formValue;
+}
+function createFormControl({ minValue, maxValue, regExp, value, type, search }) {
+    const validators = createValidators(minValue, maxValue, regExp);
+    const formValue = parseFormValue(value, type, search);
+    return new FormControl(formValue, { validators });
+}
+function createValidators(minValue, maxValue, regExp) {
+    const { pattern, min, max } = Validators;
+    const validators = [];
+    regExp && validators.push(pattern(regExp));
+    minValue !== undefined && validators.push(min(minValue));
+    maxValue !== undefined && validators.push(max(maxValue));
+    return validators;
+}
+function dateParser(value, format) {
+    return value !== null && value !== '' ? moment(value, format).toDate() : '';
+}
+
+const supportedTypes = [
+    FilterType.STRING,
+    FilterType.BOOLEAN,
+    FilterType.INTEGER,
+    FilterType.ENUMERATION,
+    FilterType.TIME,
+    FilterType.MONEY,
+    FilterType.DATETIME,
+    FilterType.DATE,
+    FilterType.DOUBLE
+];
+const operation = {
+    '>': (value, otherValue) => {
+        return value > otherValue;
+    },
+    '<': (value, otherValue) => {
+        return value < otherValue;
+    },
+    '>=': (value, otherValue) => {
+        return value >= otherValue;
+    },
+    '<=': (value, otherValue) => {
+        return value <= otherValue;
+    },
+    'contains': (value, otherValue) => {
+        return contains(value, otherValue);
+    },
+    '=': (value, otherValue) => {
+        if (typeof otherValue === 'number') {
+            return equals(Number(value), otherValue);
+        }
+        return equals(value, otherValue);
+    },
+    '!=': (value, otherValue) => {
+        if (typeof otherValue === 'number') {
+            return !equals(Number(value), otherValue);
+        }
+        return !equals(value, otherValue);
+    }
+};
+function compare(operator, value, otherValue) {
+    const comparator = operation[operator];
+    return comparator(value, otherValue);
+}
+function isValidOperator(operator) {
+    return !!operation[operator];
+}
+function isSupportedType(type) {
+    return contains(type, supportedTypes);
+}
+
+const TRANSLATE_PREFIX$2 = 'platform.filter_service';
+class CalendarOptionsService {
+    translate = inject(TranslateService);
+    getOptions() {
+        return {
+            clear: this.translate.instant(`${TRANSLATE_PREFIX$2}.clear`),
+            dateFormat: this.translate.instant(`${TRANSLATE_PREFIX$2}.date_format`),
+            dayNames: [
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_sunday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_monday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_tuesday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_wednesday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_thursday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_friday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_saturday`)
+            ],
+            dayNamesMin: [
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.min_sunday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.min_monday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.min_tuesday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.min_wednesday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.min_thursday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.min_friday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.min_saturday`)
+            ],
+            dayNamesShort: [
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_sunday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_monday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_tuesday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_wednesday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_thursday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_friday`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_saturday`)
+            ],
+            firstDayOfWeek: 0,
+            hourFormat: this.translate.instant(`${TRANSLATE_PREFIX$2}.hour_format`),
+            monthNames: [
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_january`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_february`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_march`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_april`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_may`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_june`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_july`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_august`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_september`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_october`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_november`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.name_december`),
+            ],
+            monthNamesShort: [
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_january`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_february`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_march`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_april`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_may`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_june`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_july`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_august`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_september`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_october`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_november`),
+                this.translate.instant(`${TRANSLATE_PREFIX$2}.short_december`),
+            ],
+            today: this.translate.instant(`${TRANSLATE_PREFIX$2}.today`)
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarOptionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarOptionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarOptionsService, decorators: [{
+            type: Injectable
+        }] });
+
+const TRANSLATE_PREFIX$1 = 'platform.filter_service';
+const TOAST_LIFE = 5000;
+class FormFilterComponent {
+    filterService = inject(AdvancedFilterService);
+    translate = inject(TranslateService);
+    toastService = inject(ToastService);
+    calendarOptionsService = inject(CalendarOptionsService);
+    changeDetectorRef = inject(ChangeDetectorRef);
+    destroy$ = new Subject();
+    errorState;
+    tabs;
+    contexts = [];
+    formFilters = [];
+    oldFormFilters = [];
+    actualFormFilters = [];
+    general = new TabView({ name: 'Geral' });
+    totalFiltersActive = 0;
+    isMobile = false;
+    tabViewOrientation = 'left';
+    error = false;
+    activeIndex = 0;
+    errorMessages = {
+        min: this.translate.instant(`${TRANSLATE_PREFIX$1}.error_min_value`),
+        max: this.translate.instant(`${TRANSLATE_PREFIX$1}.error_max_value`),
+        pattern: this.translate.instant(`${TRANSLATE_PREFIX$1}.invalid_pattern`)
+    };
+    showMessages = true;
+    isModal = false;
+    contextId = '';
+    totalFiltersActiveOutput = new EventEmitter();
+    errorOutput = new EventEmitter();
+    showDialogOutput = new EventEmitter();
+    closeModalOutput = new EventEmitter();
+    onResizeWindow(event) {
+        const { innerWidth } = event.target;
+        this.isMobile = innerWidth <= 640;
+        this.tabViewOrientation = this.isMobile ? 'top' : 'left';
+    }
+    ngOnInit() {
+        this.isMobile = innerWidth <= 640;
+        this.tabViewOrientation = this.isMobile ? 'top' : 'left';
+        this.subscribeContextsObservable();
+        this.subscribeFiltersObservable();
+        window.addEventListener('message', event => {
+            const data = event.data;
+            const message = data.message && data.message.split(':')[1];
+            if (message === 'addContext') {
+                this.filterService.addContexts(...data.payload);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+    }
+    hasChanges() {
+        if (!this.oldFormFilters?.length) {
+            return true;
+        }
+        const filtered = this.formFilters.filter((currentFilter, index) => {
+            const oldFilter = this.oldFormFilters[index];
+            const oldValue = oldFilter ? oldFilter.value : undefined;
+            return !equals(currentFilter.value, oldValue);
+        });
+        return filtered.length > 0;
+    }
+    onApplyFilters() {
+        this.hasChanges() && this.closeModalOutput.emit();
+    }
+    getFilters() {
+        this.hasChanges() && this.filterService.tryAgain(this.contexts);
+    }
+    applyFilters(showToast = false) {
+        if (this.hasChanges()) {
+            this.showDialogOutput.emit(false);
+            this.counterUpdate();
+            const filters = this.getFiltersValues(this.formFilters);
+            this.filterService.saveTickedFilters(filters);
+        }
+        else if (showToast) {
+            const message = {
+                severity: 'info',
+                duration: TOAST_LIFE,
+                text: this.translate.instant(`${TRANSLATE_PREFIX$1}.applied_filter_nochange`, { activeFilters: this.totalFiltersActive })
+            };
+            this.sendMessage(message);
+        }
+        this.oldFormFilters = clone(this.formFilters);
+    }
+    getDefaultValue(defaultValue, isMultiple) {
+        if (defaultValue === undefined || (isMultiple && defaultValue[0] === '')) {
+            return [];
+        }
+        return defaultValue;
+    }
+    clearFilters() {
+        const keys = Object.keys(this.formFilters);
+        keys.forEach(key => this.cleanFieldAndSetDefaultValue(key));
+    }
+    sendCloseMessage() {
+        window.parent.postMessage({
+            message: 'dashboard:close-modal',
+            payload: {
+                modalName: 'advanced-filter-1'
+            }
+        }, '*');
+    }
+    sendMessage(message) {
+        if (this.showMessages) {
+            this.toastService.show(message);
+        }
+        else {
+            window.parent.postMessage({
+                message: 'dashboard:toastr',
+                payload: {
+                    type: 'success',
+                    message: message.detail
+                }
+            }, '*');
+        }
+    }
+    saveFilters(forceSave = false) {
+        const filters = this.parseToUserFilters(this.formFilters);
+        const savedFilterSuccess = () => {
+            if (!forceSave) {
+                const message = {
+                    severity: 'info',
+                    duration: TOAST_LIFE,
+                    text: this.translate.instant(`${TRANSLATE_PREFIX$1}.saved_filters_success`, { activeFilters: this.totalFiltersActive })
+                };
+                this.sendMessage(message);
+            }
+            this.counterUpdate();
+        };
+        const savedFiltersError = () => {
+            const message = {
+                severity: 'error',
+                duration: TOAST_LIFE,
+                text: this.translate.instant(`${TRANSLATE_PREFIX$1}.saved_filters_error`, { activeFilters: this.totalFiltersActive })
+            };
+            this.sendMessage(message);
+        };
+        this.filterService
+            .saveFilters(filters)
+            .subscribe(savedFilterSuccess, savedFiltersError);
+    }
+    saveFiltersWithCallbackFunction(callbackFunction) {
+        const filters = this.parseToUserFilters(this.formFilters);
+        this.filterService
+            .saveFilters(filters)
+            .subscribe(callbackFunction);
+    }
+    counterUpdate() {
+        this.totalFiltersActive = this.countActiveFilters(this.tabs);
+        this.totalFiltersActiveOutput.emit(this.totalFiltersActive);
+    }
+    countActiveFilters(tabs) {
+        let totalFiltersActive = 0;
+        tabs.forEach(tabView => {
+            const { value } = tabView.form;
+            tabView.activeFilters = Object.keys(value).reduce((appliedFilters, key) => {
+                const filterValue = value[key];
+                const isArray = Array.isArray(filterValue);
+                const isValidArray = isArray && filterValue.length > 0;
+                if (isValidArray || (!isArray && filterValue)) {
+                    appliedFilters++;
+                }
+                return appliedFilters;
+            }, 0);
+            totalFiltersActive += tabView.activeFilters;
+        });
+        return totalFiltersActive;
+    }
+    parseToUserFilters(filters) {
+        return filters.reduce((all, filter) => {
+            const { type, services, name, value, domain, contexts } = filter;
+            const filterValue = toUserFormat(value, type);
+            const values = services.map(service => ({ name, service, value: filterValue, domain, contexts }));
+            return [...all, ...values];
+        }, []);
+    }
+    getFiltersValues(filters) {
+        const filtersAsObject = filters;
+        const ids = Object.keys(filtersAsObject);
+        return ids.reduce((all, filterId) => {
+            const { type, services, name, value, domain } = filtersAsObject[filterId];
+            const filterValue = toFilterFormat(value, type);
+            const values = services.map(service => ({ name, service, value: filterValue, domain }));
+            return [...all, ...values];
+        }, []);
+    }
+    subscribeContextsObservable() {
+        const { contextsObserver } = this.filterService;
+        contextsObserver.pipe(takeUntil(this.destroy$)).subscribe((contexts) => (this.contexts = contexts));
+    }
+    errorStateAction() {
+        this.filterService.tryAgain(this.contexts);
+    }
+    subscribeFiltersObservable() {
+        const { filtersObserver } = this.filterService;
+        filtersObserver
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(({ filters, applyFilter, error, message }) => {
+            this.errorOutput.emit(error);
+            this.error = error;
+            this.errorState = message;
+            if (!error) {
+                this.createForm(filters, applyFilter);
+            }
+        });
+    }
+    createForm(filters, applyFilter) {
+        this.tabs = this.createTabs(filters);
+        this.counterUpdate();
+        this.setDependencies(this.formFilters);
+        this.createChildArray();
+        if (filters.length > 0 && applyFilter) {
+            this.applyFilters();
+        }
+    }
+    setDependencies(filters) {
+        const filtersMap = {};
+        filters.forEach(f => {
+            const id = getFilterId(f.domain, f.name);
+            filtersMap[id] = f;
+        });
+        const names = Object.keys(filtersMap);
+        const dependencies = from(names).pipe(map(key => filtersMap[key]), filter(({ dependsOn }) => dependsOn && dependsOn.length > 0), tap(({ dependsOn, domain, filterControl }) => {
+            const invalidFilters = dependsOn
+                .filter(dep => dep.required)
+                .filter(dep => {
+                const id = getFilterId(domain, dep.filterName);
+                const formFilter = filtersMap[id];
+                if (!formFilter) {
+                    return true;
+                }
+                const { value, type } = formFilter;
+                const { comparator } = dep;
+                if (comparator && isValidOperator(comparator.operator) && isSupportedType(type)) {
+                    const fieldValue = parseFilterValue(value, type);
+                    return !compare(comparator.operator, comparator.value, fieldValue);
+                }
+                return dep.required ? !formFilter.value : formFilter.value;
+            });
+            if (invalidFilters.length > 0) {
+                filterControl.disable();
+            }
+        }), map(({ domain, dependsOn, filterControl }) => ({ domain, dependsOn, filterControl })));
+        dependencies.subscribe(({ dependsOn, domain, filterControl }) => from(dependsOn)
+            .pipe(filter(dep => dep.required), map(({ filterName }) => getFilterId(domain, filterName)), map(filterId => filtersMap[filterId]), mergeMap(formFilter => from(formFilter.valueChanges || [])), map(val => {
+            const comparation = dependsOn.every(dep => {
+                const filterId = getFilterId(domain, dep.filterName);
+                if (this.formFilters[filterId]) {
+                    const type = this.formFilters[filterId].type;
+                    const { comparator } = dep;
+                    if (comparator && isValidOperator(comparator.operator) && isSupportedType(type)) {
+                        const value = parseFilterValue(val, type);
+                        return compare(comparator.operator, comparator.value, value);
+                    }
+                    return true;
+                }
+                return true;
+            });
+            return !this.IsEmpty(val) && comparation ? 'enable' : 'disable';
+        }))
+            .subscribe(status => filterControl[status]()));
+    }
+    addGeneralField(filter) {
+        const { name, domain, type } = filter;
+        const controlName = getFilterId(domain, name);
+        const fieldControl = createFormControl(filter);
+        fieldControl.valueChanges
+            .pipe(takeUntil(this.destroy$), map(v => parseFilterValue(v, type)), tap(value => (this.formFilters[controlName].value = value)))
+            .subscribe(val => this.tabs.forEach(tab => {
+            const control = tab.form.controls[name];
+            if (control && tab.domain === domain) {
+                control.setValue(val, { emitEvent: false });
+            }
+        }));
+        const newFilter = { ...filter, ...{ name: controlName } };
+        const newField = this.createField(newFilter);
+        this.general.form.addControl(controlName, fieldControl);
+        this.general.fields.push(newField);
+    }
+    /*
+     * Verifica os contextos de cada filtro, caso todos os contextos foram informados:
+     * @return true
+     * Caso não tenha nenhum contexto, considera-se por padrão que é todos:
+     * @return true
+     */
+    containsAllContexts(myContexts) {
+        if (!myContexts.length) {
+            return true;
+        }
+        const allContexts = this.contexts.map(data => data.contextId);
+        return equals(myContexts.sort(), allContexts.sort());
+    }
+    /**
+     *
+     * @todo Refatorar. O método possui muitas responsabilidades
+     *
+     */
+    createTabs(filters) {
+        return filters.reduce((tabs, filter) => {
+            const { domain, services, name, type, scope, contexts, dependsOn, value, search, defaultValue } = filter;
+            const isNotMultiple = search && getSearchType(search).output.maxSelectedItems === 1;
+            const field = this.createField(filter);
+            const filterId = getFilterId(domain, name);
+            const filterConfig = {
+                domain,
+                contexts,
+                services,
+                name,
+                dependsOn,
+                value: fromJson(value, type, isNotMultiple),
+                type,
+                isMultiple: !isNotMultiple,
+                defaultValue: fromJson(defaultValue, type, isNotMultiple)
+            };
+            this.formFilters[filterId] = new FormFilter(filterConfig);
+            const formFilter = this.formFilters[filterId];
+            if (scope === Scope.DOMAIN && this.containsAllContexts(contexts)) {
+                this.addGeneralField(filter);
+            }
+            contexts.forEach(contextId => {
+                if ((contextId === this.contextId) || (this.contextId === '')) {
+                    const tabId = getTabId(domain, contextId);
+                    const fieldControl = createFormControl(filter);
+                    if (!tabs.has(tabId)) {
+                        const { contextLabel } = this.contexts.find(context => context.contextId === contextId);
+                        const tab = new ContextTab({ domain, name: contextLabel });
+                        tabs.set(tabId, tab);
+                    }
+                    fieldControl.valueChanges
+                        .pipe(takeUntil(this.destroy$))
+                        .subscribe((val) => this.updateFilterValue(tabId, name, val, domain, type));
+                    const contextTab = tabs.get(tabId);
+                    contextTab.fields.push(field);
+                    contextTab.form.addControl(filter.name, fieldControl);
+                    if (!formFilter.filterControl) {
+                        formFilter.filterControl = fieldControl;
+                    }
+                }
+            });
+            return tabs;
+        }, new Map());
+    }
+    updateFilterValue(tabId, filterName, value, domain, type) {
+        const controlOpts = { emitEvent: false };
+        const fieldValue = parseFilterValue(value, type);
+        const filterId = getFilterId(domain, filterName);
+        const generalFieldControl = this.general.form.controls[filterId];
+        this.tabs.forEach(({ form }, key) => {
+            const control = form.controls[filterName];
+            if (tabId !== key && control) {
+                control.setValue(value, controlOpts);
+            }
+        });
+        const { childs } = this.formFilters[filterId];
+        childs && childs.forEach((child) => this.cleanFieldAndSetDefaultValue(child.filter.key));
+        generalFieldControl && generalFieldControl.setValue(value, controlOpts);
+        this.formFilters[filterId].value = fieldValue;
+    }
+    cleanFieldAndSetDefaultValue(key) {
+        const { isMultiple, defaultValue, filterControl, type } = this.formFilters[key];
+        const finalValue = this.getDefaultValue(defaultValue, isMultiple);
+        if (filterControl) {
+            if (type === 'DATE' || (type === 'SEARCH' && isMultiple)) {
+                filterControl.setValue(finalValue);
+            }
+            if (type === 'INTEGER' || type === 'DOUBLE' || type === 'MONEY') {
+                finalValue === '' ? filterControl.setValue(null) : filterControl.setValue(finalValue);
+            }
+            else {
+                filterControl.setValue(finalValue, { onlySelf: true });
+            }
+        }
+    }
+    createChildArray() {
+        const keys = Object.keys(this.formFilters);
+        keys.forEach(key => {
+            const { dependsOn, domain } = this.formFilters[key];
+            dependsOn.forEach((field) => {
+                const filterId = getFilterId(domain, field.filterName);
+                if (this.formFilters[filterId]) {
+                    if (!this.formFilters[filterId].childs) {
+                        this.formFilters[filterId].childs = [];
+                    }
+                    this.formFilters[filterId].childs.push({ filter: { key, required: field.required } });
+                }
+            });
+        });
+    }
+    createField(filter) {
+        const { name, label, enumItems, type, mask } = filter;
+        const translatedEnumItems = enumItems && enumItems.map((item) => ({ label: this.translate.instant(item.label), value: item.value }));
+        const field = { name, label: this.translate.instant(label), placeholder: '' };
+        const creators = {
+            [FilterType.STRING]: () => new TextField({ ...field, mask: mask ? () => mask : null, type: FieldType.String }),
+            [FilterType.MONEY]: () => new CurrencyField({ ...field, type: FieldType.Money }),
+            [FilterType.BOOLEAN]: () => this.createRadioButton({ ...field }),
+            [FilterType.DATE]: () => this.createCalendar({ ...field, type: FieldType.Date }),
+            [FilterType.DATETIME]: () => this.createCalendar({ ...field, type: FieldType.DateTime }),
+            [FilterType.TIME]: () => this.createCalendar({ ...field, type: FieldType.Time }),
+            [FilterType.ENUMERATION]: () => new SelectField({
+                ...field,
+                placeholder: this.translate.instant('platform.filter_service.select'),
+                options: [...translatedEnumItems],
+                type: FieldType.Enum
+            }),
+            [FilterType.INTEGER]: () => new NumberField({
+                ...field,
+                numberLocaleOptions: this.optionsInteger(),
+                mask: mask ? () => mask : null,
+                type: FieldType.Integer
+            }),
+            [FilterType.DOUBLE]: () => new CurrencyField({ ...field, type: FieldType.Double }),
+            [FilterType.SEARCH]: () => this.createAutocompleteField(field, filter)
+        };
+        return creators[type]();
+    }
+    createRadioButton(field) {
+        const options = [
+            { label: this.translate.instant(`${TRANSLATE_PREFIX$1}.yes`), value: true },
+            { label: this.translate.instant(`${TRANSLATE_PREFIX$1}.no`), value: false }
+        ];
+        return new RadioButtonField({ ...field, type: FieldType.Radio, options });
+    }
+    createCalendar(config) {
+        const calendar = new CalendarField(config);
+        calendar.calendarLocaleOptions = this.calendarOptionsService.getOptions();
+        if (!this.isModal)
+            calendar.appendTo = 'body';
+        return calendar;
+    }
+    createAutocompleteField(field, { dependsOn, search, domain, name }) {
+        const suggestionsObservable = new BehaviorSubject([]);
+        const { queryParam } = getSearchType(search).input;
+        const { displayFields, keyFields, resultDataJsonPath, displayFieldConcatToken, maxSelectedItems } = getSearchType(search).output;
+        const filterId = getFilterId(domain, name);
+        const suggestionsError = (messageError) => {
+            const messageDetail = messageError ? messageError : this.translate.instant(`${TRANSLATE_PREFIX$1}.find_suggestions_error`, { activeFilters: this.totalFiltersActive });
+            const message = {
+                severity: 'error',
+                duration: TOAST_LIFE,
+                text: messageDetail
+            };
+            this.sendMessage(message);
+        };
+        const onSearch = (val) => {
+            const params = { [queryParam]: val };
+            dependsOn && Object.assign(params, this.getDependenciesValues(dependsOn, domain));
+            const searchUrl = search && search.type === 'ENTITY'
+                ? this.getEntitySearchUrl(search.entitySearch.input, val, dependsOn)
+                : getSearchType(search).input.url;
+            this.filterService
+                .searchFieldSuggestions(searchUrl, params, search.type)
+                .pipe(map(response => jsonPath(response, resultDataJsonPath)), map((suggestions) => this.addSuggestionFields(suggestions, displayFields, keyFields, displayFieldConcatToken, filterId)))
+                .subscribe(result => {
+                suggestionsObservable.next(result);
+                this.changeDetectorRef.detectChanges();
+            }, (error) => {
+                let messageError = undefined;
+                if (error && error.error.message)
+                    messageError = error.error.message;
+                suggestionsError(messageError);
+            });
+        };
+        return new AutocompleteField({
+            ...field,
+            onSearch,
+            appendTo: 'body',
+            suggestionsObservable,
+            displayField: searchDisplayName,
+            dataKey: searchKeyName,
+            multiple: maxSelectedItems > 1,
+            size: { lg: 12, md: 12, xl: 12 },
+            emptyMessage: this.translate.instant(`${TRANSLATE_PREFIX$1}.search_empty_message`)
+        });
+    }
+    safeReplaceCommas(input, operator) {
+        let output = '';
+        let parenCount = 0;
+        let justAddedOperator = false;
+        for (const char of input) {
+            let charToAdd = char;
+            ({ parenCount, justAddedOperator } = this.updateParenAndOperatorState(char, parenCount, justAddedOperator));
+            ({ charToAdd, justAddedOperator } = this.processCommaSubstitution(char, parenCount, justAddedOperator, operator, charToAdd));
+            justAddedOperator = this.updateNonCommaOperatorState(char, charToAdd, justAddedOperator);
+            output += charToAdd;
+        }
+        return output;
+    }
+    updateParenAndOperatorState(char, parenCount, justAddedOperator) {
+        if (char === '(') {
+            parenCount++;
+            justAddedOperator = false;
+        }
+        else if (char === ')') {
+            parenCount--;
+            justAddedOperator = false;
+        }
+        else {
+            // Nenhuma ação necessária para outros caracteres
+        }
+        return { parenCount, justAddedOperator };
+    }
+    processCommaSubstitution(char, parenCount, justAddedOperator, operator, charToAdd) {
+        if (char === ',') {
+            if (parenCount === 0) {
+                if (!justAddedOperator) {
+                    charToAdd = ` ${operator} `;
+                    justAddedOperator = true;
+                }
+                else {
+                    charToAdd = '';
+                }
+            }
+            else {
+                justAddedOperator = false;
+            }
+        }
+        return { charToAdd, justAddedOperator };
+    }
+    updateNonCommaOperatorState(char, charToAdd, justAddedOperator) {
+        if (char !== ',') {
+            if (charToAdd !== char) {
+                return false;
+            }
+            if (char !== '(' && char !== ')') {
+                return false;
+            }
+        }
+        return justAddedOperator;
+    }
+    getEntitySearchUrl(search, value, dependsOn) {
+        const { attributes, domainName, entityName, serviceName } = search;
+        const url = `${domainName}/${serviceName}/entities/${entityName}/?filter=`;
+        const filters = attributes.map(attr => filterOperators[attr.comparator](attr.name, value));
+        dependsOn &&
+            dependsOn.forEach(obj => {
+                const filterId = getFilterId(domainName, obj.filterName);
+                const fieldValue = this.formFilters[filterId].value[searchKeyName];
+                filters.push(`${obj.entityAttribute} eq '${fieldValue}'`);
+            });
+        const filtersString = filters.join(',');
+        const finalFilter = this.safeReplaceCommas(filtersString, search.operator);
+        return url.concat(finalFilter);
+    }
+    addSuggestionFields(suggestions, displayFields, keyFields, separator, filterId) {
+        const addValue = (acc, value, token) => (acc ? `${acc}${token}${value}` : value);
+        const result = suggestions.map(suggestion => ({
+            ...suggestion,
+            [searchDisplayName]: displayFields.reduce((value, display) => {
+                return addValue(value, this.translate.instant(suggestion[display]), separator);
+            }, ''),
+            [searchKeyName]: keyFields.reduce((value, key) => addValue(value, suggestion[key], ', '), '')
+        }));
+        this.formFilters[filterId].invalidValue = result.length === 0;
+        return result.filter(item => {
+            const { value } = this.formFilters[filterId];
+            if (Array.isArray(value)) {
+                const index = value.findIndex((i) => i.$$__keyValue__ === item.$$__keyValue__);
+                if (index === -1) {
+                    return item;
+                }
+            }
+            else {
+                return item;
+            }
+        });
+    }
+    getDependenciesValues(dependencies, domain) {
+        return dependencies.reduce((params, { filterName }) => {
+            const filterId = getFilterId(domain, filterName);
+            if (this.formFilters[filterId]) {
+                const { value, type } = this.formFilters[filterId];
+                if (type === 'ENUMERATION') {
+                    params[filterName] = value;
+                }
+                else {
+                    if (Array.isArray(value)) {
+                        params[filterName] = value.map(arr => arr[searchKeyName]);
+                    }
+                    else {
+                        params[filterName] = value ? value[searchKeyName] : [''];
+                    }
+                }
+                this.IsEmpty(params[filterName]) && delete params[filterName];
+            }
+            return params;
+        }, {});
+    }
+    /*
+     * Verifica se o valor informado é falso, em arrays, é verificado cada item
+     */
+    IsEmpty(value) {
+        return Array.isArray(value) ? value.every(data => !data) : !value;
+    }
+    /**
+     * Return format to specify for integer type field
+     */
+    optionsInteger() {
+        return { currencySymbol: '', decimalSeparator: '', thousandsSeparator: '' };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FormFilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: FormFilterComponent, selector: "s-app-form-filter", inputs: { showMessages: "showMessages", isModal: "isModal", contextId: "contextId" }, outputs: { totalFiltersActiveOutput: "totalFiltersActiveOutput", errorOutput: "errorOutput", showDialogOutput: "showDialogOutput", closeModalOutput: "closeModalOutput" }, host: { listeners: { "window:resize": "onResizeWindow($event)" } }, ngImport: i0, template: "<s-empty-state\n  *ngIf=\"error\"\n  iconClass=\"fa fa-exclamation-triangle\"\n  title=\"{{ errorState?.status }} - {{ errorState?.statusText }}\"\n  (primaryAction)=\"errorStateAction()\"\n  [primaryActionLabel]=\"translate.instant('platform.filter_service.try')\"\n  [description]=\"translate.instant('platform.filter_service.error_state')\"\n></s-empty-state>\n\n<div *ngIf=\"!error\">\n  <p-tabView *ngIf=\"tabs && tabs.size > 1\"\n    [(activeIndex)]=\"activeIndex\">\n\n    <p-tabPanel header=\"{{ general.name }}\" *ngIf=\"general.fields.length\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"general.fields\"\n        [form]=\"general.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n\n    <p-tabPanel *ngFor=\"let tab of (tabs | mapValues)\"\n      header=\"{{ tab.label }}\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"tab.fields\"\n        [form]=\"tab.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n  </p-tabView>\n\n  <div *ngIf=\"tabs && tabs.size === 1\">\n    <s-dynamic-form\n      *ngFor=\"let tab of (tabs | mapValues)\"\n      [errorMessages]=\"errorMessages\"\n      [fields]=\"tab.fields\"\n      [form]=\"tab.form\">\n    </s-dynamic-form>\n  </div>\n</div>\n", styles: [".filter-dialog{width:800px;top:100px}.filter-dialog>.ui-dialog-content{height:300px;padding:10px!important}@media (min-width: 641px) and (max-width: 1024px){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:300px}}@media only screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation: portrait){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:90%}}@media (min-width: 320px) and (max-width: 640px){.filter-dialog{width:95%;left:0;top:0;opacity:1;margin:auto;height:93%}.filter-dialog>.ui-dialog-content{height:85%}}@media (min-width: 320px) and (max-width: 640px) and (max-width: 360px){.filter-dialog button{padding:0!important}.filter-dialog>.ui-dialog-content{height:81%}}\n"], dependencies: [{ kind: "component", type: i1$1.TabView, selector: "p-tabView, p-tabview", inputs: ["style", "styleClass", "controlClose", "scrollable", "activeIndex", "selectOnFocus", "nextButtonAriaLabel", "prevButtonAriaLabel", "autoHideButtons", "tabindex"], outputs: ["onChange", "onClose", "activeIndexChange"] }, { kind: "component", type: i1$1.TabPanel, selector: "p-tabPanel, p-tabpanel", inputs: ["closable", "headerStyle", "headerStyleClass", "cache", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "selected", "disabled", "header", "leftIcon", "rightIcon"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.DynamicFormComponent, selector: "s-dynamic-form", inputs: ["id", "configs", "fields", "form", "errorMessages"] }, { kind: "component", type: i4.EmptyStateComponent, selector: "s-empty-state", inputs: ["id", "title", "iconClass", "description", "showPrimaryAction", "showSecondaryAction", "primaryActionLabel", "secondaryActionLabel", "primaryModel"], outputs: ["primaryAction", "secondaryAction"] }, { kind: "pipe", type: MapValuesPipe, name: "mapValues" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FormFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-app-form-filter', template: "<s-empty-state\n  *ngIf=\"error\"\n  iconClass=\"fa fa-exclamation-triangle\"\n  title=\"{{ errorState?.status }} - {{ errorState?.statusText }}\"\n  (primaryAction)=\"errorStateAction()\"\n  [primaryActionLabel]=\"translate.instant('platform.filter_service.try')\"\n  [description]=\"translate.instant('platform.filter_service.error_state')\"\n></s-empty-state>\n\n<div *ngIf=\"!error\">\n  <p-tabView *ngIf=\"tabs && tabs.size > 1\"\n    [(activeIndex)]=\"activeIndex\">\n\n    <p-tabPanel header=\"{{ general.name }}\" *ngIf=\"general.fields.length\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"general.fields\"\n        [form]=\"general.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n\n    <p-tabPanel *ngFor=\"let tab of (tabs | mapValues)\"\n      header=\"{{ tab.label }}\">\n      <s-dynamic-form\n        [errorMessages]=\"errorMessages\"\n        [fields]=\"tab.fields\"\n        [form]=\"tab.form\">\n      </s-dynamic-form>\n    </p-tabPanel>\n  </p-tabView>\n\n  <div *ngIf=\"tabs && tabs.size === 1\">\n    <s-dynamic-form\n      *ngFor=\"let tab of (tabs | mapValues)\"\n      [errorMessages]=\"errorMessages\"\n      [fields]=\"tab.fields\"\n      [form]=\"tab.form\">\n    </s-dynamic-form>\n  </div>\n</div>\n", styles: [".filter-dialog{width:800px;top:100px}.filter-dialog>.ui-dialog-content{height:300px;padding:10px!important}@media (min-width: 641px) and (max-width: 1024px){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:300px}}@media only screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation: portrait){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:90%}}@media (min-width: 320px) and (max-width: 640px){.filter-dialog{width:95%;left:0;top:0;opacity:1;margin:auto;height:93%}.filter-dialog>.ui-dialog-content{height:85%}}@media (min-width: 320px) and (max-width: 640px) and (max-width: 360px){.filter-dialog button{padding:0!important}.filter-dialog>.ui-dialog-content{height:81%}}\n"] }]
+        }], propDecorators: { showMessages: [{
+                type: Input
+            }], isModal: [{
+                type: Input
+            }], contextId: [{
+                type: Input
+            }], totalFiltersActiveOutput: [{
+                type: Output
+            }], errorOutput: [{
+                type: Output
+            }], showDialogOutput: [{
+                type: Output
+            }], closeModalOutput: [{
+                type: Output
+            }], onResizeWindow: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+
+const TRANSLATE_PREFIX = 'platform.filter_service';
+class AdvancedFilterComponent {
+    translate = inject(TranslateService);
+    router = inject(Router);
+    labelButton = 'Filters';
+    onlyContent = false;
+    hideButtons = false;
+    canOpenFilter = true;
+    showActiveFiltersCountBadge = true;
+    filterAndSave = false;
+    contextId = '';
+    subscriptions = [];
+    isMobile = false;
+    tabViewOrientation = 'left';
+    totalFiltersActive = 0;
+    showDialog = false;
+    error = false;
+    currentTicket = '';
+    modalComponent;
+    mobileButtonActions = [
+        { id: 'save', label: this.translate.instant('save'), command: () => this.modalComponent.saveFilters() },
+        { id: 'clear', label: this.translate.instant('clear'), command: () => this.modalComponent.clearFilters() }
+    ];
+    ngOnInit() {
+        this.isMobile = innerWidth <= 640;
+        this.tabViewOrientation = this.isMobile ? 'top' : 'left';
+        const sub = this.router.events.subscribe(e => {
+            if (e instanceof NavigationEnd) {
+                this.modalComponent.getFilters();
+            }
+        });
+        this.subscriptions.push(sub);
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(v => v.unsubscribe());
+    }
+    onResizeWindow(event) {
+        const { innerWidth } = event.target;
+        this.isMobile = innerWidth <= 640;
+        this.tabViewOrientation = this.isMobile ? 'top' : 'left';
+    }
+    get appliedFiltersTooltip() {
+        return this.totalFiltersActive > 1
+            ? this.translate.instant(`${TRANSLATE_PREFIX}.applied_filters_message`, { totalActiveFilters: this.totalFiltersActive })
+            : this.translate.instant(`${TRANSLATE_PREFIX}.applied_filter_message`, { totalActiveFilters: this.totalFiltersActive });
+    }
+    onError(event) {
+        this.error = event;
+    }
+    saveFilters(forceSave = false) {
+        this.modalComponent.saveFilters(forceSave);
+    }
+    saveFiltersWithCallbackFunction(callbackFunction) {
+        this.modalComponent.saveFiltersWithCallbackFunction(callbackFunction);
+    }
+    clearFilters() {
+        this.modalComponent.clearFilters();
+    }
+    close() {
+        this.modalComponent.getFilters();
+        window.parent.postMessage({
+            message: 'dashboard:close-modal',
+            payload: {
+                modalName: 'advanced-filter-1'
+            }
+        }, '*');
+    }
+    applyFilters() {
+        if (this.modalComponent.hasChanges()) {
+            this.showDialog = false;
+        }
+        if (this.filterAndSave) {
+            this.modalComponent.saveFilters();
+        }
+        this.modalComponent.applyFilters(true);
+    }
+    onApplyFilters() {
+        if (this.filterAndSave) {
+            this.modalComponent.saveFilters();
+        }
+        this.modalComponent.onApplyFilters();
+    }
+    toggleDialog() {
+        this.showDialog = !this.showDialog;
+    }
+    updateTotalFiltersActive(event) {
+        this.totalFiltersActive = event;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: AdvancedFilterComponent, selector: "s-advanced-filter", inputs: { labelButton: "labelButton", onlyContent: "onlyContent", hideButtons: "hideButtons", canOpenFilter: "canOpenFilter", showActiveFiltersCountBadge: "showActiveFiltersCountBadge", filterAndSave: "filterAndSave", contextId: "contextId" }, host: { listeners: { "window:resize": "onResizeWindow($event)" } }, viewQueries: [{ propertyName: "modalComponent", first: true, predicate: FormFilterComponent, descendants: true }], ngImport: i0, template: "<s-button\n  *ngIf=\"!onlyContent\"\n  [id]=\"'filterButton'\"\n  [disabled]=\"!canOpenFilter\"\n  (clicked)=\"canOpenFilter ? toggleDialog() : ''\"\n  iconClass=\"fa fa-filter\"\n  priority=\"default\"\n  [label]=\"labelButton\"\n  [auxiliary]=\"true\"\n  [tooltip]=\"appliedFiltersTooltip\"\n>\n  <span\n    *ngIf=\"totalFiltersActive && showActiveFiltersCountBadge\"\n    class=\"sds-badge-number sds-color-primary custom-badge\"\n    >{{ totalFiltersActive }}</span\n  >\n</s-button>\n\n<section *ngIf=\"onlyContent\">\n  <div class=\"only-content-wrapper\">\n    <div class=\"header\">\n      <h3>{{ 'platform.filter_service.filters' | translate }}</h3>\n      <span (click)=\"close()\" class=\"close_btn pi pi-times\"></span>\n    </div>\n    <div class=\"app-form-filter\">\n      <s-app-form-filter\n        [showMessages]=\"false\"\n        (totalFiltersActiveOutput)=\"updateTotalFiltersActive($event)\"\n        (closeModalOutput)=\"close()\"\n        [isModal]=\"false\"\n        [contextId]=\"contextId\"\n      ></s-app-form-filter>\n    </div>\n    <div class=\"filter-footer\" *ngIf=\"!error\">\n      <s-button\n        priority=\"link\"\n        [label]=\"translate.instant('platform.filter_service.cancel')\"\n        (clicked)=\"close()\"\n      ></s-button>\n      <s-button\n        *ngIf=\"isMobile\"\n        priority=\"default\"\n        [label]=\"translate.instant('platform.filter_service.actions')\"\n        [auxiliary]=\"true\"\n        [menuOptions]=\"mobileButtonActions\"\n      ></s-button>\n      <ng-container *ngIf=\"!isMobile\">\n        <s-button\n          priority=\"secondary\"\n          [label]=\"translate.instant('platform.filter_service.clear')\"\n          (clicked)=\"clearFilters()\"\n        ></s-button>\n        <s-button\n          priority=\"secondary\"\n          [label]=\"translate.instant('platform.filter_service.save')\"\n          (clicked)=\"saveFilters()\"\n        ></s-button>\n      </ng-container>\n      <s-button\n        type=\"submit\"\n        priority=\"primary\"\n        [label]=\"translate.instant('platform.filter_service.filter')\"\n        (clicked)=\"onApplyFilters()\"\n      ></s-button>\n    </div>\n  </div>\n</section>\n\n<p-dialog\n  *ngIf=\"!onlyContent\"\n  appendTo=\"body\"\n  styleClass=\"filter-dialog\"\n  [draggable]=\"false\"\n  [modal]=\"true\"\n  [(visible)]=\"showDialog\"\n  [blockScroll]=\"true\"\n  [closable]=\"false\"\n>\n  <ng-template pTemplate=\"header\">\n    <div class=\"w-full flex items-center justify-between\">\n      <span>{{ 'platform.filter_service.filters' | translate }}</span>\n      <span\n        (click)=\"toggleDialog(); close()\"\n        (keypress)=\"toggleDialog(); close()\"\n        class=\"close_btn pi pi-times cursor-pointer\">\n      </span>\n    </div>\n  </ng-template>\n\n  <s-app-form-filter\n    [showMessages]=\"true\"\n    (errorOutput)=\"onError($event)\"\n    (totalFiltersActiveOutput)=\"updateTotalFiltersActive($event)\"\n    [isModal]=\"true\"\n    [contextId]=\"contextId\"\n  ></s-app-form-filter>\n\n    <ng-template pTemplate=\"footer\">\n      <ng-container *ngIf=\"!error && !hideButtons\">\n        <s-button\n          type=\"submit\"\n          priority=\"primary\"\n          [label]=\"translate.instant('platform.filter_service.filter')\"\n          (clicked)=\"applyFilters()\"\n        ></s-button>\n        <ng-container *ngIf=\"!isMobile\">\n          <s-button\n            priority=\"secondary\"\n            [label]=\"translate.instant('platform.filter_service.save')\"\n            (clicked)=\"saveFilters()\"\n          ></s-button>\n          <s-button\n            priority=\"secondary\"\n            [label]=\"translate.instant('platform.filter_service.clear')\"\n            (clicked)=\"clearFilters()\"\n          ></s-button>\n        </ng-container>\n        <s-button\n          *ngIf=\"isMobile\"\n          priority=\"default\"\n          [label]=\"translate.instant('platform.filter_service.actions')\"\n          [auxiliary]=\"true\"\n          [menuOptions]=\"mobileButtonActions\"\n        ></s-button>\n        <s-button\n          priority=\"link\"\n          [label]=\"translate.instant('platform.filter_service.cancel')\"\n          (clicked)=\"toggleDialog(); close()\"\n        ></s-button>\n      </ng-container>\n    </ng-template>\n</p-dialog>\n\n\n<p-toast key=\"filterServiceToastKey\" [baseZIndex]=\"5000\"></p-toast>\n", styles: [".custom-badge{position:absolute!important;right:-4px;top:-10px;height:20px;vertical-align:middle;display:table;min-width:22px}.filter-button{position:relative;border:solid 1px black;border-radius:1.5rem;background:transparent;padding:.5rem 1rem;cursor:pointer}.filter-dialog .ui-dialog-title{display:block!important;padding-right:0!important}.filter-footer{text-align:end;border-top:1px solid #e5eaea;padding:13px}.filter-dialog>.ui-dialog-content{height:300px;padding:10px!important}.app-form-filter{height:335px;max-height:335px;overflow:auto}.only-content-wrapper{background-color:#fff}.close_btn{align-content:center;justify-self:right;margin-left:auto}.close_btn:hover{cursor:pointer}.header{text-transform:uppercase;display:flex;width:100%;border-bottom:1px solid #e5eaea;padding:15px;margin-left:0}@media (min-width: 641px) and (max-width: 1024px){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:300px}}@media only screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation: portrait){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:90%}}@media (min-width: 320px) and (max-width: 640px){.filter-dialog{width:95%;left:0;top:0;opacity:1;margin:auto;height:93%}.filter-dialog>.ui-dialog-content{height:85%}}@media (min-width: 320px) and (max-width: 640px) and (max-width: 360px){.filter-dialog button{padding:0!important}.filter-dialog>.ui-dialog-content{height:81%}}\n"], dependencies: [{ kind: "component", type: i1$2.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "closeButtonProps", "maximizeButtonProps", "visible", "style", "position", "role", "content", "contentTemplate", "footerTemplate", "closeIconTemplate", "maximizeIconTemplate", "minimizeIconTemplate", "headlessTemplate"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }, { kind: "directive", type: i2$1.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i3$1.ButtonComponent, selector: "s-button", inputs: ["id", "label", "tooltip", "tooltipPosition", "iconClass", "rightIconClass", "caret", "styleClass", "baseZIndex", "disabled", "auxiliary", "type", "priority", "menuOptions", "size", "slide", "animation", "badge", "iconColor"], outputs: ["clicked"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.Toast, selector: "p-toast", inputs: ["key", "autoZIndex", "baseZIndex", "life", "style", "styleClass", "position", "preventOpenDuplicates", "preventDuplicates", "showTransformOptions", "hideTransformOptions", "showTransitionOptions", "hideTransitionOptions", "breakpoints"], outputs: ["onClose"] }, { kind: "component", type: FormFilterComponent, selector: "s-app-form-filter", inputs: ["showMessages", "isModal", "contextId"], outputs: ["totalFiltersActiveOutput", "errorOutput", "showDialogOutput", "closeModalOutput"] }, { kind: "pipe", type: TranslatePipe$1, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-advanced-filter', encapsulation: ViewEncapsulation.None, template: "<s-button\n  *ngIf=\"!onlyContent\"\n  [id]=\"'filterButton'\"\n  [disabled]=\"!canOpenFilter\"\n  (clicked)=\"canOpenFilter ? toggleDialog() : ''\"\n  iconClass=\"fa fa-filter\"\n  priority=\"default\"\n  [label]=\"labelButton\"\n  [auxiliary]=\"true\"\n  [tooltip]=\"appliedFiltersTooltip\"\n>\n  <span\n    *ngIf=\"totalFiltersActive && showActiveFiltersCountBadge\"\n    class=\"sds-badge-number sds-color-primary custom-badge\"\n    >{{ totalFiltersActive }}</span\n  >\n</s-button>\n\n<section *ngIf=\"onlyContent\">\n  <div class=\"only-content-wrapper\">\n    <div class=\"header\">\n      <h3>{{ 'platform.filter_service.filters' | translate }}</h3>\n      <span (click)=\"close()\" class=\"close_btn pi pi-times\"></span>\n    </div>\n    <div class=\"app-form-filter\">\n      <s-app-form-filter\n        [showMessages]=\"false\"\n        (totalFiltersActiveOutput)=\"updateTotalFiltersActive($event)\"\n        (closeModalOutput)=\"close()\"\n        [isModal]=\"false\"\n        [contextId]=\"contextId\"\n      ></s-app-form-filter>\n    </div>\n    <div class=\"filter-footer\" *ngIf=\"!error\">\n      <s-button\n        priority=\"link\"\n        [label]=\"translate.instant('platform.filter_service.cancel')\"\n        (clicked)=\"close()\"\n      ></s-button>\n      <s-button\n        *ngIf=\"isMobile\"\n        priority=\"default\"\n        [label]=\"translate.instant('platform.filter_service.actions')\"\n        [auxiliary]=\"true\"\n        [menuOptions]=\"mobileButtonActions\"\n      ></s-button>\n      <ng-container *ngIf=\"!isMobile\">\n        <s-button\n          priority=\"secondary\"\n          [label]=\"translate.instant('platform.filter_service.clear')\"\n          (clicked)=\"clearFilters()\"\n        ></s-button>\n        <s-button\n          priority=\"secondary\"\n          [label]=\"translate.instant('platform.filter_service.save')\"\n          (clicked)=\"saveFilters()\"\n        ></s-button>\n      </ng-container>\n      <s-button\n        type=\"submit\"\n        priority=\"primary\"\n        [label]=\"translate.instant('platform.filter_service.filter')\"\n        (clicked)=\"onApplyFilters()\"\n      ></s-button>\n    </div>\n  </div>\n</section>\n\n<p-dialog\n  *ngIf=\"!onlyContent\"\n  appendTo=\"body\"\n  styleClass=\"filter-dialog\"\n  [draggable]=\"false\"\n  [modal]=\"true\"\n  [(visible)]=\"showDialog\"\n  [blockScroll]=\"true\"\n  [closable]=\"false\"\n>\n  <ng-template pTemplate=\"header\">\n    <div class=\"w-full flex items-center justify-between\">\n      <span>{{ 'platform.filter_service.filters' | translate }}</span>\n      <span\n        (click)=\"toggleDialog(); close()\"\n        (keypress)=\"toggleDialog(); close()\"\n        class=\"close_btn pi pi-times cursor-pointer\">\n      </span>\n    </div>\n  </ng-template>\n\n  <s-app-form-filter\n    [showMessages]=\"true\"\n    (errorOutput)=\"onError($event)\"\n    (totalFiltersActiveOutput)=\"updateTotalFiltersActive($event)\"\n    [isModal]=\"true\"\n    [contextId]=\"contextId\"\n  ></s-app-form-filter>\n\n    <ng-template pTemplate=\"footer\">\n      <ng-container *ngIf=\"!error && !hideButtons\">\n        <s-button\n          type=\"submit\"\n          priority=\"primary\"\n          [label]=\"translate.instant('platform.filter_service.filter')\"\n          (clicked)=\"applyFilters()\"\n        ></s-button>\n        <ng-container *ngIf=\"!isMobile\">\n          <s-button\n            priority=\"secondary\"\n            [label]=\"translate.instant('platform.filter_service.save')\"\n            (clicked)=\"saveFilters()\"\n          ></s-button>\n          <s-button\n            priority=\"secondary\"\n            [label]=\"translate.instant('platform.filter_service.clear')\"\n            (clicked)=\"clearFilters()\"\n          ></s-button>\n        </ng-container>\n        <s-button\n          *ngIf=\"isMobile\"\n          priority=\"default\"\n          [label]=\"translate.instant('platform.filter_service.actions')\"\n          [auxiliary]=\"true\"\n          [menuOptions]=\"mobileButtonActions\"\n        ></s-button>\n        <s-button\n          priority=\"link\"\n          [label]=\"translate.instant('platform.filter_service.cancel')\"\n          (clicked)=\"toggleDialog(); close()\"\n        ></s-button>\n      </ng-container>\n    </ng-template>\n</p-dialog>\n\n\n<p-toast key=\"filterServiceToastKey\" [baseZIndex]=\"5000\"></p-toast>\n", styles: [".custom-badge{position:absolute!important;right:-4px;top:-10px;height:20px;vertical-align:middle;display:table;min-width:22px}.filter-button{position:relative;border:solid 1px black;border-radius:1.5rem;background:transparent;padding:.5rem 1rem;cursor:pointer}.filter-dialog .ui-dialog-title{display:block!important;padding-right:0!important}.filter-footer{text-align:end;border-top:1px solid #e5eaea;padding:13px}.filter-dialog>.ui-dialog-content{height:300px;padding:10px!important}.app-form-filter{height:335px;max-height:335px;overflow:auto}.only-content-wrapper{background-color:#fff}.close_btn{align-content:center;justify-self:right;margin-left:auto}.close_btn:hover{cursor:pointer}.header{text-transform:uppercase;display:flex;width:100%;border-bottom:1px solid #e5eaea;padding:15px;margin-left:0}@media (min-width: 641px) and (max-width: 1024px){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:300px}}@media only screen and (min-device-width: 481px) and (max-device-width: 1024px) and (orientation: portrait){.filter-dialog{width:75%}.filter-dialog>.ui-dialog-content{height:90%}}@media (min-width: 320px) and (max-width: 640px){.filter-dialog{width:95%;left:0;top:0;opacity:1;margin:auto;height:93%}.filter-dialog>.ui-dialog-content{height:85%}}@media (min-width: 320px) and (max-width: 640px) and (max-width: 360px){.filter-dialog button{padding:0!important}.filter-dialog>.ui-dialog-content{height:81%}}\n"] }]
+        }], propDecorators: { labelButton: [{
+                type: Input
+            }], onlyContent: [{
+                type: Input
+            }], hideButtons: [{
+                type: Input
+            }], canOpenFilter: [{
+                type: Input
+            }], showActiveFiltersCountBadge: [{
+                type: Input
+            }], filterAndSave: [{
+                type: Input
+            }], contextId: [{
+                type: Input
+            }], modalComponent: [{
+                type: ViewChild,
+                args: [FormFilterComponent]
+            }], onResizeWindow: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+
+class AppRoutingModule {
+}
+class AdvancedFilterModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterModule, declarations: [AdvancedFilterComponent, FormFilterComponent, MapValuesPipe, TranslatePipe$1], imports: [DialogModule,
+            ButtonModule,
+            ButtonModule$1,
+            TabViewModule,
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            DynamicFormModule,
+            ToastModule,
+            EmptyStateModule,
+            TooltipModule, TranslationsModule], exports: [AdvancedFilterComponent, FormFilterComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterModule, providers: [AdvancedFilterService, LocaleService, MessageService, TranslateService, CalendarOptionsService], imports: [DialogModule,
+            ButtonModule,
+            ButtonModule$1,
+            TabViewModule,
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            DynamicFormModule,
+            ToastModule,
+            EmptyStateModule,
+            TooltipModule,
+            TranslationsModule.forChild([{ domain: 'platform', service: 'filter_service', fallback: fallback$1 }])] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AdvancedFilterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        DialogModule,
+                        ButtonModule,
+                        ButtonModule$1,
+                        TabViewModule,
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        DynamicFormModule,
+                        ToastModule,
+                        EmptyStateModule,
+                        TooltipModule,
+                        TranslationsModule.forChild([{ domain: 'platform', service: 'filter_service', fallback: fallback$1 }]),
+                    ],
+                    providers: [AdvancedFilterService, LocaleService, MessageService, TranslateService, CalendarOptionsService],
+                    declarations: [AdvancedFilterComponent, FormFilterComponent, MapValuesPipe, TranslatePipe$1],
+                    exports: [AdvancedFilterComponent, FormFilterComponent]
+                }]
+        }] });
+
+class CyclicJsonInterceptor {
+    intercept(req, next) {
+        if (req.body instanceof Blob === false && req.body instanceof FormData === false) {
+            req = req.clone({ body: jc.decycle(req.body) });
+        }
+        return next.handle(req).pipe(map((event) => {
+            if (event instanceof HttpResponse) {
+                event = event.clone({ body: jc.retrocycle(event.body) });
+            }
+            return event;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CyclicJsonInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CyclicJsonInterceptor, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CyclicJsonInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CyclicJsonInterceptorModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CyclicJsonInterceptorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: CyclicJsonInterceptorModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CyclicJsonInterceptorModule, providers: [{ provide: HTTP_INTERCEPTORS, useClass: CyclicJsonInterceptor, multi: true }, provideHttpClient(withInterceptorsFromDi())] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CyclicJsonInterceptorModule, decorators: [{
+            type: NgModule,
+            args: [{ imports: [], providers: [{ provide: HTTP_INTERCEPTORS, useClass: CyclicJsonInterceptor, multi: true }, provideHttpClient(withInterceptorsFromDi())] }]
+        }] });
+
+class RestUrl {
+    get() {
+        return defer(() => from(service.getRestUrl()));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RestUrl, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RestUrl });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: RestUrl, decorators: [{
+            type: Injectable
+        }] });
+
+class XServicesUrl {
+    get() {
+        return defer(() => {
+            const url = service.getXServicesUrl();
+            return from(url);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: XServicesUrl, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: XServicesUrl });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: XServicesUrl, decorators: [{
+            type: Injectable
+        }] });
+
+class HttpInterceptor {
+    restUrl = inject(RestUrl);
+    xServicesUrl = inject(XServicesUrl);
+    intercept(originalReq, next) {
+        if (!originalReq.url.includes(`://`)) {
+            const getAuthHeader = defer(() => from(user.getAuthHeader()));
+            if (/^\/?[^\/]+\/[^\/]+\/api\/(?:latest|v\d+)\/.+$/g.test(originalReq.url)) {
+                const getXServicesUrl = this.xServicesUrl.get();
+                return forkJoin([getXServicesUrl, getAuthHeader]).pipe(mergeMap((values) => {
+                    const [xUrl, authHeader] = values;
+                    return this.injectBaseUrl(originalReq, next, xUrl, authHeader);
+                }));
+            }
+            const getRestUrl = this.restUrl.get();
+            return forkJoin([getRestUrl, getAuthHeader]).pipe(mergeMap((values) => {
+                const [bridgeUrl, authHeader] = values;
+                return this.injectBaseUrl(originalReq, next, bridgeUrl, authHeader);
+            }));
+        }
+        return next.handle(originalReq);
+    }
+    injectBaseUrl(originalReq, next, baseUrl, authorization) {
+        const request = originalReq.clone({
+            url: baseUrl + originalReq.url,
+            headers: originalReq.headers.set(`Authorization`, authorization)
+        });
+        return next.handle(request);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpInterceptor, decorators: [{
+            type: Injectable
+        }] });
+
+class HttpInterceptorModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpInterceptorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: HttpInterceptorModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpInterceptorModule, providers: [RestUrl, XServicesUrl, { provide: HTTP_INTERCEPTORS, useClass: HttpInterceptor, multi: true }, provideHttpClient(withInterceptorsFromDi())] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpInterceptorModule, decorators: [{
+            type: NgModule,
+            args: [{ imports: [], providers: [RestUrl, XServicesUrl, { provide: HTTP_INTERCEPTORS, useClass: HttpInterceptor, multi: true }, provideHttpClient(withInterceptorsFromDi())] }]
+        }] });
+
+const RESOURCES = new InjectionToken('RESOURCES');
+const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
+class Resource {
+    name;
+    actions;
+    uri;
+    redirectToError = false;
+    actionsToCheck;
+    entity;
+}
+class Environment {
+    domain;
+    service;
+    ignorePermissions;
+}
+
+let promise;
+class PermissionsService {
+    resources = inject(RESOURCES);
+    environment = inject(ENVIRONMENT);
+    http = inject(HttpClient);
+    router = inject(Router);
+    toastService = inject(ToastService);
+    translate = inject(TranslateService);
+    checkedPermissions = {};
+    actionUrl = 'platform/authorization/queries';
+    // v2
+    checkAccess(resources) {
+        const permissions = [];
+        resources.forEach(rec => {
+            rec.actions.forEach(action => {
+                if (!rec.uri) {
+                    rec.uri = this.getUriByResourceName(rec.name, rec.entity);
+                }
+                permissions.push({ action, resource: rec.uri });
+            });
+        });
+        return this.http.post(`${this.actionUrl}/checkAccess`, { includeFilters: true, permissions }).pipe(map((response) => {
+            const checkedPermissions = response.permissions || response;
+            this.checkedPermissions = { ...this.checkedPermissions, ...checkedPermissions };
+            const values = {};
+            if (this.shouldRedirectToForbiddenPage(resources, checkedPermissions)) {
+                this.router.navigate(['error', 403]);
+                return throwError(() => new Error('forbidden'));
+            }
+            checkedPermissions.forEach((permission) => {
+                const resource = resources.find(res => res.uri === permission.resource);
+                if (!resource) {
+                    return;
+                }
+                const { name } = resource;
+                values[name] = values[name] || {};
+                values[name][permission.action] = permission.authorized;
+                values[name][permission.action.toLowerCase()] = permission.authorized;
+                if (permission.resourceFilters?.length) {
+                    values[name]['resourceFilters'] = [
+                        ...(values[name]['resourceFilters'] || []),
+                        ...permission.resourceFilters
+                    ];
+                }
+            });
+            return values;
+        }));
+    }
+    // v1
+    get(resource = '') {
+        if (!promise) {
+            promise = this.getPermissions();
+        }
+        return from(promise).pipe(map((permissions) => {
+            this.checkedPermissions = permissions;
+            if (resource) {
+                const resourceKey = Object.keys(permissions)
+                    .find(key => key.toLowerCase() === resource.toLowerCase());
+                return permissions[resourceKey];
+            }
+            return permissions;
+        }), catchError(() => {
+            promise = undefined;
+            this.toastService.show({
+                severity: 'error',
+                title: this.translate.instant('permission_error_summary'),
+                text: this.translate.instant('permission_error_detail')
+            });
+            return of(this.getPermissionObject(false));
+        }));
+    }
+    isAuthorized(resourceName, action, isEntity) {
+        if (!this.checkedPermissions || Object.keys(this.checkedPermissions).length === 0) {
+            throwError(() => new Error('\'Permissions\' are not defined. You should call \'get\' or \'checkAccess\' method first.'));
+        }
+        const resourceKey = Object.keys(this.checkedPermissions)
+            .find(key => key.toLowerCase() === resourceName.toLowerCase());
+        if (!resourceKey) {
+            return false;
+        }
+        const actions = this.checkedPermissions[resourceKey];
+        return actions?.[action] ?? actions?.[action.toLowerCase()] ?? false;
+    }
+    getUriByResourceName(resourceName, isEntity) {
+        const { domain, service } = this.environment;
+        if (!domain || !service) {
+            throwError(() => new Error('You must inform domain and service name'));
+        }
+        const uriBase = `res://senior.com.br/${domain}/${service}`;
+        return isEntity ? `${uriBase}/entities/${resourceName}` : `${uriBase}/${resourceName}`;
+    }
+    shouldRedirectToForbiddenPage(resources = [], permissions) {
+        const permissionsDenied = permissions.filter(perm => !perm.authorized);
+        if (permissionsDenied.length) {
+            const resourcesToCheck = resources.filter(r => r.redirectToError);
+            if (resourcesToCheck.length) {
+                return resourcesToCheck.every(resource => {
+                    const actionsToCheck = resource.actionsToCheck?.length ? resource.actionsToCheck : resource.actions;
+                    return actionsToCheck.every(action => permissionsDenied.some(p => p.resource === resource.uri && p.action === action));
+                });
+            }
+        }
+        return false;
+    }
+    getFlatEnvironment() {
+        return this.environment.ignorePermissions;
+    }
+    getFlatResources() {
+        return this.resources.reduce((result, item) => {
+            if (!item) {
+                return result;
+            }
+            return Array.isArray(item) ? [...result, ...item] : [...result, item];
+        }, []);
+    }
+    getPermissionObject(defaultValue) {
+        return this.getFlatResources().reduce((resources, resource) => {
+            resources[resource.name] = resource.actions.reduce((actions, action) => {
+                actions[action] = defaultValue;
+                actions[action.toLowerCase()] = defaultValue;
+                return actions;
+            }, {});
+            return resources;
+        }, {});
+    }
+    async getPermissions() {
+        if (this.getFlatEnvironment()) {
+            return this.getPermissionObject(true);
+        }
+        const resources = this.getFlatResources();
+        const perm = resources
+            .map(resource => resource.actions.map((action) => ({ action, resource: resource.uri })))
+            .reduce((acc, val) => [...acc, ...val]);
+        const response = await this.http
+            .post(`${this.actionUrl}/checkAccess`, { includeFilters: false, permissions: perm })
+            .toPromise();
+        const permissions = response.permissions ?? response;
+        const values = {};
+        permissions.forEach((permission) => {
+            const resource = resources.find((res) => res.uri === permission.resource);
+            if (!resource) {
+                return;
+            }
+            const { name } = resource;
+            values[name] = values[name] || {};
+            values[name][permission.action] = permission.authorized;
+            values[name][permission.action.toLowerCase()] = permission.authorized;
+        });
+        return values;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class PermissionsModule {
+    static forRoot(resources, environment) {
+        return {
+            ngModule: PermissionsModule,
+            providers: [
+                PermissionsService,
+                {
+                    provide: RESOURCES,
+                    multi: true,
+                    useValue: resources
+                },
+                {
+                    provide: ENVIRONMENT,
+                    multi: false,
+                    useValue: environment
+                }
+            ]
+        };
+    }
+    static forChild(resources) {
+        return {
+            ngModule: PermissionsModule,
+            providers: [
+                {
+                    provide: RESOURCES,
+                    multi: true,
+                    useValue: resources
+                }
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule, decorators: [{
+            type: NgModule
+        }] });
+
+function ResourceFactory({ domain, service, resource }) {
+    return `res://senior.com.br/${domain}/${service}/${resource}`;
+}
+function endpointFactoryFunction(domain, service) {
+    // The @seniorsistemas/platform-components http interceptor is handling the base url portion of the final URL
+    const create = (method, endpoint) => `${domain}/${service}/${method}/${endpoint}`;
+    const resource = (resource) => ResourceFactory({ domain, service, resource });
+    return {
+        resource,
+        query: create.bind(null, 'queries'),
+        action: create.bind(null, 'actions'),
+        signal: create.bind(null, 'signals'),
+        entity(entity) {
+            const URL = create('entities', entity);
+            return {
+                create: () => URL,
+                update: (id) => URL + '/' + id,
+                remove: (id) => URL + '/' + id
+            };
+        }
+    };
+}
+const endpointFactory = endpointFactoryFunction;
+// ADD HERE YOUR NEW ENDPOINT
+const PLATFORM_FEATURE_TOGGLE = endpointFactoryFunction('platform', 'feature_toggle');
+
+class FeatureToggleService {
+    http = inject(HttpClient);
+    cache = {};
+    isEnabled({ domain, service, name }, tenant) {
+        let tenantObs;
+        if (tenant) {
+            tenantObs = of(tenant);
+        }
+        else {
+            tenantObs = from(user.getUserData()).pipe(map(userData => userData.tenantName));
+        }
+        return tenantObs.pipe(mergeMap(tenant => {
+            const key = JSON.stringify({ tenant, domain, service });
+            if (!this.cache[key]) {
+                this.cache[key] = this.http
+                    .post(PLATFORM_FEATURE_TOGGLE.query('getEnabledFeatures'), { tenant, domain, service })
+                    .pipe(map(output => output.features), shareReplay(1), catchError(err => {
+                    console.error(err);
+                    delete this.cache[key];
+                    return of([]);
+                }));
+            }
+            return this.cache[key];
+        }), map((features) => {
+            return features.findIndex(f => f.name === name) !== -1;
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureToggleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureToggleService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureToggleService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class FeatureToggleModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureToggleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: FeatureToggleModule, imports: [HttpInterceptorModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureToggleModule, providers: [FeatureToggleService, provideHttpClient(withInterceptorsFromDi())], imports: [HttpInterceptorModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FeatureToggleModule, decorators: [{
+            type: NgModule,
+            args: [{ imports: [HttpInterceptorModule], providers: [FeatureToggleService, provideHttpClient(withInterceptorsFromDi())] }]
+        }] });
+
+var UserAction;
+(function (UserAction) {
+    UserAction["CONFIRMED"] = "CONFIRMED";
+    UserAction["POSTPONED"] = "POSTPONED";
+    UserAction["REFUSED"] = "REFUSED";
+})(UserAction || (UserAction = {}));
+
+class SpotlightService {
+    http = inject(HttpClient);
+    API_URL = 'platform/spotlight/';
+    getUser() {
+        return this.http.post('platform/user/queries/getUser', {}).toPromise();
+    }
+    listSpotlightScreen() {
+        return this.http.get(this.API_URL + 'queries/listSpotlightScreen');
+    }
+    listSpotlightUsers() {
+        return this.http.get(this.API_URL + 'queries/listSpotlightUsers').toPromise();
+    }
+    listSpotlightControl() {
+        return this.http.get(this.API_URL + 'queries/listSpotlightControl').toPromise();
+    }
+    saveSpotlightUser(content) {
+        return this.http.post(this.API_URL + 'actions/saveSpotlightUsers', { content });
+    }
+    saveSpotlightControl(content) {
+        return this.http.post(this.API_URL + 'actions/saveSpotlightControl', { content });
+    }
+    notificateSpotlight(content) {
+        return this.http.post(this.API_URL + 'actions/notificateSpotlight', content);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightService, decorators: [{
+            type: Injectable
+        }] });
+
+var EnumDisplayType;
+(function (EnumDisplayType) {
+    EnumDisplayType["ADVERSITING"] = "ADVERSITING";
+    EnumDisplayType["INTEGRATION"] = "INTEGRATION";
+})(EnumDisplayType || (EnumDisplayType = {}));
+
+class SpotlightControl {
+    id;
+    spotlightId;
+    status;
+    firstUser;
+    createdBy;
+    createdDate;
+    lastModifiedBy;
+    lastModifiedDate;
+}
+
+var EnumSpotlightStatus;
+(function (EnumSpotlightStatus) {
+    EnumSpotlightStatus["ACTIVE"] = "ACTIVE";
+    EnumSpotlightStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    EnumSpotlightStatus["NO_STARTED"] = "NO_STARTED";
+    EnumSpotlightStatus["REFUSED"] = "REFUSED";
+})(EnumSpotlightStatus || (EnumSpotlightStatus = {}));
+
+class TranslatePipe {
+    translationService = inject(TranslateService);
+    transform(value) {
+        return this.translationService.instant(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, name: "translate", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'translate',
+                    pure: false,
+                }]
+        }] });
+
+class SpotlightComponent {
+    spotlightService = inject(SpotlightService);
+    cookieService = inject(CookieService);
+    datePipe = inject(DatePipe);
+    header;
+    imgUrl;
+    primaryButtonLabel;
+    primaryButtonTooltip;
+    canAppear = false;
+    currentUser;
+    spotlightUsersList;
+    spotlightControlsList;
+    spotlightScreen;
+    canEmitEvent;
+    visible = false;
+    menuId;
+    fade = false;
+    visibleChange = new EventEmitter();
+    async ngOnInit() {
+        await this.setValues();
+        this.fetchSpotlight();
+    }
+    async setValues() {
+        const userData = JSON.parse(this.cookieService.get('com.senior.token'));
+        this.currentUser = userData.username;
+        this.spotlightUsersList = await this.spotlightService.listSpotlightUsers();
+        this.spotlightControlsList = await this.spotlightService.listSpotlightControl();
+    }
+    setValuesInSpotlight(values) {
+        this.header = values.spotlightTitle;
+        this.imgUrl = values.bannerUrl;
+        this.primaryButtonLabel = values.primaryButtonLabel;
+        this.primaryButtonTooltip = values.primaryButtonHint;
+    }
+    getShowDate(days) {
+        const currentDate = new Date();
+        return this.datePipe.transform(currentDate.setDate(currentDate.getDate() + days).toString(), 'yyyy-MM-dd');
+    }
+    fetchSpotlight() {
+        this.spotlightService.listSpotlightScreen().subscribe(value => {
+            this.spotlightScreen = value.contents.filter(val => val.screenMenuId === this.menuId)[0];
+            if (this.spotlightScreen) {
+                this.showSpotlight(this.spotlightScreen.spotlight);
+            }
+        });
+    }
+    showSpotlight(spotlight) {
+        if (this.validateDate(spotlight.initialDate) && this.validateFinalDate(spotlight.finalDate) && this.validateSpotlight(spotlight)) {
+            this.setValuesInSpotlight(spotlight);
+            this.canAppear = true;
+            const control = this.getSpotlightControlFromList(this.spotlightScreen.spotlight.id);
+            this.canEmitEvent = !control || this.currentUser !== control.firstUser;
+        }
+    }
+    validateDate(date) {
+        if (date) {
+            const currentDate = this.datePipe.transform(new Date().toString(), 'yyyy-MM-dd');
+            const initialDate = this.datePipe.transform(date, 'yyyy-MM-dd');
+            return currentDate >= initialDate;
+        }
+        return false;
+    }
+    validateFinalDate(date) {
+        if (date) {
+            const currentDate = this.datePipe.transform(new Date().toString(), 'yyyy-MM-dd');
+            const finalDate = this.datePipe.transform(date, 'yyyy-MM-dd');
+            return currentDate <= finalDate;
+        }
+        return true;
+    }
+    validateSpotlight(spotlight) {
+        if (!this.validateControlsList(this.spotlightControlsList, spotlight, this.currentUser)) {
+            return false;
+        }
+        if (!this.validateDisplayType(spotlight, this.spotlightUsersList, this.spotlightControlsList, this.currentUser)) {
+            return false;
+        }
+        return true;
+    }
+    validateControlsList(controlsList, spotlight, currentUser) {
+        if (controlsList.totalElements) {
+            const notCompatibleControls = controlsList.contents.filter(control => {
+                if (control.status === EnumSpotlightStatus.ACTIVE) {
+                    return control.spotlightId === spotlight.id;
+                }
+                else if (control.status === EnumSpotlightStatus.IN_PROGRESS) {
+                    return control.spotlightId === spotlight.id && control.firstUser !== currentUser;
+                }
+            });
+            if (notCompatibleControls.length > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    validateDisplayType(spotlight, usersList, controlsList, currentUser) {
+        switch (spotlight.displayType) {
+            case EnumDisplayType.ADVERSITING:
+                return usersList.totalElements ? this.validateUser(usersList.contents, spotlight) : true;
+            case EnumDisplayType.INTEGRATION:
+                if (controlsList.totalElements) {
+                    const compatibleControls = controlsList.contents.filter(control => {
+                        switch (control.status) {
+                            case EnumSpotlightStatus.NO_STARTED:
+                                return control.spotlightId === spotlight.id;
+                            case EnumSpotlightStatus.REFUSED:
+                                return usersList.totalElements ? this.validateUser(usersList.contents, spotlight) : true;
+                            case EnumSpotlightStatus.IN_PROGRESS:
+                                return control.firstUser === currentUser
+                                    && control.spotlightId === spotlight.id;
+                        }
+                    });
+                    if (compatibleControls.length === 0) {
+                        return false;
+                    }
+                }
+                return true;
+        }
+    }
+    validateUser(users, spotlight) {
+        let spotlightUsers = users.filter(user => user.spotlightId === spotlight.id);
+        if (!spotlightUsers.length) {
+            spotlightUsers = users.filter(user => user.userOperation === this.currentUser);
+            return spotlightUsers.length === 0;
+        }
+        const compatibleUserToValidate = spotlightUsers.filter(user => user.userOperation === this.currentUser)[0];
+        return compatibleUserToValidate ? this.validateDate(compatibleUserToValidate.showDate) : true;
+    }
+    saveSpotlightUser(days) {
+        const spotlight = this.spotlightScreen.spotlight;
+        const user = this.spotlightUsersList.contents.filter(val => {
+            return val.spotlightId === spotlight.id
+                && val.userOperation === this.currentUser;
+        })[0];
+        let spotlightUser = {
+            spotlightId: spotlight.id,
+            showDate: days ? this.getShowDate(days) : null,
+            userOperation: this.currentUser
+        };
+        if (user) {
+            spotlightUser = {
+                id: user.id,
+                ...spotlightUser
+            };
+        }
+        this.spotlightService.saveSpotlightUser(spotlightUser).subscribe();
+    }
+    onPrimary() {
+        const spotlight = this.spotlightScreen.spotlight;
+        const notification = this.buildNotification(UserAction.CONFIRMED);
+        this.saveSpotlightControl();
+        this.saveSpotlightUser();
+        if (this.canEmitEvent) {
+            this.spotlightService.notificateSpotlight(notification).subscribe();
+        }
+        if (spotlight.primaryButtonUrl) {
+            window.open(spotlight.primaryButtonUrl);
+        }
+        this.close();
+    }
+    onSecondary() {
+        const notification = this.buildNotification(UserAction.POSTPONED);
+        this.saveSpotlightControl(EnumSpotlightStatus.REFUSED);
+        this.saveSpotlightUser(this.spotlightScreen.spotlight.daysRememberLate);
+        this.spotlightService.notificateSpotlight(notification).subscribe();
+        this.close();
+    }
+    onTertiary() {
+        const notification = this.buildNotification(UserAction.REFUSED);
+        this.saveSpotlightControl(EnumSpotlightStatus.REFUSED);
+        this.saveSpotlightUser(this.spotlightScreen.spotlight.daysNotInterested);
+        this.spotlightService.notificateSpotlight(notification).subscribe();
+        this.close();
+    }
+    /**
+     * Verifica se um registro de usuário pertence ao usuário logado e corresponde ao spotlight atual
+     * @param user SpotlightUser Objeto representando o registro do usuário para uma spotlight
+     * @param spotlight Spotlight Spotlight
+     * @returns boolean true se corresponder ao spotlight atual, false caso contrário
+     */
+    hasThisRegister(user, spotlight) {
+        return (user.spotlightId === spotlight.id && user.userOperation === this.currentUser);
+    }
+    /**
+     * Verifica se um registro de usuário pertece ao usuário logado, mas não corresponde ao spotlight atual
+     * @param user SpotlightUser Objeto representando o registro do usuário para uma spotlight
+     * @param spotlight Spotlight Spotlight
+     * @returns boolean true se corresponder ao spotlight atual, false caso contrário
+     */
+    hasAnotherRegister(user, spotlight) {
+        return user.spotlightId !== spotlight.id && user.userOperation === this.currentUser;
+    }
+    /**
+     * Persiste um novo registro de controle para o spotlight atual se
+     * não for encontrado nenhum na lista de controles carregada inicialmente
+     * @param status EnumSpotlightStatus Status do controle do spotlight. Se nenhum for informado, IN_PROGRESS será aplicado
+     * @returns SpotlightControl Controle do spotlight recuperado/pesistido
+     */
+    saveSpotlightControl(status = EnumSpotlightStatus.IN_PROGRESS) {
+        const spotlight = this.spotlightScreen.spotlight;
+        let control = this.getSpotlightControlFromList(spotlight.id);
+        if (!control) {
+            control = {
+                spotlightId: spotlight.id,
+                status: status,
+                firstUser: this.currentUser
+            };
+        }
+        if (this.isNewControl(control) || control.status !== EnumSpotlightStatus.IN_PROGRESS) {
+            control.status = status;
+            control.firstUser = status === EnumSpotlightStatus.IN_PROGRESS ? this.currentUser : '';
+            this.spotlightService.saveSpotlightControl(control).subscribe();
+        }
+        return control;
+    }
+    /**
+     * Retorna o controle de spotlight correspondente ao identificador
+     * informado na lista de controles carregada na inicialização do componente
+     * @param id string Identificador do controle de spotlight
+     */
+    getSpotlightControlFromList(id) {
+        return this.spotlightControlsList.contents.filter(val => val.spotlightId === id)[0];
+    }
+    /**
+     * Verifica se o controle de spotlight informado não foi registrado ainda
+     * @param spotlightControl SpotlightControl Controle do spotlight
+     * @returns boolean true se ainda não foi registrado na base, false caso contrário
+     */
+    isNewControl(spotlightControl) {
+        return !this.spotlightControlsList.contents.includes(spotlightControl);
+    }
+    /**
+     * Retorna um objeto de notificação referente ao botão clicado pelo usuário.
+     * @param userAction UserAction Ação realizada pelo usuário ao clicar nos botões da modal
+     * @returns SpotlightNotification Objeto de notificação
+     */
+    buildNotification(userAction) {
+        const spotlight = this.spotlightScreen.spotlight;
+        return {
+            clickedButton: userAction,
+            spotlightControlId: spotlight.id,
+            primaryButtonUrl: spotlight.primaryButtonUrl
+        };
+    }
+    close() {
+        this.visibleChange.emit(false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SpotlightComponent, selector: "s-spotlight", inputs: { visible: "visible", menuId: "menuId", fade: "fade" }, outputs: { visibleChange: "visibleChange" }, ngImport: i0, template: "<div class=\"s-spotlight-overlay\" id=\"ol\" *ngIf=\"canAppear && visible\">\n    <div class=\"s-spotlight\" id=\"sl\" [ngClass]=\"{'s-effect-fadein': fade}\">\n        <div class=\"s-spotlight-header\">\n            <span class=\"s-spotlight-title\">{{header.toUpperCase()}}</span>\n            <a role=\"button\" class=\"s-spotlight-close\" (click)=\"close()\"><span class=\"fa fa-times\" aria-hidden=\"true\"></span></a>\n        </div>\n        <div class=\"s-img\">\n            <img src=\"{{imgUrl}}\">\n        </div>\n        <div class=\"s-spotlight-footer\">\n            <div class=\"s-spotlight-footer-left\">\n                <button\n                    pButton\n                    type=\"submit\"\n                    id=\"decline-button\"\n                    label=\"{{'platform.spotlight.no_interest' | translate}}\"\n                    (click)=\"onTertiary()\"\n                    class=\"ui-button-link\">\n                </button>\n            </div>\n            <div class=\"s-spotlight-footer-right\">\n                <button\n                pButton\n                type=\"submit\"\n                id=\"remember-button\"\n                label=\"{{'platform.spotlight.remember_late' | translate}}\"\n                (click)=\"onSecondary()\"\n                class=\"ui-button-raised ui-button-secondary\">\n            </button>\n            <button\n                pButton\n                label=\"{{primaryButtonLabel}}\"\n                type=\"submit\"\n                id=\"submit-button\"\n                (click)=\"onPrimary()\"\n                [pTooltip]=\"primaryButtonTooltip\"\n                tooltipPosition=\"top\"\n                showDelay=\"500\"\n                class=\"ui-button-raised\">\n            </button>\n        </div>\n    </div>\n</div>\n</div>", styles: [".s-spotlight-overlay{display:flex;position:fixed;z-index:10;left:0;top:0;width:100%;height:100%;overflow:auto;background-color:#000;background-color:#0006}.s-spotlight{border-radius:3px;background:#fff;margin:auto;overflow:hidden;animation:move .15s forwards}.s-spotlight-header,.s-spotlight-footer{display:flex;padding:15px}.s-spotlight-header{align-items:center;justify-content:space-between}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{display:flex}.s-spotlight-footer-right{flex:2;justify-content:flex-end}.s-spotlight-footer-left{flex:1;justify-content:flex-start}.s-spotlight-title{font-family:Open Sans,sans-serif;font-size:16px;font-weight:400;color:#333}.s-spotlight-close{display:block;margin-left:15px;color:#000}.s-img{width:100%;display:flex;align-items:center;justify-content:center}.s-img img{width:100%}.s-effect-fadein{animation:fade .15s forwards}@keyframes fade{0%{opacity:0}to{opacity:1}}@media (max-width: 595px){.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{align-items:center;flex-direction:column-reverse}.s-spotlight-footer button{margin:0 0 15px!important;width:100%!important}}@media (min-width: 576px){.s-spotlight{width:100%}}@media (min-width: 768px){.s-spotlight{width:720px}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{flex-direction:row}}@media (min-width: 992px){.s-spotlight{width:960px}}@media (min-width: 1200px){.s-spotlight{width:50%}}\n"], dependencies: [{ kind: "directive", type: i1$3.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain", "fluid", "label", "icon", "buttonProps"] }, { kind: "directive", type: i2$2.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-spotlight', template: "<div class=\"s-spotlight-overlay\" id=\"ol\" *ngIf=\"canAppear && visible\">\n    <div class=\"s-spotlight\" id=\"sl\" [ngClass]=\"{'s-effect-fadein': fade}\">\n        <div class=\"s-spotlight-header\">\n            <span class=\"s-spotlight-title\">{{header.toUpperCase()}}</span>\n            <a role=\"button\" class=\"s-spotlight-close\" (click)=\"close()\"><span class=\"fa fa-times\" aria-hidden=\"true\"></span></a>\n        </div>\n        <div class=\"s-img\">\n            <img src=\"{{imgUrl}}\">\n        </div>\n        <div class=\"s-spotlight-footer\">\n            <div class=\"s-spotlight-footer-left\">\n                <button\n                    pButton\n                    type=\"submit\"\n                    id=\"decline-button\"\n                    label=\"{{'platform.spotlight.no_interest' | translate}}\"\n                    (click)=\"onTertiary()\"\n                    class=\"ui-button-link\">\n                </button>\n            </div>\n            <div class=\"s-spotlight-footer-right\">\n                <button\n                pButton\n                type=\"submit\"\n                id=\"remember-button\"\n                label=\"{{'platform.spotlight.remember_late' | translate}}\"\n                (click)=\"onSecondary()\"\n                class=\"ui-button-raised ui-button-secondary\">\n            </button>\n            <button\n                pButton\n                label=\"{{primaryButtonLabel}}\"\n                type=\"submit\"\n                id=\"submit-button\"\n                (click)=\"onPrimary()\"\n                [pTooltip]=\"primaryButtonTooltip\"\n                tooltipPosition=\"top\"\n                showDelay=\"500\"\n                class=\"ui-button-raised\">\n            </button>\n        </div>\n    </div>\n</div>\n</div>", styles: [".s-spotlight-overlay{display:flex;position:fixed;z-index:10;left:0;top:0;width:100%;height:100%;overflow:auto;background-color:#000;background-color:#0006}.s-spotlight{border-radius:3px;background:#fff;margin:auto;overflow:hidden;animation:move .15s forwards}.s-spotlight-header,.s-spotlight-footer{display:flex;padding:15px}.s-spotlight-header{align-items:center;justify-content:space-between}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{display:flex}.s-spotlight-footer-right{flex:2;justify-content:flex-end}.s-spotlight-footer-left{flex:1;justify-content:flex-start}.s-spotlight-title{font-family:Open Sans,sans-serif;font-size:16px;font-weight:400;color:#333}.s-spotlight-close{display:block;margin-left:15px;color:#000}.s-img{width:100%;display:flex;align-items:center;justify-content:center}.s-img img{width:100%}.s-effect-fadein{animation:fade .15s forwards}@keyframes fade{0%{opacity:0}to{opacity:1}}@media (max-width: 595px){.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{align-items:center;flex-direction:column-reverse}.s-spotlight-footer button{margin:0 0 15px!important;width:100%!important}}@media (min-width: 576px){.s-spotlight{width:100%}}@media (min-width: 768px){.s-spotlight{width:720px}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{flex-direction:row}}@media (min-width: 992px){.s-spotlight{width:960px}}@media (min-width: 1200px){.s-spotlight{width:50%}}\n"] }]
+        }], propDecorators: { visible: [{
+                type: Input
+            }], menuId: [{
+                type: Input
+            }], fade: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }] } });
+
+const fallback = {
+    'platform.spotlight.no_interest': 'Não tenho interesse',
+    'platform.spotlight.remember_late': 'Lembrar mais tarde'
+};
+
+class SpotlightModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: SpotlightModule, declarations: [SpotlightComponent,
+            TranslatePipe], imports: [ButtonModule$1,
+            TooltipModule,
+            CommonModule,
+            HttpInterceptorModule, TranslationsModule], exports: [SpotlightComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightModule, providers: [
+            SpotlightService,
+            DatePipe,
+            CookieService
+        ], imports: [ButtonModule$1,
+            TooltipModule,
+            CommonModule,
+            HttpInterceptorModule,
+            TranslationsModule.forChild([{ domain: 'platform', service: 'spotlight', fallback }])] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        ButtonModule$1,
+                        TooltipModule,
+                        CommonModule,
+                        HttpInterceptorModule,
+                        TranslationsModule.forChild([{ domain: 'platform', service: 'spotlight', fallback }]),
+                    ],
+                    providers: [
+                        SpotlightService,
+                        DatePipe,
+                        CookieService
+                    ],
+                    declarations: [
+                        SpotlightComponent,
+                        TranslatePipe
+                    ],
+                    exports: [SpotlightComponent]
+                }]
+        }] });
+
+/// <reference path="./json-cycle.d.ts" />
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AdvancedFilterComponent, AdvancedFilterModule, AdvancedFilterService, AppRoutingModule, CyclicJsonInterceptorModule, FeatureToggleModule, FeatureToggleService, Filter, FilterType, FormFilter, FormFilterComponent, HttpInterceptorModule, LENGTH_DEFAULT, PermissionsModule, PermissionsService, RestUrl, Scope, SpotlightComponent, SpotlightModule, TranslationsConfig, TranslationsModule, USER_INFO, XServicesUrl, factory, promise };
+//# sourceMappingURL=seniorsistemas-platform-components.mjs.map