@seniorsistemas/components-ai 0.0.0-master-d4a804fe

package/fesm2022/seniorsistemas-components-ai.mjs

@@ -0,0 +1,4006 @@
+import * as i0 from '@angular/core';
+import { NgModule, Injectable, Optional, Inject, EventEmitter, Component, Input, Output, Pipe, Directive, HostListener, ViewEncapsulation, inject } from '@angular/core';
+import * as i2 from '@angular/common';
+import { CommonModule, DOCUMENT } from '@angular/common';
+import * as i1 from '@angular/common/http';
+import { HttpParams } from '@angular/common/http';
+import { throwError, BehaviorSubject, of, from, concatMap, catchError as catchError$1 } from 'rxjs';
+import { catchError, map, filter } from 'rxjs/operators';
+import * as i2$1 from '@angular/forms';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import * as i3 from 'primeng/dialog';
+import { DialogModule } from 'primeng/dialog';
+import * as i5$1 from 'primeng/button';
+import { ButtonModule } from 'primeng/button';
+import * as i6 from 'primeng/radiobutton';
+import { RadioButtonModule } from 'primeng/radiobutton';
+import * as i7 from 'primeng/checkbox';
+import { CheckboxModule } from 'primeng/checkbox';
+import { DividerModule } from 'primeng/divider';
+import * as XLSX from 'xlsx';
+import { jsPDF } from 'jspdf';
+import autoTable from 'jspdf-autotable';
+import * as i5 from 'primeng/api';
+import * as i4 from 'primeng/progressbar';
+import { ProgressBarModule } from 'primeng/progressbar';
+import * as i5$2 from 'primeng/tag';
+import { TagModule } from 'primeng/tag';
+import * as i1$1 from '@angular/router';
+import { NavigationEnd, RouterModule, Router } from '@angular/router';
+import * as i2$2 from 'primeng/breadcrumb';
+import { BreadcrumbModule } from 'primeng/breadcrumb';
+import * as i4$2 from 'primeng/panel';
+import { PanelModule } from 'primeng/panel';
+import * as i7$1 from 'primeng/drawer';
+import { DrawerModule } from 'primeng/drawer';
+import * as i4$1 from 'primeng/inputtext';
+import { InputTextModule } from 'primeng/inputtext';
+import * as i3$1 from 'primeng/inputnumber';
+import { InputNumberModule } from 'primeng/inputnumber';
+import * as i3$2 from 'primeng/calendar';
+import { CalendarModule } from 'primeng/calendar';
+import * as i3$3 from 'primeng/dropdown';
+import { DropdownModule } from 'primeng/dropdown';
+import * as i8 from 'primeng/table';
+import { TableModule } from 'primeng/table';
+import * as i9 from 'primeng/tooltip';
+import { TooltipModule } from 'primeng/tooltip';
+import { InputTextarea } from 'primeng/inputtextarea';
+
+/**
+ * Módulo principal da biblioteca @seniorsistemas/components-ia
+ *
+ * Este módulo será populado conforme os componentes forem migrados.
+ * Por enquanto, é um módulo vazio para permitir o build inicial.
+ */
+class AngularComponentsModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AngularComponentsModule, imports: [CommonModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularComponentsModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AngularComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule
+                    ],
+                    exports: []
+                }]
+        }] });
+
+class EntityService {
+    http;
+    translationService;
+    queriesUrl = '';
+    constructor(http, translationService) {
+        this.http = http;
+        this.translationService = translationService;
+        // Initialize queriesUrl in ngOnInit or a separate method
+        // since abstract properties can't be accessed in constructor
+    }
+    /**
+     * Initialize the service - call this after setting actionsUrl
+     */
+    initializeService() {
+        this.queriesUrl = this.actionsUrl.replace('actions', 'queries');
+    }
+    /**
+     * Convert ListParams to HttpParams for GET requests
+     */
+    getListQueryParams(listParams) {
+        const { page = 0, size = 10, sort = [], filterQuery = '', displayFields = [] } = listParams;
+        let params = new HttpParams();
+        params = params.append('size', String(size));
+        params = params.append('offset', String(page));
+        if (sort && sort.length) {
+            const orderBy = sort
+                .map((s) => {
+                let order = '';
+                if (s.order === 1)
+                    order = ' asc';
+                else if (s.order === -1)
+                    order = ' desc';
+                return `${s.field}${order}`;
+            })
+                .join(', ');
+            params = params.append('orderby', orderBy);
+        }
+        if (filterQuery) {
+            params = params.append('filter', filterQuery);
+        }
+        if (displayFields && displayFields.length) {
+            params = params.append('displayfields', displayFields.join(','));
+        }
+        return params;
+    }
+    /**
+     * Convert ListParams to body parameters for POST requests
+     */
+    getBodyParams(listParams) {
+        const { page = 0, size = 10, sort = [], filterQuery = '', displayFields = [] } = listParams;
+        const bodyParams = {};
+        bodyParams.size = size;
+        bodyParams.offset = page;
+        if (sort && sort.length) {
+            bodyParams.orderBy = sort
+                .map((s) => {
+                let order = '';
+                if (s.order === 1)
+                    order = ' asc';
+                else if (s.order === -1)
+                    order = ' desc';
+                return `${s.field}${order}`;
+            })
+                .join(', ');
+        }
+        if (filterQuery) {
+            bodyParams.filter = filterQuery;
+        }
+        if (displayFields && displayFields.length) {
+            bodyParams.displayfields = displayFields.join(',');
+        }
+        return bodyParams;
+    }
+    /**
+     * Default error handler
+     */
+    handleError = (error) => {
+        let errorMessage = 'An error occurred';
+        if (this.translationService) {
+            errorMessage = this.translationService.translate('error.generic');
+        }
+        if (error.status) {
+            switch (error.status) {
+                case 401:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.unauthorized')
+                        : 'Unauthorized';
+                    break;
+                case 403:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.forbidden')
+                        : 'Forbidden';
+                    break;
+                case 404:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.not_found')
+                        : 'Not found';
+                    break;
+                case 500:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.server_error')
+                        : 'Server error';
+                    break;
+                default:
+                    if (error.error && error.error.message) {
+                        errorMessage = error.error.message;
+                    }
+                    else if (error.statusText) {
+                        errorMessage = error.statusText;
+                    }
+            }
+        }
+        else if (error.message) {
+            errorMessage = error.message;
+        }
+        console.error('EntityService Error:', error);
+        return throwError(() => new Error(errorMessage));
+    };
+    /**
+     * List entities with pagination, sorting, and filtering
+     */
+    list(listParams = {}) {
+        const params = this.getListQueryParams(listParams);
+        return this.http.get(this.entityUrl, { params })
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Get entity by ID
+     */
+    get(id) {
+        return this.http.get(`${this.entityUrl}/${id}`)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Create new entity
+     */
+    insert(entity) {
+        return this.http.post(this.entityUrl, entity)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Update existing entity
+     */
+    update(id, entity) {
+        return this.http.put(`${this.entityUrl}/${id}`, entity)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Delete entity by ID
+     */
+    delete(id) {
+        return this.http.delete(`${this.entityUrl}/${id}`, { observe: 'response' })
+            .pipe(map(() => undefined), catchError(this.handleError));
+    }
+    /**
+     * Execute custom filter action
+     */
+    listCustomFilter(listParams, action) {
+        const bodyParams = this.getBodyParams(listParams);
+        return this.http.post(`${this.actionsUrl}/${action}`, bodyParams)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Execute custom query
+     */
+    executeQuery(queryName, params = {}) {
+        return this.http.post(`${this.queriesUrl}/${queryName}`, params)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Execute custom action
+     */
+    executeAction(actionName, params = {}) {
+        return this.http.post(`${this.actionsUrl}/${actionName}`, params)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Check if entity exists by ID
+     */
+    exists(id) {
+        return this.http.head(`${this.entityUrl}/${id}`)
+            .pipe(map(() => true), catchError((error) => {
+            if (error.status === 404) {
+                return [false];
+            }
+            return this.handleError(error);
+        }));
+    }
+    /**
+     * Bulk delete entities
+     */
+    bulkDelete(ids) {
+        return this.http.post(`${this.actionsUrl}/bulkDelete`, { ids }, { observe: 'response' })
+            .pipe(map(() => undefined), catchError(this.handleError));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EntityService, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EntityService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EntityService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined }] });
+
+class CookieService {
+    /**
+     * Obtém o valor de um cookie pelo nome
+     */
+    getCookie(name) {
+        if (typeof document === 'undefined') {
+            return null; // SSR protection
+        }
+        const nameEQ = name + '=';
+        const cookies = document.cookie.split(';');
+        for (let cookie of cookies) {
+            cookie = cookie.trim();
+            if (cookie.indexOf(nameEQ) === 0) {
+                const value = decodeURIComponent(cookie.substring(nameEQ.length));
+                return value;
+            }
+        }
+        return null;
+    }
+    /**
+     * Define um cookie
+     */
+    setCookie(name, value, days, path = '/') {
+        if (typeof document === 'undefined') {
+            return; // SSR protection
+        }
+        let expires = '';
+        if (days) {
+            const date = new Date();
+            date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+            expires = '; expires=' + date.toUTCString();
+        }
+        document.cookie = `${name}=${encodeURIComponent(value)}${expires}; path=${path}`;
+    }
+    /**
+     * Remove um cookie
+     */
+    deleteCookie(name, path = '/') {
+        this.setCookie(name, '', -1, path);
+    }
+    /**
+     * Verifica se um cookie existe
+     */
+    hasCookie(name) {
+        return this.getCookie(name) !== null;
+    }
+    /**
+     * Obtém todos os cookies como objeto
+     */
+    getAllCookies() {
+        if (typeof document === 'undefined') {
+            return {}; // SSR protection
+        }
+        const cookies = {};
+        const cookieArray = document.cookie.split(';');
+        for (let cookie of cookieArray) {
+            cookie = cookie.trim();
+            const [name, value] = cookie.split('=');
+            if (name && value) {
+                cookies[name] = decodeURIComponent(value);
+            }
+        }
+        return cookies;
+    }
+    /**
+     * Debug: Lista todos os cookies disponíveis
+     */
+    debugAllCookies() {
+        console.log('[CookieService] All available cookies:');
+        const allCookies = this.getAllCookies();
+        Object.keys(allCookies).forEach(name => {
+            const value = allCookies[name];
+            console.log(`[CookieService] ${name}: ${value.length > 100 ? value.substring(0, 100) + '...' : value}`);
+        });
+        if (Object.keys(allCookies).length === 0) {
+            console.log('[CookieService] No cookies found');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CookieService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CookieService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AuthService {
+    cookieService;
+    TOKEN_COOKIE_NAME = 'com.senior.token';
+    API_URL_COOKIE_NAME = 'com.senior.base.url';
+    API_PATH_SUFFIX = '/t/senior.com.br/bridge/1.0/rest';
+    currentUserSubject = new BehaviorSubject(null);
+    currentUser$ = this.currentUserSubject.asObservable();
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+        this.loadUserFromCookie();
+    }
+    /**
+     * Load user token from cookie
+     */
+    loadUserFromCookie() {
+        const tokenString = this.cookieService.getCookie(this.TOKEN_COOKIE_NAME);
+        if (tokenString) {
+            try {
+                const token = JSON.parse(tokenString);
+                if (this.isTokenValid(token)) {
+                    this.currentUserSubject.next(token);
+                }
+                else {
+                    this.currentUserSubject.next(null);
+                }
+            }
+            catch (error) {
+                console.error('[AuthService] Error parsing token from cookie:', error);
+                this.currentUserSubject.next(null);
+            }
+        }
+    }
+    /**
+     * Get current user token
+     */
+    getCurrentUser() {
+        return this.currentUserSubject.value;
+    }
+    /**
+     * Get access token
+     */
+    getAccessToken() {
+        const user = this.getCurrentUser();
+        return user?.access_token || null;
+    }
+    /**
+     * Get token type (e.g., "Bearer")
+     */
+    getTokenType() {
+        const user = this.getCurrentUser();
+        return user?.token_type || 'Bearer';
+    }
+    /**
+     * Get refresh token
+     */
+    getRefreshToken() {
+        const user = this.getCurrentUser();
+        return user?.refresh_token || null;
+    }
+    /**
+     * Get API base URL from cookie
+     */
+    getApiBaseUrl() {
+        const baseUrl = this.cookieService.getCookie(this.API_URL_COOKIE_NAME);
+        // In development, use proxy
+        if (!baseUrl) {
+            // Check if we're in development mode
+            const isDevelopment = !window.location.hostname.includes('senior.com.br');
+            if (isDevelopment) {
+                return '/api';
+            }
+            return null;
+        }
+        // Remove trailing slash from base URL
+        const cleanBaseUrl = baseUrl.replace(/\/$/, '');
+        // Combine with API path suffix
+        return `${cleanBaseUrl}${this.API_PATH_SUFFIX}`;
+    }
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated() {
+        const user = this.getCurrentUser();
+        return user !== null && this.isTokenValid(user);
+    }
+    /**
+     * Check if token is valid (not expired)
+     */
+    isTokenValid(token) {
+        if (!token || !token.access_token) {
+            return false;
+        }
+        // Check if token is expired
+        const now = Math.floor(Date.now() / 1000);
+        const tokenExpiry = token.expires_in;
+        // If expires_in is a timestamp, compare directly
+        // If it's a duration, we'd need the token creation time
+        // For now, assume it's a timestamp
+        // If expires_in is very large (like a duration in seconds), skip expiry check
+        if (tokenExpiry > 1000000000) {
+            // Looks like a timestamp
+            return tokenExpiry > now;
+        }
+        else {
+            // Looks like a duration, assume token is valid
+            return true;
+        }
+    }
+    /**
+     * Check if refresh token is valid
+     */
+    isRefreshTokenValid() {
+        const user = this.getCurrentUser();
+        if (!user || !user.refresh_token) {
+            return false;
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const refreshExpiry = user.refresh_expires_in;
+        return refreshExpiry > now;
+    }
+    /**
+     * Get user locale
+     */
+    getUserLocale() {
+        const user = this.getCurrentUser();
+        return user?.locale || 'pt-BR';
+    }
+    /**
+     * Get user full name
+     */
+    getUserFullName() {
+        const user = this.getCurrentUser();
+        return user?.fullName || '';
+    }
+    /**
+     * Get user email
+     */
+    getUserEmail() {
+        const user = this.getCurrentUser();
+        return user?.email || '';
+    }
+    /**
+     * Get tenant name
+     */
+    getTenantName() {
+        const user = this.getCurrentUser();
+        return user?.tenantName || '';
+    }
+    /**
+     * Get username
+     */
+    getUsername() {
+        const user = this.getCurrentUser();
+        return user?.username || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, deps: [{ token: CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: CookieService }] });
+
+class PermissionService {
+    http;
+    authService;
+    PERMISSION_ENDPOINT = 'platform/authorization/queries/checkAccess';
+    permissionCache = new Map();
+    cacheExpiry = new Map();
+    CACHE_DURATION = 5 * 60 * 1000; // 5 minutes in milliseconds
+    constructor(http, authService) {
+        this.http = http;
+        this.authService = authService;
+    }
+    /**
+     * Check access for a single permission
+     */
+    checkAccess(resource, action, context) {
+        const cacheKey = this.getCacheKey(resource, action, context);
+        // Check cache first
+        const cachedResult = this.getCachedPermission(cacheKey);
+        if (cachedResult !== null) {
+            return of(cachedResult.allowed);
+        }
+        // Make API request
+        const request = {
+            permissions: [{ resource, action, context }]
+        };
+        return this.http.post(this.PERMISSION_ENDPOINT, request).pipe(map(response => {
+            if (response.results && response.results.length > 0) {
+                const result = response.results[0];
+                this.cachePermission(cacheKey, result);
+                return result.allowed;
+            }
+            return false;
+        }), catchError(error => {
+            console.error('Permission check failed:', error);
+            // On error, deny access by default
+            return of(false);
+        }));
+    }
+    /**
+     * Check access for multiple permissions
+     */
+    checkMultipleAccess(permissions) {
+        const uncachedPermissions = [];
+        const results = [];
+        // Check cache for each permission
+        permissions.forEach(permission => {
+            const cacheKey = this.getCacheKey(permission.resource, permission.action, permission.context);
+            const cachedResult = this.getCachedPermission(cacheKey);
+            if (cachedResult !== null) {
+                results.push(cachedResult);
+            }
+            else {
+                uncachedPermissions.push(permission);
+            }
+        });
+        // If all permissions are cached, return immediately
+        if (uncachedPermissions.length === 0) {
+            return of(results);
+        }
+        // Make API request for uncached permissions
+        const request = {
+            permissions: uncachedPermissions
+        };
+        return this.http.post(this.PERMISSION_ENDPOINT, request).pipe(map(response => {
+            if (response.results) {
+                // Cache the new results
+                response.results.forEach(result => {
+                    const cacheKey = this.getCacheKey(result.resource, result.action);
+                    this.cachePermission(cacheKey, result);
+                });
+                // Combine cached and new results
+                return [...results, ...response.results];
+            }
+            return results;
+        }), catchError(error => {
+            console.error('Multiple permission check failed:', error);
+            // On error, return cached results and deny uncached ones
+            const deniedResults = uncachedPermissions.map(permission => ({
+                allowed: false,
+                resource: permission.resource,
+                action: permission.action,
+                reason: 'Permission check failed'
+            }));
+            return of([...results, ...deniedResults]);
+        }));
+    }
+    /**
+     * Check if user can read a resource
+     */
+    canRead(resource, context) {
+        return this.checkAccess(resource, 'read', context);
+    }
+    /**
+     * Check if user can write to a resource
+     */
+    canWrite(resource, context) {
+        return this.checkAccess(resource, 'write', context);
+    }
+    /**
+     * Check if user can delete a resource
+     */
+    canDelete(resource, context) {
+        return this.checkAccess(resource, 'delete', context);
+    }
+    /**
+     * Check if user can execute an action on a resource
+     */
+    canExecute(resource, action, context) {
+        return this.checkAccess(resource, action, context);
+    }
+    /**
+     * Clear permission cache
+     */
+    clearCache() {
+        this.permissionCache.clear();
+        this.cacheExpiry.clear();
+    }
+    /**
+     * Clear expired cache entries
+     */
+    clearExpiredCache() {
+        const now = Date.now();
+        const expiredKeys = [];
+        this.cacheExpiry.forEach((expiry, key) => {
+            if (expiry < now) {
+                expiredKeys.push(key);
+            }
+        });
+        expiredKeys.forEach(key => {
+            this.permissionCache.delete(key);
+            this.cacheExpiry.delete(key);
+        });
+    }
+    /**
+     * Generate cache key for permission
+     */
+    getCacheKey(resource, action, context) {
+        const contextStr = context ? JSON.stringify(context) : '';
+        return `${resource}:${action}:${contextStr}`;
+    }
+    /**
+     * Get cached permission result
+     */
+    getCachedPermission(cacheKey) {
+        const expiry = this.cacheExpiry.get(cacheKey);
+        if (expiry && expiry > Date.now()) {
+            return this.permissionCache.get(cacheKey) || null;
+        }
+        // Remove expired entry
+        this.permissionCache.delete(cacheKey);
+        this.cacheExpiry.delete(cacheKey);
+        return null;
+    }
+    /**
+     * Cache permission result
+     */
+    cachePermission(cacheKey, result) {
+        this.permissionCache.set(cacheKey, result);
+        this.cacheExpiry.set(cacheKey, Date.now() + this.CACHE_DURATION);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionService, deps: [{ token: i1.HttpClient }, { token: 'AuthService', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AuthService']
+                }] }] });
+
+/**
+ * Serviço para gerenciar o token Senior e extrair informações específicas
+ * para o sistema de traduções.
+ *
+ * Nota: Este serviço foca especificamente na extração do locale e informações
+ * básicas do usuário. Para funcionalidades completas de autenticação,
+ * use o AuthService que tem uma interface mais robusta.
+ */
+class SeniorTokenService {
+    cookieService;
+    SENIOR_TOKEN_COOKIE = 'com.senior.token';
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+    }
+    /**
+     * Obtém o token Senior completo do cookie
+     */
+    getSeniorToken() {
+        // Tentar o nome padrão primeiro
+        let token = this.cookieService.getCookie(this.SENIOR_TOKEN_COOKIE);
+        if (!token) {
+            // Tentar nomes alternativos comuns
+            const alternativeNames = [
+                'com.senior.token',
+                'senior.token',
+                'senior_token',
+                'seniorToken',
+                'token',
+                'authToken',
+                'auth_token'
+            ];
+            for (const name of alternativeNames) {
+                token = this.cookieService.getCookie(name);
+                if (token) {
+                    break;
+                }
+            }
+        }
+        return token;
+    }
+    /**
+     * Decodifica e obtém os dados do token Senior
+     */
+    getSeniorTokenData() {
+        const token = this.getSeniorToken();
+        if (!token) {
+            return null;
+        }
+        try {
+            let tokenData;
+            // Primeiro, tentar como JSON direto (mais provável baseado na informação fornecida)
+            try {
+                tokenData = JSON.parse(token);
+            }
+            catch (jsonError) {
+                // Se falhar, tentar como JWT
+                if (token.includes('.')) {
+                    const parts = token.split('.');
+                    if (parts.length >= 2) {
+                        const payload = parts[1];
+                        // Adicionar padding se necessário
+                        const paddedPayload = payload + '='.repeat((4 - payload.length % 4) % 4);
+                        const decodedPayload = atob(paddedPayload);
+                        tokenData = JSON.parse(decodedPayload);
+                    }
+                    else {
+                        throw new Error('Invalid JWT format');
+                    }
+                }
+                else {
+                    throw jsonError; // Re-throw original JSON error
+                }
+            }
+            return tokenData;
+        }
+        catch (error) {
+            console.error('[SeniorTokenService] Error parsing Senior token:', error);
+            return null;
+        }
+    }
+    /**
+     * Obtém o locale do usuário do token Senior
+     */
+    getUserLocale() {
+        const tokenData = this.getSeniorTokenData();
+        if (!tokenData) {
+            return null;
+        }
+        // O locale deve estar no mesmo nível do access_token
+        if (tokenData.locale) {
+            return tokenData.locale;
+        }
+        // Fallback: tentar outros campos comuns
+        const possibleLocaleFields = [
+            'language',
+            'lang',
+            'user_locale',
+            'userLocale',
+            'preferred_language',
+            'preferredLanguage'
+        ];
+        for (const field of possibleLocaleFields) {
+            if (tokenData[field]) {
+                return tokenData[field];
+            }
+        }
+        return null;
+    }
+    /**
+     * Obtém informações do usuário do token Senior
+     */
+    getUserInfo() {
+        const tokenData = this.getSeniorTokenData();
+        if (!tokenData) {
+            return null;
+        }
+        // Baseado na estrutura do AuthService, os campos devem estar no nível raiz
+        return {
+            userId: tokenData.userId || tokenData['sub'] || tokenData['user_id'] || tokenData.username,
+            userName: tokenData.userName || tokenData['name'] || tokenData['user_name'] || tokenData.username || tokenData.fullName,
+            locale: tokenData.locale,
+            email: tokenData.email,
+            fullName: tokenData.fullName
+        };
+    }
+    /**
+     * Verifica se o usuário está logado (token existe e é válido)
+     */
+    isUserLoggedIn() {
+        const tokenData = this.getSeniorTokenData();
+        if (!tokenData) {
+            return false;
+        }
+        // Verificar expiração se existir
+        if (tokenData['exp']) {
+            const now = Math.floor(Date.now() / 1000);
+            if (tokenData['exp'] < now) {
+                console.warn('Senior token has expired');
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Monitora mudanças no cookie do token (para detectar login/logout)
+     */
+    watchTokenChanges(callback) {
+        let lastToken = this.getSeniorToken();
+        const checkToken = () => {
+            const currentToken = this.getSeniorToken();
+            if (currentToken !== lastToken) {
+                lastToken = currentToken;
+                const tokenData = this.getSeniorTokenData();
+                callback(tokenData);
+            }
+        };
+        // Verificar a cada 5 segundos
+        setInterval(checkToken, 5000);
+    }
+    /**
+     * Valida se o token tem a estrutura esperada do Senior
+     */
+    validateTokenStructure() {
+        const tokenData = this.getSeniorTokenData();
+        const issues = [];
+        if (!tokenData) {
+            issues.push('Token not found or could not be parsed');
+            return { isValid: false, issues };
+        }
+        // Verificar campos obrigatórios esperados
+        const requiredFields = ['access_token'];
+        const recommendedFields = ['locale', 'username', 'email'];
+        for (const field of requiredFields) {
+            if (!tokenData[field]) {
+                issues.push(`Missing required field: ${field}`);
+            }
+        }
+        for (const field of recommendedFields) {
+            if (!tokenData[field]) {
+                issues.push(`Missing recommended field: ${field}`);
+            }
+        }
+        // Verificar se locale está presente e é válido
+        if (tokenData.locale) {
+            // Importar a função de mapeamento seria circular, então fazer verificação básica
+            const supportedLocales = ['pt-BR', 'en-US', 'es-ES', 'pt', 'en', 'es'];
+            const locale = tokenData.locale;
+            const isSupported = supportedLocales.some(supportedLocale => locale.toLowerCase().includes(supportedLocale.toLowerCase()));
+            if (!isSupported) {
+                issues.push(`Locale '${locale}' might not be supported`);
+            }
+        }
+        const isValid = issues.filter(issue => issue.includes('required')).length === 0;
+        console.log('[SeniorTokenService] Token validation result:', { isValid, issues });
+        return { isValid, issues };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SeniorTokenService, deps: [{ token: CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SeniorTokenService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SeniorTokenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: CookieService }] });
+
+class ThemeService {
+    document;
+    isDarkModeSubject = new BehaviorSubject(false);
+    isDarkMode$ = this.isDarkModeSubject.asObservable();
+    mediaQuery;
+    constructor(document) {
+        this.document = document;
+        // Create media query to watch for system theme changes (kept for compatibility)
+        this.mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        // Check for saved theme preference, default to light theme
+        const savedTheme = localStorage.getItem('theme');
+        if (savedTheme === 'dark') {
+            // Only use dark theme if explicitly saved as dark
+            this.setTheme(true);
+        }
+        else {
+            // Default to light theme, ignoring system preference
+            this.setTheme(false);
+            // Set default theme preference if not exists
+            if (!savedTheme) {
+                localStorage.setItem('theme', 'light');
+            }
+        }
+    }
+    followSystemTheme() {
+        // This method is kept for compatibility but no longer used by default
+        // Set theme based on system preference only when explicitly requested
+        this.setTheme(this.mediaQuery.matches);
+        // Listen for system theme changes only when in auto mode
+        this.mediaQuery.addEventListener('change', (e) => {
+            const savedTheme = localStorage.getItem('theme');
+            if (savedTheme === 'auto') {
+                this.setTheme(e.matches);
+            }
+        });
+    }
+    toggleTheme() {
+        const currentTheme = this.isDarkModeSubject.value;
+        this.setTheme(!currentTheme);
+        // When manually toggling, save the specific preference
+        localStorage.setItem('theme', !currentTheme ? 'dark' : 'light');
+    }
+    setThemeMode(mode) {
+        localStorage.setItem('theme', mode);
+        if (mode === 'auto') {
+            this.followSystemTheme();
+        }
+        else {
+            this.setTheme(mode === 'dark');
+        }
+    }
+    setTheme(isDark) {
+        this.isDarkModeSubject.next(isDark);
+        // Apply theme to document
+        if (isDark) {
+            this.document.documentElement.classList.add('app-dark');
+        }
+        else {
+            this.document.documentElement.classList.remove('app-dark');
+        }
+    }
+    get isDarkMode() {
+        return this.isDarkModeSubject.value;
+    }
+    get currentThemeMode() {
+        const savedTheme = localStorage.getItem('theme');
+        return savedTheme || 'light'; // Default to light instead of auto
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+
+const SUPPORTED_LANGUAGES = [
+    {
+        code: 'pt-BR',
+        name: 'Português (Brasil)',
+        flag: '🇧🇷',
+        aliases: ['pt', 'pt_BR', 'portuguese', 'br']
+    },
+    {
+        code: 'en-US',
+        name: 'English (US)',
+        flag: '🇺🇸',
+        aliases: ['en', 'en_US', 'english', 'us']
+    },
+    {
+        code: 'es-ES',
+        name: 'Español (España)',
+        flag: '🇪🇸',
+        aliases: ['es', 'es_ES', 'spanish', 'spain']
+    }
+];
+const DEFAULT_LANGUAGE = 'pt-BR';
+const TRANSLATION_CONFIG = {
+    supportedLanguages: SUPPORTED_LANGUAGES,
+    defaultLanguage: DEFAULT_LANGUAGE,
+    fallbackLanguage: 'pt-BR',
+    storageKey: 'selectedLanguage',
+    assetsPath: './app/locale'
+};
+/**
+ * Mapeia um locale do token Senior para um código de idioma suportado
+ */
+function mapTokenLocaleToLanguage(tokenLocale) {
+    if (!tokenLocale)
+        return null;
+    // Normalizar o locale (remover case sensitivity e caracteres especiais)
+    const normalizedLocale = tokenLocale.toLowerCase().replace(/[_-]/g, '');
+    // Procurar correspondência exata primeiro
+    for (const lang of SUPPORTED_LANGUAGES) {
+        if (lang.code.toLowerCase().replace(/[_-]/g, '') === normalizedLocale) {
+            return lang.code;
+        }
+    }
+    // Procurar por aliases
+    for (const lang of SUPPORTED_LANGUAGES) {
+        if (lang.aliases) {
+            for (const alias of lang.aliases) {
+                if (alias.toLowerCase().replace(/[_-]/g, '') === normalizedLocale) {
+                    return lang.code;
+                }
+            }
+        }
+    }
+    // Tentar correspondência parcial (apenas o idioma, ignorando país)
+    const languageOnly = normalizedLocale.substring(0, 2);
+    for (const lang of SUPPORTED_LANGUAGES) {
+        const langCode = lang.code.toLowerCase().substring(0, 2);
+        if (langCode === languageOnly) {
+            return lang.code;
+        }
+    }
+    console.warn(`Unsupported locale from token: ${tokenLocale}`);
+    return null;
+}
+/**
+ * Obtém informações de um idioma pelo código
+ */
+function getLanguageInfo(code) {
+    return SUPPORTED_LANGUAGES.find(lang => lang.code === code) || null;
+}
+
+class TranslationService {
+    seniorTokenService;
+    currentLanguage = new BehaviorSubject(TRANSLATION_CONFIG.defaultLanguage);
+    translations = {};
+    loadingLanguages = new Set();
+    translationLoader;
+    constructor(seniorTokenService, loader) {
+        this.seniorTokenService = seniorTokenService;
+        this.translationLoader = loader;
+        this.loadStoredLanguage();
+        // Carregar traduções do idioma inicial imediatamente
+        this.loadTranslations();
+        // Monitorar mudanças no token para atualizar idioma
+        this.watchTokenChanges();
+    }
+    get currentLanguage$() {
+        return this.currentLanguage.asObservable();
+    }
+    getCurrentLanguage() {
+        return this.currentLanguage.value;
+    }
+    async setLanguage(language) {
+        this.currentLanguage.next(language);
+        localStorage.setItem(TRANSLATION_CONFIG.storageKey, language);
+        await this.loadTranslations();
+    }
+    async waitForTranslations() {
+        const language = this.currentLanguage.value;
+        if (!this.isLanguageLoaded(language)) {
+            await this.loadTranslations();
+        }
+    }
+    /**
+     * Verifica se as traduções do idioma atual estão carregadas
+     */
+    isLanguageLoaded(language) {
+        const lang = language || this.currentLanguage.value;
+        return !!this.translations[lang] && Object.keys(this.translations[lang]).length > 0;
+    }
+    translate(key, params) {
+        const currentLang = this.currentLanguage.value;
+        const translations = this.translations[currentLang];
+        if (!translations || Object.keys(translations).length === 0) {
+            // Se as traduções não estão carregadas, tentar carregar de forma assíncrona
+            if (!this.loadingLanguages.has(currentLang)) {
+                this.loadTranslations().catch(error => {
+                    console.error('Error loading translations:', error);
+                });
+            }
+            console.warn(`No translations loaded for language: ${currentLang}`);
+            return key;
+        }
+        // Para estrutura plana, buscar diretamente pela chave
+        const translation = translations[key];
+        if (!translation) {
+            console.warn(`Translation key not found: ${key}`);
+            return key;
+        }
+        if (typeof translation !== 'string') {
+            console.warn(`Translation key is not a string: ${key}`);
+            return key;
+        }
+        // Replace parameters if provided
+        if (params) {
+            return this.replaceParams(translation, params);
+        }
+        return translation;
+    }
+    async loadTranslations() {
+        const language = this.currentLanguage.value;
+        // Se já está carregado, não carregar novamente
+        if (this.isLanguageLoaded(language)) {
+            return;
+        }
+        // Evitar carregamentos duplicados
+        if (this.loadingLanguages.has(language)) {
+            // Aguardar um pouco e tentar novamente
+            await new Promise(resolve => setTimeout(resolve, 100));
+            if (this.isLanguageLoaded(language)) {
+                return;
+            }
+        }
+        this.loadingLanguages.add(language);
+        try {
+            await this.doLoadTranslations(language);
+        }
+        catch (error) {
+            console.error('Error in loadTranslations:', error);
+        }
+        finally {
+            this.loadingLanguages.delete(language);
+        }
+    }
+    async doLoadTranslations(language) {
+        try {
+            // Se há um loader customizado, usar ele
+            if (this.translationLoader) {
+                const translations = await this.translationLoader.loadTranslations(language);
+                this.translations[language] = translations;
+                console.log(`Translations loaded for ${language}:`, Object.keys(this.translations[language]).length, 'keys');
+                return;
+            }
+            // Caso contrário, avisar que não há traduções
+            console.warn(`No translation loader provided. Translations for ${language} not loaded.`);
+            this.translations[language] = {};
+        }
+        catch (error) {
+            console.error(`Error loading translations for ${language}:`, error);
+            // Fallback para o idioma padrão se houver erro
+            if (language !== TRANSLATION_CONFIG.fallbackLanguage) {
+                try {
+                    if (this.translationLoader) {
+                        const fallbackTranslations = await this.translationLoader.loadTranslations(TRANSLATION_CONFIG.fallbackLanguage);
+                        this.translations[language] = fallbackTranslations;
+                        console.log(`Fallback translations loaded for ${language}`);
+                    }
+                }
+                catch (fallbackError) {
+                    console.error(`Error loading fallback translations:`, fallbackError);
+                }
+            }
+        }
+    }
+    loadStoredLanguage() {
+        // 1. Primeiro, tentar obter do token Senior
+        const tokenLocale = this.seniorTokenService.getUserLocale();
+        if (tokenLocale) {
+            const mappedLanguage = mapTokenLocaleToLanguage(tokenLocale);
+            if (mappedLanguage) {
+                console.log(`Using language from Senior token: ${tokenLocale} -> ${mappedLanguage}`);
+                this.currentLanguage.next(mappedLanguage);
+                return;
+            }
+        }
+        // 2. Segundo, tentar obter do localStorage
+        const stored = localStorage.getItem(TRANSLATION_CONFIG.storageKey);
+        const supportedCodes = TRANSLATION_CONFIG.supportedLanguages.map(lang => lang.code);
+        if (stored && supportedCodes.includes(stored)) {
+            console.log('Using language from localStorage:', stored);
+            this.currentLanguage.next(stored);
+            return;
+        }
+        // 3. Por último, usar idioma padrão
+        console.log('Using default language:', TRANSLATION_CONFIG.defaultLanguage);
+        this.currentLanguage.next(TRANSLATION_CONFIG.defaultLanguage);
+    }
+    replaceParams(text, params) {
+        return text.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+            return params[key] !== undefined ? params[key] : match;
+        });
+    }
+    getSupportedLanguages() {
+        return TRANSLATION_CONFIG.supportedLanguages;
+    }
+    /**
+     * Força o recarregamento das traduções (útil para desenvolvimento)
+     */
+    async reloadTranslations() {
+        const language = this.currentLanguage.value;
+        delete this.translations[language];
+        await this.loadTranslations();
+    }
+    /**
+     * Obtém todas as chaves de tradução carregadas
+     */
+    getLoadedKeys() {
+        const language = this.currentLanguage.value;
+        const translations = this.translations[language];
+        return translations ? Object.keys(translations) : [];
+    }
+    /**
+     * Verifica se um código de idioma é suportado
+     */
+    isValidLanguage(locale) {
+        const supportedCodes = TRANSLATION_CONFIG.supportedLanguages.map(lang => lang.code);
+        return supportedCodes.includes(locale);
+    }
+    /**
+     * Monitora mudanças no token Senior para atualizar idioma automaticamente
+     */
+    watchTokenChanges() {
+        this.seniorTokenService.watchTokenChanges((tokenData) => {
+            if (tokenData?.locale) {
+                const mappedLanguage = mapTokenLocaleToLanguage(tokenData.locale);
+                if (mappedLanguage) {
+                    const newLocale = mappedLanguage;
+                    const currentLocale = this.currentLanguage.value;
+                    if (newLocale !== currentLocale) {
+                        console.log(`Token locale changed: ${tokenData.locale} -> ${newLocale}`);
+                        this.setLanguage(newLocale);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Força atualização do idioma baseado no token atual
+     */
+    async syncWithToken() {
+        const tokenLocale = this.seniorTokenService.getUserLocale();
+        if (tokenLocale) {
+            const mappedLanguage = mapTokenLocaleToLanguage(tokenLocale);
+            if (mappedLanguage) {
+                const newLocale = mappedLanguage;
+                const currentLocale = this.currentLanguage.value;
+                if (newLocale !== currentLocale) {
+                    console.log(`Syncing language with token: ${tokenLocale} -> ${newLocale}`);
+                    await this.setLanguage(newLocale);
+                }
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationService, deps: [{ token: SeniorTokenService }, { token: 'TranslationLoader', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: SeniorTokenService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['TranslationLoader']
+                }] }] });
+
+class ExportDialogComponent {
+    translationService;
+    visible = false;
+    allRecords = [];
+    selectedRecords = [];
+    statusLabels;
+    translationPrefix = 'crmx.business';
+    set availableColumns(columns) {
+        if (columns && columns.length > 0) {
+            this.columns = columns;
+        }
+    }
+    visibleChange = new EventEmitter();
+    exportFormat = 'xlsx';
+    exportScope = 'all';
+    formats = [];
+    scopes = [];
+    columns = [];
+    constructor(translationService) {
+        this.translationService = translationService;
+        this.initializeFormats();
+        this.initializeScopes();
+    }
+    ngOnChanges() {
+        this.initializeFormats();
+        this.initializeScopes();
+    }
+    t(key) {
+        if (this.translationService) {
+            return this.translationService.translate(`${this.translationPrefix}.${key}`);
+        }
+        return key;
+    }
+    initializeFormats() {
+        this.formats = [
+            {
+                value: 'xlsx',
+                label: 'Excel',
+                icon: 'pi-file-excel',
+                description: this.t('export_excel_description')
+            },
+            {
+                value: 'pdf',
+                label: 'PDF',
+                icon: 'pi-file-pdf',
+                description: this.t('export_pdf_description')
+            }
+        ];
+    }
+    initializeScopes() {
+        this.scopes = [
+            {
+                value: 'all',
+                label: this.t('export_all_records'),
+                icon: 'pi-list',
+                description: this.t('export_all_records_description')
+            },
+            {
+                value: 'selected',
+                label: this.t('export_selected_records'),
+                icon: 'pi-check-square',
+                description: this.t('export_selected_records_description')
+            }
+        ];
+    }
+    get recordsToExport() {
+        return this.exportScope === 'all' ? this.allRecords : this.selectedRecords;
+    }
+    get selectedColumnsCount() {
+        return this.columns.filter(col => col.selected).length;
+    }
+    get canExport() {
+        return this.selectedColumnsCount > 0 && this.recordsToExport.length > 0;
+    }
+    onHide() {
+        this.visibleChange.emit(false);
+    }
+    selectAllColumns() {
+        this.columns.forEach(col => col.selected = true);
+    }
+    deselectAllColumns() {
+        this.columns.forEach(col => col.selected = false);
+    }
+    export() {
+        if (!this.canExport)
+            return;
+        if (this.exportFormat === 'xlsx') {
+            this.exportToExcel();
+        }
+        else {
+            this.exportToPDF();
+        }
+        this.onHide();
+    }
+    exportToExcel() {
+        const selectedColumns = this.columns.filter(col => col.selected);
+        const data = this.recordsToExport.map(record => {
+            const row = {};
+            selectedColumns.forEach(col => {
+                if (col.field === 'status' && record.status && this.statusLabels) {
+                    row[col.header] = this.statusLabels[record.status];
+                }
+                else {
+                    row[col.header] = record[col.field];
+                }
+            });
+            return row;
+        });
+        const worksheet = XLSX.utils.json_to_sheet(data);
+        const workbook = XLSX.utils.book_new();
+        XLSX.utils.book_append_sheet(workbook, worksheet, this.t('export_data_sheet_name'));
+        // Ajustar largura das colunas
+        const maxWidth = 30;
+        const colWidths = selectedColumns.map(col => ({
+            wch: Math.min(col.header.length + 5, maxWidth)
+        }));
+        worksheet['!cols'] = colWidths;
+        const fileName = `export-${new Date().getTime()}.xlsx`;
+        XLSX.writeFile(workbook, fileName);
+    }
+    exportToPDF() {
+        const doc = new jsPDF();
+        const selectedColumns = this.columns.filter(col => col.selected);
+        // Título
+        doc.setFontSize(18);
+        doc.setTextColor(18, 168, 133);
+        doc.text(this.t('export_pdf_title'), 14, 20);
+        // Subtítulo
+        doc.setFontSize(10);
+        doc.setTextColor(100);
+        doc.text(`${this.t('export_exported_at')}: ${new Date().toLocaleString('pt-BR')}`, 14, 28);
+        doc.text(`${this.t('export_total_records')}: ${this.recordsToExport.length}`, 14, 34);
+        // Preparar dados
+        const headers = selectedColumns.map(col => col.header);
+        const data = this.recordsToExport.map(record => {
+            return selectedColumns.map(col => {
+                if (col.field === 'status' && record.status && this.statusLabels) {
+                    return this.statusLabels[record.status];
+                }
+                return String(record[col.field] || '');
+            });
+        });
+        // Tabela
+        autoTable(doc, {
+            head: [headers],
+            body: data,
+            startY: 40,
+            theme: 'grid',
+            headStyles: {
+                fillColor: [18, 168, 133],
+                textColor: [255, 255, 255],
+                fontStyle: 'bold',
+                halign: 'center'
+            },
+            styles: {
+                fontSize: 9,
+                cellPadding: 3
+            },
+            alternateRowStyles: {
+                fillColor: [248, 255, 254]
+            }
+        });
+        const fileName = `export-${new Date().getTime()}.pdf`;
+        doc.save(fileName);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ExportDialogComponent, deps: [{ token: 'TranslationService', optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: ExportDialogComponent, isStandalone: true, selector: "sia-export-dialog", inputs: { visible: "visible", allRecords: "allRecords", selectedRecords: "selectedRecords", statusLabels: "statusLabels", translationPrefix: "translationPrefix", availableColumns: "availableColumns" }, outputs: { visibleChange: "visibleChange" }, usesOnChanges: true, ngImport: i0, template: "<p-dialog\n  [(visible)]=\"visible\"\n  (onHide)=\"onHide()\"\n  [modal]=\"true\"\n  [draggable]=\"false\"\n  [resizable]=\"false\"\n  [style]=\"{ width: '700px' }\"\n  styleClass=\"export-dialog\"\n>\n  <ng-template pTemplate=\"header\">\n    <div class=\"custom-header\">\n      <i class=\"pi pi-download header-icon\"></i>\n      <span>{{ t('export_data_title') }}</span>\n    </div>\n  </ng-template>\n\n  <div class=\"export-content\">\n    <!-- Formato de Exporta\u00E7\u00E3o -->\n    <div class=\"export-section\">\n      <div class=\"section-header\">\n        <div class=\"section-icon\">\n          <i class=\"pi pi-file\"></i>\n        </div>\n        <h3>{{ t('export_format_title') }}</h3>\n      </div>\n      <div class=\"format-options\">\n        <div\n          *ngFor=\"let format of formats\"\n          class=\"format-card\"\n          [class.selected]=\"exportFormat === format.value\"\n          (click)=\"exportFormat = format.value\"\n        >\n          <div class=\"card-radio\">\n            <p-radioButton\n              [value]=\"format.value\"\n              [(ngModel)]=\"exportFormat\"\n              [inputId]=\"format.value\"\n            ></p-radioButton>\n          </div>\n          <div class=\"card-icon\" [class.excel]=\"format.value === 'xlsx'\" [class.pdf]=\"format.value === 'pdf'\">\n            <i class=\"pi\" [ngClass]=\"format.icon\"></i>\n          </div>\n          <div class=\"card-info\">\n            <label [for]=\"format.value\" class=\"card-label\">{{ format.label }}</label>\n            <span class=\"card-description\">{{ format.description }}</span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <!-- Escopo de Exporta\u00E7\u00E3o -->\n    <div class=\"export-section\">\n      <div class=\"section-header\">\n        <div class=\"section-icon\">\n          <i class=\"pi pi-filter\"></i>\n        </div>\n        <h3>{{ t('export_scope_title') }}</h3>\n      </div>\n      <div class=\"scope-options\">\n        <div\n          *ngFor=\"let scope of scopes\"\n          class=\"scope-card\"\n          [class.selected]=\"exportScope === scope.value\"\n          [class.disabled]=\"scope.value === 'selected' && selectedRecords.length === 0\"\n          (click)=\"scope.value === 'selected' && selectedRecords.length === 0 ? null : exportScope = scope.value\"\n        >\n          <div class=\"card-radio\">\n            <p-radioButton\n              [value]=\"scope.value\"\n              [(ngModel)]=\"exportScope\"\n              [inputId]=\"scope.value\"\n              [disabled]=\"scope.value === 'selected' && selectedRecords.length === 0\"\n            ></p-radioButton>\n          </div>\n          <div class=\"card-icon\">\n            <i class=\"pi\" [ngClass]=\"scope.icon\"></i>\n          </div>\n          <div class=\"card-info\">\n            <label [for]=\"scope.value\" class=\"card-label\">{{ scope.label }}</label>\n            <span class=\"card-description\">{{ scope.description }}</span>\n            <span class=\"card-count\">\n              <i class=\"pi pi-circle-fill\"></i>\n              {{ scope.value === 'all' ? allRecords.length : selectedRecords.length }} {{ t('export_records_count') }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <!-- Sele\u00E7\u00E3o de Colunas -->\n    <div class=\"export-section\">\n      <div class=\"section-header\">\n        <div class=\"section-icon\">\n          <i class=\"pi pi-table\"></i>\n        </div>\n        <h3>{{ t('export_columns_title') }}</h3>\n        <div class=\"column-actions\">\n          <button type=\"button\" class=\"action-link\" (click)=\"selectAllColumns()\">\n            {{ t('export_select_all_columns') }}\n          </button>\n          <span class=\"separator\">|</span>\n          <button type=\"button\" class=\"action-link\" (click)=\"deselectAllColumns()\">\n            {{ t('export_clear_selection') }}\n          </button>\n        </div>\n      </div>\n      <div class=\"columns-grid\">\n        <div\n          *ngFor=\"let column of columns\"\n          class=\"column-item\"\n          [class.selected]=\"column.selected\"\n          (click)=\"column.selected = !column.selected\"\n        >\n          <p-checkbox\n            [(ngModel)]=\"column.selected\"\n            [binary]=\"true\"\n            [inputId]=\"column.field\"\n          ></p-checkbox>\n          <label [for]=\"column.field\" class=\"column-label\">\n            {{ column.header }}\n          </label>\n        </div>\n      </div>\n      <div class=\"columns-summary\">\n        <i class=\"pi pi-info-circle\"></i>\n        <span>{{ selectedColumnsCount }} {{ t('export_columns_summary') }} {{ columns.length }} {{ t('export_columns_selected') }}</span>\n      </div>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button\n      [label]=\"t('cancel')\"\n      icon=\"pi pi-times\"\n      severity=\"secondary\"\n      [text]=\"true\"\n      (onClick)=\"onHide()\"\n    ></p-button>\n    <p-button\n      [label]=\"t('export_button')\"\n      icon=\"pi pi-download\"\n      [disabled]=\"!canExport\"\n      (onClick)=\"export()\"\n    ></p-button>\n  </ng-template>\n</p-dialog>\n", styles: ["::ng-deep .export-dialog .p-dialog{border-radius:16px;overflow:hidden;box-shadow:0 20px 60px #0000004d}::ng-deep .export-dialog .p-dialog-content{padding:0;background:#fff;max-height:70vh;overflow-y:auto}.custom-header{display:flex;align-items:center;gap:12px;font-size:18px;font-weight:600}.custom-header .header-icon{font-size:22px;color:var(--p-primary-500)}.export-content{padding:28px 32px}.export-section{margin-bottom:32px}.export-section:last-child{margin-bottom:0}.export-section .section-header{display:flex;align-items:center;gap:12px;margin-bottom:20px}.export-section .section-header .section-icon{width:36px;height:36px;display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.1),rgba(var(--p-primary-rgb),.15));border-radius:10px}.export-section .section-header .section-icon i{font-size:18px;color:var(--p-primary-500)}.export-section .section-header h3{margin:0;font-size:17px;font-weight:700;color:var(--neutral-color-800);flex:1}.export-section .section-header .column-actions{display:flex;align-items:center;gap:10px;font-size:13px}.export-section .section-header .column-actions .action-link{background:none;border:none;color:var(--p-primary-500);cursor:pointer;font-weight:600;padding:0;transition:all .2s;font-size:13px}.export-section .section-header .column-actions .action-link:hover{color:var(--p-primary-500)}.export-section .section-header .column-actions .separator{color:var(--neutral-color-300);font-weight:400}.format-options{display:grid;grid-template-columns:repeat(2,1fr);gap:16px}.format-card{display:flex;align-items:center;gap:16px;padding:20px;border:2px solid #e5e7eb;border-radius:12px;cursor:pointer;transition:all .3s cubic-bezier(.4,0,.2,1);background:#fff;position:relative;overflow:hidden}.format-card:before{content:\"\";position:absolute;inset:0;background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.03),rgba(var(--p-primary-rgb),.06));opacity:0;transition:opacity .3s}.format-card:hover{border-color:var(--p-primary-500);transform:translateY(-2px);box-shadow:0 8px 24px rgba(var(--p-primary-rgb),.15)}.format-card:hover:before{opacity:1}.format-card.selected{border-color:var(--p-primary-500);background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.05),rgba(var(--p-primary-rgb),.08));box-shadow:0 0 0 4px rgba(var(--p-primary-rgb),.1)}.format-card.selected .card-icon{background:linear-gradient(135deg,var(--p-primary-500) 0%,var(--p-primary-500) 100%);transform:scale(1.05)}.format-card.selected .card-icon i{color:#fff}.format-card .card-radio ::ng-deep .p-radiobutton .p-radiobutton-box{width:20px;height:20px;border-width:2px}.format-card .card-icon{width:52px;height:52px;display:flex;align-items:center;justify-content:center;border-radius:12px;transition:all .3s;position:relative;z-index:1}.format-card .card-icon.excel{background:linear-gradient(135deg,var(--p-primary-50) 0%,var(--p-primary-100) 100%)}.format-card .card-icon.excel i{color:#107c41;font-size:26px}.format-card .card-icon.pdf{background:linear-gradient(135deg,#fee8e8,#fdd4d4)}.format-card .card-icon.pdf i{color:#dc2626;font-size:26px}.format-card .card-info{flex:1;display:flex;flex-direction:column;gap:4px;position:relative;z-index:1}.format-card .card-label{font-size:16px;font-weight:700;color:var(--neutral-color-800);cursor:pointer;margin:0}.format-card .card-description{font-size:13px;color:var(--neutral-color-600);line-height:1.4}.scope-options{display:flex;flex-direction:column;gap:14px}.scope-card{display:flex;align-items:center;gap:16px;padding:20px;border:2px solid #e5e7eb;border-radius:12px;cursor:pointer;transition:all .3s cubic-bezier(.4,0,.2,1);background:#fff;position:relative;overflow:hidden}.scope-card:before{content:\"\";position:absolute;inset:0;background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.03),rgba(var(--p-primary-rgb),.06));opacity:0;transition:opacity .3s}.scope-card:hover:not(.disabled){border-color:var(--p-primary-500);box-shadow:0 4px 16px rgba(var(--p-primary-rgb),.12)}.scope-card:hover:not(.disabled):before{opacity:1}.scope-card.selected{border-color:var(--p-primary-500);background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.05),rgba(var(--p-primary-rgb),.08));box-shadow:0 0 0 4px rgba(var(--p-primary-rgb),.1)}.scope-card.selected .card-icon{background:linear-gradient(135deg,var(--p-primary-500) 0%,var(--p-primary-500) 100%);transform:scale(1.05)}.scope-card.selected .card-icon i{color:#fff}.scope-card.disabled{opacity:.5;cursor:not-allowed;background:#f9fafb}.scope-card.disabled:hover{border-color:#e5e7eb;box-shadow:none}.scope-card .card-radio ::ng-deep .p-radiobutton .p-radiobutton-box{width:20px;height:20px;border-width:2px}.scope-card .card-icon{width:48px;height:48px;display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg,var(--p-primary-50) 0%,var(--p-primary-100) 100%);border-radius:12px;transition:all .3s;position:relative;z-index:1}.scope-card .card-icon i{font-size:22px;color:var(--p-primary-500);transition:all .3s}.scope-card .card-info{flex:1;display:flex;flex-direction:column;gap:4px;position:relative;z-index:1}.scope-card .card-label{font-size:16px;font-weight:700;color:var(--neutral-color-800);cursor:pointer;margin:0}.scope-card .card-description{font-size:13px;color:var(--neutral-color-600);line-height:1.4}.scope-card .card-count{font-size:13px;font-weight:600;color:var(--p-primary-500);margin-top:6px;display:inline-flex;align-items:center;gap:6px}.scope-card .card-count i{font-size:6px}.columns-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin-bottom:16px}.column-item{display:flex;align-items:center;gap:12px;padding:16px;border:2px solid #e5e7eb;border-radius:10px;transition:all .2s;background:#fff;cursor:pointer}.column-item:hover{border-color:var(--p-primary-500);background:rgba(var(--p-primary-rgb),.03)}.column-item.selected{border-color:var(--p-primary-500);background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.05),rgba(var(--p-primary-rgb),.08))}.column-item ::ng-deep .p-checkbox .p-checkbox-box{width:20px;height:20px;border-width:2px}.column-item .column-label{font-size:14px;font-weight:600;color:var(--neutral-color-800);cursor:pointer;margin:0;-webkit-user-select:none;user-select:none}.columns-summary{display:flex;align-items:center;gap:10px;padding:14px 18px;background:linear-gradient(135deg,var(--p-primary-50) 0%,var(--p-primary-100) 100%);border-radius:10px;font-size:14px;color:var(--neutral-color-700);font-weight:600}.columns-summary i{color:var(--p-primary-500);font-size:18px}@media (max-width: 768px){::ng-deep .export-dialog .p-dialog{width:95vw!important;margin:0}.dialog-header{padding:28px 24px}.dialog-header .header-icon-wrapper{width:56px;height:56px}.dialog-header .header-icon-wrapper i{font-size:28px}.dialog-header .header-text h2{font-size:24px}.export-content{padding:24px}.format-options,.columns-grid{grid-template-columns:1fr}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: DialogModule }, { kind: "component", type: i3.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: i5.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i5$1.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "variant", "style", "styleClass", "badgeClass", "badgeSeverity", "ariaLabel", "autofocus", "fluid", "buttonProps"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "ngmodule", type: RadioButtonModule }, { kind: "component", type: i6.RadioButton, selector: "p-radioButton, p-radiobutton, p-radio-button", inputs: ["value", "formControlName", "name", "disabled", "variant", "size", "tabindex", "inputId", "ariaLabelledBy", "ariaLabel", "style", "styleClass", "autofocus", "binary"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "ngmodule", type: CheckboxModule }, { kind: "component", type: i7.Checkbox, selector: "p-checkbox, p-checkBox, p-check-box", inputs: ["value", "name", "disabled", "binary", "ariaLabelledBy", "ariaLabel", "tabindex", "inputId", "style", "inputStyle", "styleClass", "inputClass", "indeterminate", "size", "formControl", "checkboxIcon", "readonly", "required", "autofocus", "trueValue", "falseValue", "variant"], outputs: ["onChange", "onFocus", "onBlur"] }, { kind: "ngmodule", type: DividerModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ExportDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-export-dialog', standalone: true, imports: [
+                        CommonModule,
+                        FormsModule,
+                        DialogModule,
+                        ButtonModule,
+                        RadioButtonModule,
+                        CheckboxModule,
+                        DividerModule
+                    ], template: "<p-dialog\n  [(visible)]=\"visible\"\n  (onHide)=\"onHide()\"\n  [modal]=\"true\"\n  [draggable]=\"false\"\n  [resizable]=\"false\"\n  [style]=\"{ width: '700px' }\"\n  styleClass=\"export-dialog\"\n>\n  <ng-template pTemplate=\"header\">\n    <div class=\"custom-header\">\n      <i class=\"pi pi-download header-icon\"></i>\n      <span>{{ t('export_data_title') }}</span>\n    </div>\n  </ng-template>\n\n  <div class=\"export-content\">\n    <!-- Formato de Exporta\u00E7\u00E3o -->\n    <div class=\"export-section\">\n      <div class=\"section-header\">\n        <div class=\"section-icon\">\n          <i class=\"pi pi-file\"></i>\n        </div>\n        <h3>{{ t('export_format_title') }}</h3>\n      </div>\n      <div class=\"format-options\">\n        <div\n          *ngFor=\"let format of formats\"\n          class=\"format-card\"\n          [class.selected]=\"exportFormat === format.value\"\n          (click)=\"exportFormat = format.value\"\n        >\n          <div class=\"card-radio\">\n            <p-radioButton\n              [value]=\"format.value\"\n              [(ngModel)]=\"exportFormat\"\n              [inputId]=\"format.value\"\n            ></p-radioButton>\n          </div>\n          <div class=\"card-icon\" [class.excel]=\"format.value === 'xlsx'\" [class.pdf]=\"format.value === 'pdf'\">\n            <i class=\"pi\" [ngClass]=\"format.icon\"></i>\n          </div>\n          <div class=\"card-info\">\n            <label [for]=\"format.value\" class=\"card-label\">{{ format.label }}</label>\n            <span class=\"card-description\">{{ format.description }}</span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <!-- Escopo de Exporta\u00E7\u00E3o -->\n    <div class=\"export-section\">\n      <div class=\"section-header\">\n        <div class=\"section-icon\">\n          <i class=\"pi pi-filter\"></i>\n        </div>\n        <h3>{{ t('export_scope_title') }}</h3>\n      </div>\n      <div class=\"scope-options\">\n        <div\n          *ngFor=\"let scope of scopes\"\n          class=\"scope-card\"\n          [class.selected]=\"exportScope === scope.value\"\n          [class.disabled]=\"scope.value === 'selected' && selectedRecords.length === 0\"\n          (click)=\"scope.value === 'selected' && selectedRecords.length === 0 ? null : exportScope = scope.value\"\n        >\n          <div class=\"card-radio\">\n            <p-radioButton\n              [value]=\"scope.value\"\n              [(ngModel)]=\"exportScope\"\n              [inputId]=\"scope.value\"\n              [disabled]=\"scope.value === 'selected' && selectedRecords.length === 0\"\n            ></p-radioButton>\n          </div>\n          <div class=\"card-icon\">\n            <i class=\"pi\" [ngClass]=\"scope.icon\"></i>\n          </div>\n          <div class=\"card-info\">\n            <label [for]=\"scope.value\" class=\"card-label\">{{ scope.label }}</label>\n            <span class=\"card-description\">{{ scope.description }}</span>\n            <span class=\"card-count\">\n              <i class=\"pi pi-circle-fill\"></i>\n              {{ scope.value === 'all' ? allRecords.length : selectedRecords.length }} {{ t('export_records_count') }}\n            </span>\n          </div>\n        </div>\n      </div>\n    </div>\n\n    <!-- Sele\u00E7\u00E3o de Colunas -->\n    <div class=\"export-section\">\n      <div class=\"section-header\">\n        <div class=\"section-icon\">\n          <i class=\"pi pi-table\"></i>\n        </div>\n        <h3>{{ t('export_columns_title') }}</h3>\n        <div class=\"column-actions\">\n          <button type=\"button\" class=\"action-link\" (click)=\"selectAllColumns()\">\n            {{ t('export_select_all_columns') }}\n          </button>\n          <span class=\"separator\">|</span>\n          <button type=\"button\" class=\"action-link\" (click)=\"deselectAllColumns()\">\n            {{ t('export_clear_selection') }}\n          </button>\n        </div>\n      </div>\n      <div class=\"columns-grid\">\n        <div\n          *ngFor=\"let column of columns\"\n          class=\"column-item\"\n          [class.selected]=\"column.selected\"\n          (click)=\"column.selected = !column.selected\"\n        >\n          <p-checkbox\n            [(ngModel)]=\"column.selected\"\n            [binary]=\"true\"\n            [inputId]=\"column.field\"\n          ></p-checkbox>\n          <label [for]=\"column.field\" class=\"column-label\">\n            {{ column.header }}\n          </label>\n        </div>\n      </div>\n      <div class=\"columns-summary\">\n        <i class=\"pi pi-info-circle\"></i>\n        <span>{{ selectedColumnsCount }} {{ t('export_columns_summary') }} {{ columns.length }} {{ t('export_columns_selected') }}</span>\n      </div>\n    </div>\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <p-button\n      [label]=\"t('cancel')\"\n      icon=\"pi pi-times\"\n      severity=\"secondary\"\n      [text]=\"true\"\n      (onClick)=\"onHide()\"\n    ></p-button>\n    <p-button\n      [label]=\"t('export_button')\"\n      icon=\"pi pi-download\"\n      [disabled]=\"!canExport\"\n      (onClick)=\"export()\"\n    ></p-button>\n  </ng-template>\n</p-dialog>\n", styles: ["::ng-deep .export-dialog .p-dialog{border-radius:16px;overflow:hidden;box-shadow:0 20px 60px #0000004d}::ng-deep .export-dialog .p-dialog-content{padding:0;background:#fff;max-height:70vh;overflow-y:auto}.custom-header{display:flex;align-items:center;gap:12px;font-size:18px;font-weight:600}.custom-header .header-icon{font-size:22px;color:var(--p-primary-500)}.export-content{padding:28px 32px}.export-section{margin-bottom:32px}.export-section:last-child{margin-bottom:0}.export-section .section-header{display:flex;align-items:center;gap:12px;margin-bottom:20px}.export-section .section-header .section-icon{width:36px;height:36px;display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.1),rgba(var(--p-primary-rgb),.15));border-radius:10px}.export-section .section-header .section-icon i{font-size:18px;color:var(--p-primary-500)}.export-section .section-header h3{margin:0;font-size:17px;font-weight:700;color:var(--neutral-color-800);flex:1}.export-section .section-header .column-actions{display:flex;align-items:center;gap:10px;font-size:13px}.export-section .section-header .column-actions .action-link{background:none;border:none;color:var(--p-primary-500);cursor:pointer;font-weight:600;padding:0;transition:all .2s;font-size:13px}.export-section .section-header .column-actions .action-link:hover{color:var(--p-primary-500)}.export-section .section-header .column-actions .separator{color:var(--neutral-color-300);font-weight:400}.format-options{display:grid;grid-template-columns:repeat(2,1fr);gap:16px}.format-card{display:flex;align-items:center;gap:16px;padding:20px;border:2px solid #e5e7eb;border-radius:12px;cursor:pointer;transition:all .3s cubic-bezier(.4,0,.2,1);background:#fff;position:relative;overflow:hidden}.format-card:before{content:\"\";position:absolute;inset:0;background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.03),rgba(var(--p-primary-rgb),.06));opacity:0;transition:opacity .3s}.format-card:hover{border-color:var(--p-primary-500);transform:translateY(-2px);box-shadow:0 8px 24px rgba(var(--p-primary-rgb),.15)}.format-card:hover:before{opacity:1}.format-card.selected{border-color:var(--p-primary-500);background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.05),rgba(var(--p-primary-rgb),.08));box-shadow:0 0 0 4px rgba(var(--p-primary-rgb),.1)}.format-card.selected .card-icon{background:linear-gradient(135deg,var(--p-primary-500) 0%,var(--p-primary-500) 100%);transform:scale(1.05)}.format-card.selected .card-icon i{color:#fff}.format-card .card-radio ::ng-deep .p-radiobutton .p-radiobutton-box{width:20px;height:20px;border-width:2px}.format-card .card-icon{width:52px;height:52px;display:flex;align-items:center;justify-content:center;border-radius:12px;transition:all .3s;position:relative;z-index:1}.format-card .card-icon.excel{background:linear-gradient(135deg,var(--p-primary-50) 0%,var(--p-primary-100) 100%)}.format-card .card-icon.excel i{color:#107c41;font-size:26px}.format-card .card-icon.pdf{background:linear-gradient(135deg,#fee8e8,#fdd4d4)}.format-card .card-icon.pdf i{color:#dc2626;font-size:26px}.format-card .card-info{flex:1;display:flex;flex-direction:column;gap:4px;position:relative;z-index:1}.format-card .card-label{font-size:16px;font-weight:700;color:var(--neutral-color-800);cursor:pointer;margin:0}.format-card .card-description{font-size:13px;color:var(--neutral-color-600);line-height:1.4}.scope-options{display:flex;flex-direction:column;gap:14px}.scope-card{display:flex;align-items:center;gap:16px;padding:20px;border:2px solid #e5e7eb;border-radius:12px;cursor:pointer;transition:all .3s cubic-bezier(.4,0,.2,1);background:#fff;position:relative;overflow:hidden}.scope-card:before{content:\"\";position:absolute;inset:0;background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.03),rgba(var(--p-primary-rgb),.06));opacity:0;transition:opacity .3s}.scope-card:hover:not(.disabled){border-color:var(--p-primary-500);box-shadow:0 4px 16px rgba(var(--p-primary-rgb),.12)}.scope-card:hover:not(.disabled):before{opacity:1}.scope-card.selected{border-color:var(--p-primary-500);background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.05),rgba(var(--p-primary-rgb),.08));box-shadow:0 0 0 4px rgba(var(--p-primary-rgb),.1)}.scope-card.selected .card-icon{background:linear-gradient(135deg,var(--p-primary-500) 0%,var(--p-primary-500) 100%);transform:scale(1.05)}.scope-card.selected .card-icon i{color:#fff}.scope-card.disabled{opacity:.5;cursor:not-allowed;background:#f9fafb}.scope-card.disabled:hover{border-color:#e5e7eb;box-shadow:none}.scope-card .card-radio ::ng-deep .p-radiobutton .p-radiobutton-box{width:20px;height:20px;border-width:2px}.scope-card .card-icon{width:48px;height:48px;display:flex;align-items:center;justify-content:center;background:linear-gradient(135deg,var(--p-primary-50) 0%,var(--p-primary-100) 100%);border-radius:12px;transition:all .3s;position:relative;z-index:1}.scope-card .card-icon i{font-size:22px;color:var(--p-primary-500);transition:all .3s}.scope-card .card-info{flex:1;display:flex;flex-direction:column;gap:4px;position:relative;z-index:1}.scope-card .card-label{font-size:16px;font-weight:700;color:var(--neutral-color-800);cursor:pointer;margin:0}.scope-card .card-description{font-size:13px;color:var(--neutral-color-600);line-height:1.4}.scope-card .card-count{font-size:13px;font-weight:600;color:var(--p-primary-500);margin-top:6px;display:inline-flex;align-items:center;gap:6px}.scope-card .card-count i{font-size:6px}.columns-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin-bottom:16px}.column-item{display:flex;align-items:center;gap:12px;padding:16px;border:2px solid #e5e7eb;border-radius:10px;transition:all .2s;background:#fff;cursor:pointer}.column-item:hover{border-color:var(--p-primary-500);background:rgba(var(--p-primary-rgb),.03)}.column-item.selected{border-color:var(--p-primary-500);background:linear-gradient(135deg,rgba(var(--p-primary-rgb),.05),rgba(var(--p-primary-rgb),.08))}.column-item ::ng-deep .p-checkbox .p-checkbox-box{width:20px;height:20px;border-width:2px}.column-item .column-label{font-size:14px;font-weight:600;color:var(--neutral-color-800);cursor:pointer;margin:0;-webkit-user-select:none;user-select:none}.columns-summary{display:flex;align-items:center;gap:10px;padding:14px 18px;background:linear-gradient(135deg,var(--p-primary-50) 0%,var(--p-primary-100) 100%);border-radius:10px;font-size:14px;color:var(--neutral-color-700);font-weight:600}.columns-summary i{color:var(--p-primary-500);font-size:18px}@media (max-width: 768px){::ng-deep .export-dialog .p-dialog{width:95vw!important;margin:0}.dialog-header{padding:28px 24px}.dialog-header .header-icon-wrapper{width:56px;height:56px}.dialog-header .header-icon-wrapper i{font-size:28px}.dialog-header .header-text h2{font-size:24px}.export-content{padding:24px}.format-options,.columns-grid{grid-template-columns:1fr}}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['TranslationService']
+                }] }], propDecorators: { visible: [{
+                type: Input
+            }], allRecords: [{
+                type: Input
+            }], selectedRecords: [{
+                type: Input
+            }], statusLabels: [{
+                type: Input
+            }], translationPrefix: [{
+                type: Input
+            }], availableColumns: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }] } });
+
+class BulkDeleteDialogComponent {
+    translationService;
+    visible = false;
+    stages = []; // Generic entities
+    service; // Generic service
+    entityNameField = 'name'; // Field to display entity name
+    entityCodeField = 'code'; // Field to display entity code (optional)
+    translationPrefix = 'crmx.business';
+    visibleChange = new EventEmitter();
+    onComplete = new EventEmitter();
+    deleteStatuses = [];
+    isProcessing = false;
+    isCompleted = false;
+    currentIndex = 0;
+    successCount = 0;
+    errorCount = 0;
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    t(key, params) {
+        if (this.translationService) {
+            const fullKey = `${this.translationPrefix}.${key}`;
+            const translated = this.translationService.translate(fullKey, params);
+            // Se params foi fornecido e a tradução contém placeholders, fazer replace manual
+            if (params && translated.includes('{{')) {
+                return Object.keys(params).reduce((text, key) => {
+                    return text.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), params[key]);
+                }, translated);
+            }
+            return translated;
+        }
+        return key;
+    }
+    ngOnChanges() {
+        if (this.visible && this.stages.length > 0) {
+            this.initializeStatuses();
+        }
+    }
+    initializeStatuses() {
+        this.deleteStatuses = this.stages.map(entity => ({
+            entity,
+            status: 'pending'
+        }));
+        this.isProcessing = false;
+        this.isCompleted = false;
+        this.currentIndex = 0;
+        this.successCount = 0;
+        this.errorCount = 0;
+    }
+    get progress() {
+        if (this.deleteStatuses.length === 0)
+            return 0;
+        return Math.round((this.currentIndex / this.deleteStatuses.length) * 100);
+    }
+    get canClose() {
+        return !this.isProcessing || this.isCompleted;
+    }
+    startDeletion() {
+        if (!this.service) {
+            console.error('Service not provided to BulkDeleteDialogComponent');
+            return;
+        }
+        this.isProcessing = true;
+        this.isCompleted = false;
+        // Process deletions sequentially
+        from(this.deleteStatuses)
+            .pipe(concatMap((deleteStatus, index) => {
+            this.currentIndex = index;
+            deleteStatus.status = 'processing';
+            return this.service.delete(deleteStatus.entity.id).pipe(concatMap(() => {
+                deleteStatus.status = 'success';
+                this.successCount++;
+                return of(null);
+            }), catchError$1((error) => {
+                // Check if it's actually a success (204 No Content)
+                if (error?.status === 204) {
+                    deleteStatus.status = 'success';
+                    this.successCount++;
+                }
+                else {
+                    deleteStatus.status = 'error';
+                    deleteStatus.errorMessage = error?.message || error?.statusText || this.t('bulk_delete_error_generic');
+                    this.errorCount++;
+                }
+                return of(null);
+            }));
+        }))
+            .subscribe({
+            complete: () => {
+                this.currentIndex = this.deleteStatuses.length;
+                this.isCompleted = true;
+                this.isProcessing = false;
+            }
+        });
+    }
+    onHide() {
+        if (!this.canClose)
+            return;
+        this.visible = false;
+        this.visibleChange.emit(false);
+        if (this.isCompleted && this.successCount > 0) {
+            this.onComplete.emit();
+        }
+    }
+    onClose() {
+        this.onHide();
+    }
+    getStatusSeverity(status) {
+        switch (status) {
+            case 'pending': return 'secondary';
+            case 'processing': return 'info';
+            case 'success': return 'success';
+            case 'error': return 'danger';
+            default: return 'secondary';
+        }
+    }
+    getStatusLabel(status) {
+        return this.t(`bulk_delete_status_${status}`);
+    }
+    getStatusIcon(status) {
+        switch (status) {
+            case 'pending': return 'pi pi-clock';
+            case 'processing': return 'pi pi-spin pi-spinner';
+            case 'success': return 'pi pi-check';
+            case 'error': return 'pi pi-times';
+            default: return 'pi pi-question';
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BulkDeleteDialogComponent, deps: [{ token: 'TranslationService', optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: BulkDeleteDialogComponent, isStandalone: true, selector: "sia-bulk-delete-dialog", inputs: { visible: "visible", stages: "stages", service: "service", entityNameField: "entityNameField", entityCodeField: "entityCodeField", translationPrefix: "translationPrefix" }, outputs: { visibleChange: "visibleChange", onComplete: "onComplete" }, usesOnChanges: true, ngImport: i0, template: "<p-dialog\n  [(visible)]=\"visible\"\n  [modal]=\"true\"\n  [closable]=\"canClose\"\n  [closeOnEscape]=\"canClose\"\n  [dismissableMask]=\"false\"\n  [style]=\"{ width: '700px', maxWidth: '90vw' }\"\n  (onHide)=\"onHide()\"\n>\n  <ng-template pTemplate=\"header\">\n    <div class=\"dialog-header\">\n      <i class=\"pi pi-trash header-icon\"></i>\n      <h2>{{ t('bulk_delete_title') }}</h2>\n    </div>\n  </ng-template>\n\n  <div class=\"dialog-content\">\n    <!-- Summary -->\n    @if (!isProcessing && !isCompleted) {\n      <div class=\"summary-section\">\n        <p class=\"summary-text\">\n          <i class=\"pi pi-exclamation-triangle warning-icon\"></i>\n          <span [innerHTML]=\"t('bulk_delete_warning', { count: stages.length })\"></span>\n        </p>\n        <p class=\"summary-description\">\n          {{ t('bulk_delete_description') }}\n        </p>\n      </div>\n    }\n\n    <!-- Progress Bar -->\n    @if (isProcessing || isCompleted) {\n      <div class=\"progress-section\">\n        <div class=\"progress-info\">\n          <span class=\"progress-label\">{{ t('bulk_delete_progress') }}</span>\n          <span class=\"progress-count\">{{ currentIndex }} / {{ deleteStatuses.length }}</span>\n        </div>\n        <p-progressBar \n          [value]=\"progress\" \n          [showValue]=\"false\"\n          styleClass=\"custom-progress\"\n        ></p-progressBar>\n        \n        <div class=\"progress-stats\">\n          <div class=\"stat success\">\n            <i class=\"pi pi-check-circle\"></i>\n            <span>{{ successCount }} {{ t('bulk_delete_success_count') }}</span>\n          </div>\n          @if (errorCount > 0) {\n            <div class=\"stat error\">\n              <i class=\"pi pi-times-circle\"></i>\n              <span>{{ errorCount }} {{ t('bulk_delete_error_count') }}</span>\n            </div>\n          }\n        </div>\n      </div>\n    }\n\n    <!-- Status List -->\n    @if (isProcessing || isCompleted) {\n      <div class=\"status-list\">\n        @for (item of deleteStatuses; track item.entity) {\n          <div class=\"status-item\">\n            <div class=\"status-info\">\n              <i [class]=\"getStatusIcon(item.status)\" class=\"status-icon\"></i>\n              <div class=\"status-details\">\n                <span class=\"stage-name\">{{ item.entity[entityNameField] }}</span>\n                @if (item.entity[entityCodeField]) {\n                  <span class=\"stage-code\">{{ t('bulk_delete_code_label') }}: {{ item.entity[entityCodeField] }}</span>\n                }\n              </div>\n            </div>\n            <div class=\"status-badge\">\n              <p-tag \n                [value]=\"getStatusLabel(item.status)\" \n                [severity]=\"getStatusSeverity(item.status)\"\n              >\n                @if (item.status === 'processing') {\n                  <i class=\"pi pi-spin pi-spinner\"></i>\n                }\n              </p-tag>\n              @if (item.status === 'error' && item.errorMessage) {\n                <small class=\"error-message\">\n                  {{ item.errorMessage }}\n                </small>\n              }\n            </div>\n          </div>\n        }\n      </div>\n    }\n\n    <!-- Completion Message -->\n    @if (isCompleted) {\n      <div class=\"completion-section\">\n        <div class=\"completion-message\" [class.has-errors]=\"errorCount > 0\">\n          <i [class]=\"errorCount > 0 ? 'pi pi-exclamation-circle' : 'pi pi-check-circle'\" class=\"completion-icon\"></i>\n          @if (errorCount === 0) {\n            <p>\n              {{ t('bulk_delete_success_message') }}\n            </p>\n          }\n          @if (errorCount > 0) {\n            <p>\n              {{ t('bulk_delete_completed_with_errors', { count: errorCount }) }}\n            </p>\n          }\n        </div>\n      </div>\n    }\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"dialog-footer\">\n      @if (!isProcessing && !isCompleted) {\n        <p-button\n          [label]=\"t('cancel')\"\n          icon=\"pi pi-times\"\n          severity=\"secondary\"\n          [outlined]=\"true\"\n          (onClick)=\"onClose()\"\n        ></p-button>\n        <p-button\n          [label]=\"t('bulk_delete_confirm')\"\n          icon=\"pi pi-trash\"\n          severity=\"danger\"\n          (onClick)=\"startDeletion()\"\n        ></p-button>\n      }\n      @if (isCompleted) {\n        <p-button\n          [label]=\"t('close')\"\n          icon=\"pi pi-check\"\n          (onClick)=\"onClose()\"\n        ></p-button>\n      }\n    </div>\n  </ng-template>\n</p-dialog>\n", styles: [".dialog-header{display:flex;align-items:center;gap:12px}.dialog-header .header-icon{font-size:24px;color:#ef4444}.dialog-header h2{margin:0;font-size:20px;font-weight:700;color:var(--neutral-color-800)}.dialog-content{padding:8px 0}.summary-section{padding:20px;background:linear-gradient(135deg,#fef3c7,#fde68a);border-radius:12px;border:1px solid #fbbf24;margin-bottom:24px}.summary-section .summary-text{display:flex;align-items:center;gap:12px;margin:0 0 12px;font-size:16px;color:var(--neutral-color-800)}.summary-section .summary-text .warning-icon{font-size:24px;color:#f59e0b}.summary-section .summary-text strong{color:#d97706}.summary-section .summary-description{margin:0;font-size:14px;color:var(--neutral-color-600);padding-left:36px}.progress-section{margin-bottom:24px}.progress-section .progress-info{display:flex;justify-content:space-between;align-items:center;margin-bottom:12px}.progress-section .progress-info .progress-label{font-weight:600;font-size:14px;color:var(--neutral-color-800)}.progress-section .progress-info .progress-count{font-size:14px;color:var(--neutral-color-600);font-weight:500}.progress-section .progress-stats{display:flex;gap:20px;margin-top:12px}.progress-section .progress-stats .stat{display:flex;align-items:center;gap:8px;font-size:14px;font-weight:500}.progress-section .progress-stats .stat.success{color:#10b981}.progress-section .progress-stats .stat.success i{font-size:18px}.progress-section .progress-stats .stat.error{color:#ef4444}.progress-section .progress-stats .stat.error i{font-size:18px}.status-list{max-height:400px;overflow-y:auto;border:1px solid var(--p-surface-200);border-radius:12px;padding:12px;background-color:#fafafa}.status-list .status-item{display:flex;justify-content:space-between;align-items:center;padding:12px;background-color:#fff;border-radius:8px;margin-bottom:8px;transition:all .2s ease}.status-list .status-item:last-child{margin-bottom:0}.status-list .status-item:hover{box-shadow:0 2px 8px #00000014}.status-list .status-item .status-info{display:flex;align-items:center;gap:12px;flex:1}.status-list .status-item .status-info .status-icon{font-size:20px}.status-list .status-item .status-info .status-icon.pi-clock{color:var(--neutral-color-400)}.status-list .status-item .status-info .status-icon.pi-spinner{color:#3b82f6}.status-list .status-item .status-info .status-icon.pi-check{color:#10b981}.status-list .status-item .status-info .status-icon.pi-times{color:#ef4444}.status-list .status-item .status-info .status-details{display:flex;flex-direction:column;gap:4px}.status-list .status-item .status-info .status-details .stage-name{font-weight:600;font-size:14px;color:var(--neutral-color-800)}.status-list .status-item .status-info .status-details .stage-code{font-size:12px;color:var(--neutral-color-500)}.status-list .status-item .status-badge{display:flex;flex-direction:column;align-items:flex-end;gap:4px}.status-list .status-item .status-badge .error-message{font-size:11px;color:#ef4444;max-width:200px;text-align:right}.completion-section{margin-top:24px}.completion-section .completion-message{padding:20px;background:linear-gradient(135deg,#d1fae5,#a7f3d0);border-radius:12px;border:1px solid #10b981;display:flex;align-items:center;gap:16px}.completion-section .completion-message.has-errors{background:linear-gradient(135deg,#fee2e2,#fecaca);border-color:#ef4444}.completion-section .completion-message.has-errors .completion-icon{color:#ef4444}.completion-section .completion-message .completion-icon{font-size:32px;color:#10b981}.completion-section .completion-message p{margin:0;font-size:16px;font-weight:600;color:var(--neutral-color-800)}.dialog-footer{display:flex;justify-content:flex-end;gap:12px}::ng-deep .custom-progress{height:12px;border-radius:6px}::ng-deep .custom-progress .p-progressbar-value{background:linear-gradient(90deg,var(--p-primary-500) 0%,var(--p-primary-500) 100%);border-radius:6px}.status-list::-webkit-scrollbar{width:8px}.status-list::-webkit-scrollbar-track{background:var(--p-surface-100);border-radius:4px}.status-list::-webkit-scrollbar-thumb{background:var(--neutral-color-400);border-radius:4px}.status-list::-webkit-scrollbar-thumb:hover{background:var(--neutral-color-500)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: DialogModule }, { kind: "component", type: i3.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: i5.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i5$1.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "variant", "style", "styleClass", "badgeClass", "badgeSeverity", "ariaLabel", "autofocus", "fluid", "buttonProps"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "ngmodule", type: ProgressBarModule }, { kind: "component", type: i4.ProgressBar, selector: "p-progressBar, p-progressbar, p-progress-bar", inputs: ["value", "showValue", "styleClass", "valueStyleClass", "style", "unit", "mode", "color"] }, { kind: "ngmodule", type: TagModule }, { kind: "component", type: i5$2.Tag, selector: "p-tag", inputs: ["style", "styleClass", "severity", "value", "icon", "rounded"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BulkDeleteDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-bulk-delete-dialog', standalone: true, imports: [
+                        CommonModule,
+                        DialogModule,
+                        ButtonModule,
+                        ProgressBarModule,
+                        TagModule
+                    ], template: "<p-dialog\n  [(visible)]=\"visible\"\n  [modal]=\"true\"\n  [closable]=\"canClose\"\n  [closeOnEscape]=\"canClose\"\n  [dismissableMask]=\"false\"\n  [style]=\"{ width: '700px', maxWidth: '90vw' }\"\n  (onHide)=\"onHide()\"\n>\n  <ng-template pTemplate=\"header\">\n    <div class=\"dialog-header\">\n      <i class=\"pi pi-trash header-icon\"></i>\n      <h2>{{ t('bulk_delete_title') }}</h2>\n    </div>\n  </ng-template>\n\n  <div class=\"dialog-content\">\n    <!-- Summary -->\n    @if (!isProcessing && !isCompleted) {\n      <div class=\"summary-section\">\n        <p class=\"summary-text\">\n          <i class=\"pi pi-exclamation-triangle warning-icon\"></i>\n          <span [innerHTML]=\"t('bulk_delete_warning', { count: stages.length })\"></span>\n        </p>\n        <p class=\"summary-description\">\n          {{ t('bulk_delete_description') }}\n        </p>\n      </div>\n    }\n\n    <!-- Progress Bar -->\n    @if (isProcessing || isCompleted) {\n      <div class=\"progress-section\">\n        <div class=\"progress-info\">\n          <span class=\"progress-label\">{{ t('bulk_delete_progress') }}</span>\n          <span class=\"progress-count\">{{ currentIndex }} / {{ deleteStatuses.length }}</span>\n        </div>\n        <p-progressBar \n          [value]=\"progress\" \n          [showValue]=\"false\"\n          styleClass=\"custom-progress\"\n        ></p-progressBar>\n        \n        <div class=\"progress-stats\">\n          <div class=\"stat success\">\n            <i class=\"pi pi-check-circle\"></i>\n            <span>{{ successCount }} {{ t('bulk_delete_success_count') }}</span>\n          </div>\n          @if (errorCount > 0) {\n            <div class=\"stat error\">\n              <i class=\"pi pi-times-circle\"></i>\n              <span>{{ errorCount }} {{ t('bulk_delete_error_count') }}</span>\n            </div>\n          }\n        </div>\n      </div>\n    }\n\n    <!-- Status List -->\n    @if (isProcessing || isCompleted) {\n      <div class=\"status-list\">\n        @for (item of deleteStatuses; track item.entity) {\n          <div class=\"status-item\">\n            <div class=\"status-info\">\n              <i [class]=\"getStatusIcon(item.status)\" class=\"status-icon\"></i>\n              <div class=\"status-details\">\n                <span class=\"stage-name\">{{ item.entity[entityNameField] }}</span>\n                @if (item.entity[entityCodeField]) {\n                  <span class=\"stage-code\">{{ t('bulk_delete_code_label') }}: {{ item.entity[entityCodeField] }}</span>\n                }\n              </div>\n            </div>\n            <div class=\"status-badge\">\n              <p-tag \n                [value]=\"getStatusLabel(item.status)\" \n                [severity]=\"getStatusSeverity(item.status)\"\n              >\n                @if (item.status === 'processing') {\n                  <i class=\"pi pi-spin pi-spinner\"></i>\n                }\n              </p-tag>\n              @if (item.status === 'error' && item.errorMessage) {\n                <small class=\"error-message\">\n                  {{ item.errorMessage }}\n                </small>\n              }\n            </div>\n          </div>\n        }\n      </div>\n    }\n\n    <!-- Completion Message -->\n    @if (isCompleted) {\n      <div class=\"completion-section\">\n        <div class=\"completion-message\" [class.has-errors]=\"errorCount > 0\">\n          <i [class]=\"errorCount > 0 ? 'pi pi-exclamation-circle' : 'pi pi-check-circle'\" class=\"completion-icon\"></i>\n          @if (errorCount === 0) {\n            <p>\n              {{ t('bulk_delete_success_message') }}\n            </p>\n          }\n          @if (errorCount > 0) {\n            <p>\n              {{ t('bulk_delete_completed_with_errors', { count: errorCount }) }}\n            </p>\n          }\n        </div>\n      </div>\n    }\n  </div>\n\n  <ng-template pTemplate=\"footer\">\n    <div class=\"dialog-footer\">\n      @if (!isProcessing && !isCompleted) {\n        <p-button\n          [label]=\"t('cancel')\"\n          icon=\"pi pi-times\"\n          severity=\"secondary\"\n          [outlined]=\"true\"\n          (onClick)=\"onClose()\"\n        ></p-button>\n        <p-button\n          [label]=\"t('bulk_delete_confirm')\"\n          icon=\"pi pi-trash\"\n          severity=\"danger\"\n          (onClick)=\"startDeletion()\"\n        ></p-button>\n      }\n      @if (isCompleted) {\n        <p-button\n          [label]=\"t('close')\"\n          icon=\"pi pi-check\"\n          (onClick)=\"onClose()\"\n        ></p-button>\n      }\n    </div>\n  </ng-template>\n</p-dialog>\n", styles: [".dialog-header{display:flex;align-items:center;gap:12px}.dialog-header .header-icon{font-size:24px;color:#ef4444}.dialog-header h2{margin:0;font-size:20px;font-weight:700;color:var(--neutral-color-800)}.dialog-content{padding:8px 0}.summary-section{padding:20px;background:linear-gradient(135deg,#fef3c7,#fde68a);border-radius:12px;border:1px solid #fbbf24;margin-bottom:24px}.summary-section .summary-text{display:flex;align-items:center;gap:12px;margin:0 0 12px;font-size:16px;color:var(--neutral-color-800)}.summary-section .summary-text .warning-icon{font-size:24px;color:#f59e0b}.summary-section .summary-text strong{color:#d97706}.summary-section .summary-description{margin:0;font-size:14px;color:var(--neutral-color-600);padding-left:36px}.progress-section{margin-bottom:24px}.progress-section .progress-info{display:flex;justify-content:space-between;align-items:center;margin-bottom:12px}.progress-section .progress-info .progress-label{font-weight:600;font-size:14px;color:var(--neutral-color-800)}.progress-section .progress-info .progress-count{font-size:14px;color:var(--neutral-color-600);font-weight:500}.progress-section .progress-stats{display:flex;gap:20px;margin-top:12px}.progress-section .progress-stats .stat{display:flex;align-items:center;gap:8px;font-size:14px;font-weight:500}.progress-section .progress-stats .stat.success{color:#10b981}.progress-section .progress-stats .stat.success i{font-size:18px}.progress-section .progress-stats .stat.error{color:#ef4444}.progress-section .progress-stats .stat.error i{font-size:18px}.status-list{max-height:400px;overflow-y:auto;border:1px solid var(--p-surface-200);border-radius:12px;padding:12px;background-color:#fafafa}.status-list .status-item{display:flex;justify-content:space-between;align-items:center;padding:12px;background-color:#fff;border-radius:8px;margin-bottom:8px;transition:all .2s ease}.status-list .status-item:last-child{margin-bottom:0}.status-list .status-item:hover{box-shadow:0 2px 8px #00000014}.status-list .status-item .status-info{display:flex;align-items:center;gap:12px;flex:1}.status-list .status-item .status-info .status-icon{font-size:20px}.status-list .status-item .status-info .status-icon.pi-clock{color:var(--neutral-color-400)}.status-list .status-item .status-info .status-icon.pi-spinner{color:#3b82f6}.status-list .status-item .status-info .status-icon.pi-check{color:#10b981}.status-list .status-item .status-info .status-icon.pi-times{color:#ef4444}.status-list .status-item .status-info .status-details{display:flex;flex-direction:column;gap:4px}.status-list .status-item .status-info .status-details .stage-name{font-weight:600;font-size:14px;color:var(--neutral-color-800)}.status-list .status-item .status-info .status-details .stage-code{font-size:12px;color:var(--neutral-color-500)}.status-list .status-item .status-badge{display:flex;flex-direction:column;align-items:flex-end;gap:4px}.status-list .status-item .status-badge .error-message{font-size:11px;color:#ef4444;max-width:200px;text-align:right}.completion-section{margin-top:24px}.completion-section .completion-message{padding:20px;background:linear-gradient(135deg,#d1fae5,#a7f3d0);border-radius:12px;border:1px solid #10b981;display:flex;align-items:center;gap:16px}.completion-section .completion-message.has-errors{background:linear-gradient(135deg,#fee2e2,#fecaca);border-color:#ef4444}.completion-section .completion-message.has-errors .completion-icon{color:#ef4444}.completion-section .completion-message .completion-icon{font-size:32px;color:#10b981}.completion-section .completion-message p{margin:0;font-size:16px;font-weight:600;color:var(--neutral-color-800)}.dialog-footer{display:flex;justify-content:flex-end;gap:12px}::ng-deep .custom-progress{height:12px;border-radius:6px}::ng-deep .custom-progress .p-progressbar-value{background:linear-gradient(90deg,var(--p-primary-500) 0%,var(--p-primary-500) 100%);border-radius:6px}.status-list::-webkit-scrollbar{width:8px}.status-list::-webkit-scrollbar-track{background:var(--p-surface-100);border-radius:4px}.status-list::-webkit-scrollbar-thumb{background:var(--neutral-color-400);border-radius:4px}.status-list::-webkit-scrollbar-thumb:hover{background:var(--neutral-color-500)}\n"] }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['TranslationService']
+                }] }], propDecorators: { visible: [{
+                type: Input
+            }], stages: [{
+                type: Input
+            }], service: [{
+                type: Input
+            }], entityNameField: [{
+                type: Input
+            }], entityCodeField: [{
+                type: Input
+            }], translationPrefix: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }], onComplete: [{
+                type: Output
+            }] } });
+
+class BreadcrumbComponent {
+    router;
+    activatedRoute;
+    translationService;
+    translationPrefix = 'crmx.business';
+    isProduction = false;
+    breadcrumbItems = [];
+    constructor(router, activatedRoute, translationService) {
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.translationService = translationService;
+    }
+    ngOnInit() {
+        this.buildBreadcrumbs();
+        // Atualiza breadcrumbs quando a navegação muda
+        this.router.events
+            .pipe(filter(event => event instanceof NavigationEnd))
+            .subscribe(() => this.buildBreadcrumbs());
+    }
+    get homeItem() {
+        // Só mostra o link do home em desenvolvimento
+        if (!this.isProduction) {
+            return {
+                icon: 'pi pi-home',
+                routerLink: '/main',
+                title: this.t('breadcrumb_home')
+            };
+        }
+        // Em produção, o home não tem link (apenas ícone)
+        return {
+            icon: 'pi pi-home',
+            title: this.t('breadcrumb_home'),
+            disabled: true
+        };
+    }
+    buildBreadcrumbs() {
+        const breadcrumbs = [];
+        let currentRoute = this.activatedRoute.root;
+        let url = '';
+        let lastBreadcrumbLabel = '';
+        // Percorre toda a árvore de rotas
+        while (currentRoute) {
+            // Verifica se há segmentos de URL
+            if (currentRoute.snapshot.url.length > 0) {
+                const routeURL = currentRoute.snapshot.url.map(segment => segment.path).join('/');
+                url += `/${routeURL}`;
+            }
+            // Verifica se a rota tem dados de breadcrumb
+            const breadcrumbData = currentRoute.snapshot.data['breadcrumb'];
+            // Adiciona o breadcrumb se existir e não for duplicado
+            if (breadcrumbData) {
+                const label = this.t(breadcrumbData.title);
+                // Só adiciona se não for o mesmo label do anterior (evita duplicação)
+                if (label !== lastBreadcrumbLabel) {
+                    breadcrumbs.push({
+                        label: label,
+                        icon: breadcrumbData.icon,
+                        routerLink: url || undefined
+                    });
+                    lastBreadcrumbLabel = label;
+                }
+            }
+            // Move para a próxima rota filha
+            currentRoute = currentRoute.firstChild;
+        }
+        // O último item não deve ter link (está desabilitado)
+        if (breadcrumbs.length > 0) {
+            const lastItem = breadcrumbs[breadcrumbs.length - 1];
+            lastItem.routerLink = undefined;
+            lastItem.disabled = true;
+        }
+        this.breadcrumbItems = breadcrumbs;
+    }
+    t(key) {
+        if (this.translationService) {
+            // Se a chave já tem o prefixo, usa diretamente
+            if (key.includes('.')) {
+                return this.translationService.translate(key);
+            }
+            // Caso contrário, adiciona o prefixo
+            return this.translationService.translate(`${this.translationPrefix}.${key}`);
+        }
+        return key;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbComponent, deps: [{ token: i1$1.Router }, { token: i1$1.ActivatedRoute }, { token: 'TranslationService', optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: BreadcrumbComponent, isStandalone: true, selector: "sia-breadcrumb", inputs: { translationPrefix: "translationPrefix", isProduction: "isProduction" }, ngImport: i0, template: `
+    <p-breadcrumb 
+      [model]="breadcrumbItems" 
+      [home]="homeItem"
+      styleClass="custom-breadcrumb"
+    ></p-breadcrumb>
+  `, isInline: true, styles: ["::ng-deep .p-breadcrumb{background:transparent;border:none;padding:0!important}::ng-deep .custom-breadcrumb{background:transparent;border:none;padding:0!important;.p-breadcrumb-list{background:transparent;padding:0!important;.p-menuitem{.p-menuitem-link{color:var(--text-secondary);text-decoration:none;font-size:14px;font-weight:500;padding:8px 12px;border-radius:6px;transition:all .2s ease;display:flex;align-items:center;&:hover{background:var(--p-primary-50);color:var(--p-primary-600)}.p-menuitem-icon{margin-right:8px;font-size:16px;display:inline-flex;align-items:center}}&:last-child .p-menuitem-link{color:var(--p-primary-600);font-weight:600;background:var(--p-primary-50)}}.p-breadcrumb-separator{color:var(--text-muted);margin:0 8px;font-size:14px}}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: RouterModule }, { kind: "ngmodule", type: BreadcrumbModule }, { kind: "component", type: i2$2.Breadcrumb, selector: "p-breadcrumb", inputs: ["model", "style", "styleClass", "home", "homeAriaLabel"], outputs: ["onItemClick"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-breadcrumb', standalone: true, imports: [CommonModule, RouterModule, BreadcrumbModule], template: `
+    <p-breadcrumb 
+      [model]="breadcrumbItems" 
+      [home]="homeItem"
+      styleClass="custom-breadcrumb"
+    ></p-breadcrumb>
+  `, styles: ["::ng-deep .p-breadcrumb{background:transparent;border:none;padding:0!important}::ng-deep .custom-breadcrumb{background:transparent;border:none;padding:0!important;.p-breadcrumb-list{background:transparent;padding:0!important;.p-menuitem{.p-menuitem-link{color:var(--text-secondary);text-decoration:none;font-size:14px;font-weight:500;padding:8px 12px;border-radius:6px;transition:all .2s ease;display:flex;align-items:center;&:hover{background:var(--p-primary-50);color:var(--p-primary-600)}.p-menuitem-icon{margin-right:8px;font-size:16px;display:inline-flex;align-items:center}}&:last-child .p-menuitem-link{color:var(--p-primary-600);font-weight:600;background:var(--p-primary-50)}}.p-breadcrumb-separator{color:var(--text-muted);margin:0 8px;font-size:14px}}}\n"] }]
+        }], ctorParameters: () => [{ type: i1$1.Router }, { type: i1$1.ActivatedRoute }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['TranslationService']
+                }] }], propDecorators: { translationPrefix: [{
+                type: Input
+            }], isProduction: [{
+                type: Input
+            }] } });
+
+class TranslatePipe {
+    translationService;
+    cdr;
+    subscription;
+    lastKey;
+    lastParams;
+    lastTranslation;
+    isLoading = false;
+    constructor(translationService, cdr) {
+        this.translationService = translationService;
+        this.cdr = cdr;
+    }
+    transform(key, params) {
+        if (!key)
+            return '';
+        // Check if we need to update the translation
+        if (this.shouldUpdate(key, params)) {
+            this.updateTranslation(key, params);
+        }
+        return this.lastTranslation || key;
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    shouldUpdate(key, params) {
+        return this.lastKey !== key ||
+            JSON.stringify(this.lastParams) !== JSON.stringify(params) ||
+            !this.subscription;
+    }
+    updateTranslation(key, params) {
+        this.lastKey = key;
+        this.lastParams = params;
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+        // Aguardar carregamento das traduções se necessário
+        if (!this.translationService.isLanguageLoaded()) {
+            if (!this.isLoading) {
+                this.isLoading = true;
+                this.translationService.waitForTranslations().then(() => {
+                    this.isLoading = false;
+                    this.lastTranslation = this.translationService.translate(key, params);
+                    this.cdr.markForCheck();
+                }).catch(error => {
+                    this.isLoading = false;
+                    console.error('Error waiting for translations:', error);
+                    this.lastTranslation = key;
+                    this.cdr.markForCheck();
+                });
+            }
+            return;
+        }
+        this.subscription = this.translationService.currentLanguage$.subscribe(() => {
+            this.lastTranslation = this.translationService.translate(key, params);
+            this.cdr.markForCheck();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, deps: [{ token: TranslationService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: TranslatePipe, isStandalone: true, 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,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: TranslationService }, { type: i0.ChangeDetectorRef }] });
+
+class CepMaskDirective {
+    el;
+    constructor(el) {
+        this.el = el;
+    }
+    onKeyPress(event) {
+        // Permite apenas números
+        const charCode = event.which ? event.which : event.keyCode;
+        if (charCode > 31 && (charCode < 48 || charCode > 57)) {
+            event.preventDefault();
+            return false;
+        }
+        return true;
+    }
+    onInput(event) {
+        const value = event.target.value;
+        this.applyCepMask(value);
+    }
+    onBlur(event) {
+        const value = event.target.value;
+        this.applyCepMask(value);
+    }
+    onPaste(event) {
+        event.preventDefault();
+        const pastedText = event.clipboardData?.getData('text') || '';
+        const numbers = pastedText.replace(/\D/g, '');
+        this.applyCepMask(numbers);
+    }
+    applyCepMask(value) {
+        if (!value) {
+            this.el.nativeElement.value = '';
+            return;
+        }
+        // Remove todos os caracteres não numéricos
+        const numbers = value.replace(/\D/g, '');
+        // Limita a 8 dígitos
+        const limitedNumbers = numbers.substring(0, 8);
+        // Aplica a máscara 00000-000
+        let maskedValue = '';
+        if (limitedNumbers.length === 0) {
+            maskedValue = '';
+        }
+        else if (limitedNumbers.length <= 5) {
+            maskedValue = limitedNumbers;
+        }
+        else {
+            maskedValue = limitedNumbers.replace(/(\d{5})(\d{0,3})/, '$1-$2');
+        }
+        // Atualizar o valor do input
+        this.el.nativeElement.value = maskedValue;
+        // Disparar evento de input para atualizar o FormControl
+        const inputEvent = new Event('input', { bubbles: true });
+        this.el.nativeElement.dispatchEvent(inputEvent);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CepMaskDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: CepMaskDirective, isStandalone: true, selector: "[siaCepMask]", host: { listeners: { "keypress": "onKeyPress($event)", "input": "onInput($event)", "blur": "onBlur($event)", "paste": "onPaste($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CepMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[siaCepMask]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { onKeyPress: [{
+                type: HostListener,
+                args: ['keypress', ['$event']]
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }], onPaste: [{
+                type: HostListener,
+                args: ['paste', ['$event']]
+            }] } });
+
+class PhoneMaskDirective {
+    el;
+    constructor(el) {
+        this.el = el;
+    }
+    onInput(event) {
+        const value = event.target.value;
+        this.applyPhoneMask(value);
+    }
+    onBlur(event) {
+        const value = event.target.value;
+        this.applyPhoneMask(value);
+    }
+    applyPhoneMask(value) {
+        if (!value)
+            return;
+        // Remove todos os caracteres não numéricos
+        const numbers = value.replace(/\D/g, '');
+        let maskedValue = '';
+        if (numbers.length <= 10) {
+            // Telefone fixo: (00) 0000-0000
+            maskedValue = numbers.replace(/(\d{2})(\d{4})(\d{4})/, '($1) $2-$3');
+        }
+        else if (numbers.length === 11) {
+            // Celular: (00) 00000-0000
+            maskedValue = numbers.replace(/(\d{2})(\d{5})(\d{4})/, '($1) $2-$3');
+        }
+        else {
+            // Limitar a 11 dígitos
+            const limitedNumbers = numbers.substring(0, 11);
+            maskedValue = limitedNumbers.replace(/(\d{2})(\d{5})(\d{4})/, '($1) $2-$3');
+        }
+        // Atualizar o valor do input apenas se mudou
+        if (maskedValue && maskedValue !== value) {
+            this.el.nativeElement.value = maskedValue;
+            // Disparar evento de input para atualizar o FormControl
+            const inputEvent = new Event('input', { bubbles: true });
+            this.el.nativeElement.dispatchEvent(inputEvent);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PhoneMaskDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: PhoneMaskDirective, isStandalone: true, selector: "[siaPhoneMask]", host: { listeners: { "input": "onInput($event)", "blur": "onBlur($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PhoneMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[siaPhoneMask]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }] } });
+
+class MaskService {
+    /**
+     * Aplica máscara de CPF (999.999.999-99) - 100% numérico
+     */
+    applyCpfMask(value) {
+        if (!value)
+            return '';
+        // Remove todos os caracteres não numéricos
+        const numbers = value.replace(/\D/g, '');
+        // Limita a 11 dígitos
+        const limitedNumbers = numbers.substring(0, 11);
+        // Aplica a máscara progressivamente
+        if (limitedNumbers.length <= 3) {
+            return limitedNumbers;
+        }
+        else if (limitedNumbers.length <= 6) {
+            return limitedNumbers.replace(/(\d{3})(\d+)/, '$1.$2');
+        }
+        else if (limitedNumbers.length <= 9) {
+            return limitedNumbers.replace(/(\d{3})(\d{3})(\d+)/, '$1.$2.$3');
+        }
+        else {
+            return limitedNumbers.replace(/(\d{3})(\d{3})(\d{3})(\d+)/, '$1.$2.$3-$4');
+        }
+    }
+    /**
+     * Aplica máscara de CNPJ alfanumérico (XX.XXX.XXX/XXXX-XX)
+     * Aceita letras e números em todos os caracteres
+     */
+    applyCnpjMask(value) {
+        if (!value)
+            return '';
+        // Remove caracteres especiais, mantém letras e números
+        const cleaned = value.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+        // Limita a 14 caracteres
+        const limitedChars = cleaned.substring(0, 14);
+        // Aplica a máscara progressivamente
+        if (limitedChars.length <= 2) {
+            return limitedChars;
+        }
+        else if (limitedChars.length <= 5) {
+            return limitedChars.replace(/(\w{2})(\w+)/, '$1.$2');
+        }
+        else if (limitedChars.length <= 8) {
+            return limitedChars.replace(/(\w{2})(\w{3})(\w+)/, '$1.$2.$3');
+        }
+        else if (limitedChars.length <= 12) {
+            return limitedChars.replace(/(\w{2})(\w{3})(\w{3})(\w+)/, '$1.$2.$3/$4');
+        }
+        else {
+            return limitedChars.replace(/(\w{2})(\w{3})(\w{3})(\w{4})(\w+)/, '$1.$2.$3/$4-$5');
+        }
+    }
+    /**
+     * Aplica a máscara apropriada baseada no tipo de pessoa
+     * CPF: 100% numérico (999.999.999-99)
+     * CNPJ: alfanumérico (XX.XXX.XXX/XXXX-XX)
+     */
+    applyDocumentMask(value, typePerson) {
+        if (!value)
+            return '';
+        if (typePerson === 'NATURAL_PERSON') {
+            return this.applyCpfMask(value);
+        }
+        else {
+            return this.applyCnpjMask(value);
+        }
+    }
+    /**
+     * Remove a máscara de um documento (mantém apenas alfanuméricos)
+     */
+    removeMask(value) {
+        if (!value)
+            return '';
+        return value.replace(/[^a-zA-Z0-9]/g, '');
+    }
+    /**
+     * Determina se um documento é CPF ou CNPJ baseado no comprimento
+     */
+    getDocumentType(value) {
+        if (!value)
+            return 'unknown';
+        const cleaned = this.removeMask(value);
+        if (cleaned.length <= 11) {
+            return 'cpf';
+        }
+        else if (cleaned.length <= 14) {
+            return 'cnpj';
+        }
+        return 'unknown';
+    }
+    /**
+     * Valida se um CPF tem formato válido (11 dígitos numéricos)
+     */
+    isValidCpfFormat(value) {
+        if (!value)
+            return false;
+        const cleaned = value.replace(/\D/g, '');
+        return cleaned.length === 11 && /^\d{11}$/.test(cleaned);
+    }
+    /**
+     * Valida se um CNPJ tem formato válido (14 caracteres alfanuméricos)
+     */
+    isValidCnpjFormat(value) {
+        if (!value)
+            return false;
+        const cleaned = this.removeMask(value);
+        return cleaned.length === 14;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MaskService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MaskService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MaskService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class DocumentMaskDirective {
+    el;
+    control;
+    maskService;
+    documentType = 'auto';
+    allowAlphanumeric = false;
+    typePerson;
+    constructor(el, control, maskService) {
+        this.el = el;
+        this.control = control;
+        this.maskService = maskService;
+    }
+    ngOnInit() {
+        // Aplicar máscara inicial se já houver valor
+        if (this.control.value) {
+            this.applyMask(this.control.value);
+        }
+    }
+    onInput(event) {
+        const value = event.target.value;
+        this.applyMask(value);
+    }
+    onBlur(event) {
+        const value = event.target.value;
+        this.applyMask(value);
+    }
+    applyMask(value) {
+        if (!value) {
+            this.control.control?.setValue('', { emitEvent: false });
+            return;
+        }
+        const masked = this.maskService.applyDocumentMask(value, this.typePerson || 'JURIDICAL_PERSON');
+        this.control.control?.setValue(masked, { emitEvent: false });
+        this.el.nativeElement.value = masked;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DocumentMaskDirective, deps: [{ token: i0.ElementRef }, { token: i2$1.NgControl }, { token: MaskService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DocumentMaskDirective, isStandalone: true, selector: "[siaDocumentMask]", inputs: { documentType: "documentType", allowAlphanumeric: "allowAlphanumeric", typePerson: "typePerson" }, host: { listeners: { "input": "onInput($event)", "blur": "onBlur($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DocumentMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[siaDocumentMask]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i2$1.NgControl }, { type: MaskService }], propDecorators: { documentType: [{
+                type: Input
+            }], allowAlphanumeric: [{
+                type: Input
+            }], typePerson: [{
+                type: Input
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }] } });
+
+/**
+ * Componente wrapper para campos de formulário dinâmico
+ * Centraliza a renderização de label, campo e mensagem de erro
+ */
+class DynamicFieldWrapperComponent {
+    translationService;
+    field;
+    form;
+    mode = 'form';
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    isRequired() {
+        return this.field.required === true && this.mode === 'form';
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    getFieldError() {
+        const control = this.form.get(this.field.field);
+        if (control?.hasError('required')) {
+            return this.translationService.translate('crmx.business.required_field');
+        }
+        if (control?.hasError('minlength')) {
+            const minLength = this.field.minLength || control.errors?.['minlength'].requiredLength;
+            return this.translationService.translate('crmx.business.min_length_error', { length: minLength });
+        }
+        if (control?.hasError('maxlength')) {
+            const maxLength = this.field.maxLength || control.errors?.['maxlength'].requiredLength;
+            return this.translationService.translate('crmx.business.max_length_error', { length: maxLength });
+        }
+        if (control?.hasError('min')) {
+            const min = this.field.min || control.errors?.['min'].min;
+            return this.translationService.translate('crmx.business.min_value_error', { value: min });
+        }
+        if (control?.hasError('max')) {
+            const max = this.field.max || control.errors?.['max'].max;
+            return this.translationService.translate('crmx.business.max_value_error', { value: max });
+        }
+        return '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldWrapperComponent, deps: [{ token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldWrapperComponent, isStandalone: true, selector: "sia-dynamic-field-wrapper", inputs: { field: "field", form: "form", mode: "mode" }, ngImport: i0, template: `
+    <div class="field">
+      <label [for]="field.field">
+        {{ field.label | translate }}
+        <span *ngIf="isRequired()" class="required-asterisk">*</span>
+      </label>
+      
+      <!-- Conteúdo do campo (projetado via ng-content) -->
+      <ng-content></ng-content>
+      
+      <small *ngIf="isFieldInvalid()" class="p-error">
+        {{ getFieldError() }}
+      </small>
+    </div>
+  `, isInline: true, styles: [".field{display:flex;flex-direction:column;gap:.5rem;label{font-weight:500;color:var(--text-color);.required-asterisk{color:var(--p-red-500);margin-left:.25rem}}small.p-error{margin-top:.25rem;color:var(--p-red-500)}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { 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: DynamicFieldWrapperComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-wrapper', standalone: true, imports: [
+                        CommonModule,
+                        TranslatePipe
+                    ], template: `
+    <div class="field">
+      <label [for]="field.field">
+        {{ field.label | translate }}
+        <span *ngIf="isRequired()" class="required-asterisk">*</span>
+      </label>
+      
+      <!-- Conteúdo do campo (projetado via ng-content) -->
+      <ng-content></ng-content>
+      
+      <small *ngIf="isFieldInvalid()" class="p-error">
+        {{ getFieldError() }}
+      </small>
+    </div>
+  `, styles: [".field{display:flex;flex-direction:column;gap:.5rem;label{font-weight:500;color:var(--text-color);.required-asterisk{color:var(--p-red-500);margin-left:.25rem}}small.p-error{margin-top:.25rem;color:var(--p-red-500)}}\n"] }]
+        }], ctorParameters: () => [{ type: TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+
+class DynamicFieldTextComponent {
+    translationService;
+    field;
+    form;
+    mode = 'form';
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    isFieldDirty() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.dirty);
+    }
+    getPlaceholder() {
+        if (this.mode === 'filter') {
+            return this.translationService.translate('crmx.business.filter_search_placeholder', {
+                label: this.field.label.toLowerCase()
+            });
+        }
+        return this.field.placeholder || '';
+    }
+    getDocumentType() {
+        const typePersonValue = this.form?.get('typePerson')?.value;
+        return typePersonValue || 'JURIDICAL_PERSON';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldTextComponent, deps: [{ token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldTextComponent, isStandalone: true, selector: "sia-dynamic-field-text", inputs: { field: "field", form: "form", mode: "mode" }, ngImport: i0, template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <input
+          *ngIf="!field.mask"
+          pInputText
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+        
+        <!-- Input com máscara CEP -->
+        <input
+          *ngIf="field.mask === 'cep'"
+          pInputText
+          appCepMask
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+        
+        <!-- Input com máscara Telefone -->
+        <input
+          *ngIf="field.mask === 'phone'"
+          pInputText
+          appPhoneMask
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+        
+        <!-- Input com máscara Documento -->
+        <input
+          *ngIf="field.mask === 'document'"
+          pInputText
+          appDocumentMask
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, isInline: true, styles: ["input{width:100%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$1.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { kind: "directive", type: i2$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i4$1.InputText, selector: "[pInputText]", inputs: ["variant", "fluid", "pSize"] }, { kind: "component", type: DynamicFieldWrapperComponent, selector: "sia-dynamic-field-wrapper", inputs: ["field", "form", "mode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldTextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-text', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        InputTextModule,
+                        CepMaskDirective,
+                        PhoneMaskDirective,
+                        DocumentMaskDirective,
+                        DynamicFieldWrapperComponent
+                    ], template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <input
+          *ngIf="!field.mask"
+          pInputText
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+        
+        <!-- Input com máscara CEP -->
+        <input
+          *ngIf="field.mask === 'cep'"
+          pInputText
+          appCepMask
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+        
+        <!-- Input com máscara Telefone -->
+        <input
+          *ngIf="field.mask === 'phone'"
+          pInputText
+          appPhoneMask
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+        
+        <!-- Input com máscara Documento -->
+        <input
+          *ngIf="field.mask === 'document'"
+          pInputText
+          appDocumentMask
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()" />
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, styles: ["input{width:100%}\n"] }]
+        }], ctorParameters: () => [{ type: TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+
+class DynamicFieldNumberComponent {
+    translationService;
+    field;
+    form;
+    mode = 'form';
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    isFieldDirty() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.dirty);
+    }
+    getPlaceholder() {
+        if (this.mode === 'filter') {
+            return this.translationService.translate('crmx.business.filter_search_placeholder', {
+                label: this.field.label.toLowerCase()
+            });
+        }
+        return this.field.placeholder || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldNumberComponent, deps: [{ token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldNumberComponent, isStandalone: true, selector: "sia-dynamic-field-number", inputs: { field: "field", form: "form", mode: "mode" }, ngImport: i0, template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <p-inputNumber
+          [inputId]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [min]="field.min"
+          [max]="field.max"
+          [minFractionDigits]="field.minFractionDigits || 0"
+          [maxFractionDigits]="field.maxFractionDigits || 2"
+          [mode]="field.numberMode || 'decimal'"
+          [currency]="field.currency || 'BRL'"
+          [locale]="field.locale || 'pt-BR'"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()"
+          styleClass="w-full">
+        </p-inputNumber>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, isInline: true, styles: ["::ng-deep p-inputNumber{width:100%;.p-inputnumber,input{width:100%}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: InputNumberModule }, { kind: "component", type: i3$1.InputNumber, selector: "p-inputNumber, p-inputnumber, p-input-number", inputs: ["showButtons", "format", "buttonLayout", "inputId", "styleClass", "style", "placeholder", "size", "maxlength", "tabindex", "title", "ariaLabelledBy", "ariaLabel", "ariaRequired", "name", "required", "autocomplete", "min", "max", "incrementButtonClass", "decrementButtonClass", "incrementButtonIcon", "decrementButtonIcon", "readonly", "step", "allowEmpty", "locale", "localeMatcher", "mode", "currency", "currencyDisplay", "useGrouping", "variant", "minFractionDigits", "maxFractionDigits", "prefix", "suffix", "inputStyle", "inputStyleClass", "showClear", "autofocus", "disabled", "fluid"], outputs: ["onInput", "onFocus", "onBlur", "onKeyDown", "onClear"] }, { kind: "component", type: DynamicFieldWrapperComponent, selector: "sia-dynamic-field-wrapper", inputs: ["field", "form", "mode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldNumberComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-number', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        InputNumberModule,
+                        DynamicFieldWrapperComponent
+                    ], template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <p-inputNumber
+          [inputId]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [min]="field.min"
+          [max]="field.max"
+          [minFractionDigits]="field.minFractionDigits || 0"
+          [maxFractionDigits]="field.maxFractionDigits || 2"
+          [mode]="field.numberMode || 'decimal'"
+          [currency]="field.currency || 'BRL'"
+          [locale]="field.locale || 'pt-BR'"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()"
+          styleClass="w-full">
+        </p-inputNumber>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, styles: ["::ng-deep p-inputNumber{width:100%;.p-inputnumber,input{width:100%}}\n"] }]
+        }], ctorParameters: () => [{ type: TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+
+class DynamicFieldDateComponent {
+    translationService;
+    field;
+    form;
+    mode = 'form';
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    isFieldDirty() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.dirty);
+    }
+    getPlaceholder() {
+        if (this.mode === 'filter') {
+            return this.translationService.translate('crmx.business.filter_select_placeholder', {
+                label: this.field.label.toLowerCase()
+            });
+        }
+        return this.field.placeholder || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldDateComponent, deps: [{ token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldDateComponent, isStandalone: true, selector: "sia-dynamic-field-date", inputs: { field: "field", form: "form", mode: "mode" }, ngImport: i0, template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <p-calendar
+          [inputId]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [dateFormat]="field.dateFormat || 'dd/mm/yy'"
+          [showIcon]="true"
+          [showButtonBar]="true"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()"
+          [appendTo]="'body'"
+          styleClass="w-full">
+        </p-calendar>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, isInline: true, styles: ["::ng-deep p-calendar{width:100%;.p-calendar,input{width:100%}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: CalendarModule }, { kind: "component", type: i3$2.Calendar, selector: "p-calendar", inputs: ["iconDisplay", "style", "styleClass", "inputStyle", "inputId", "name", "inputStyleClass", "placeholder", "ariaLabelledBy", "ariaLabel", "iconAriaLabel", "disabled", "dateFormat", "multipleSeparator", "rangeSeparator", "inline", "showOtherMonths", "selectOtherMonths", "showIcon", "fluid", "icon", "appendTo", "readonlyInput", "shortYearCutoff", "monthNavigator", "yearNavigator", "hourFormat", "timeOnly", "stepHour", "stepMinute", "stepSecond", "showSeconds", "required", "showOnFocus", "showWeek", "startWeekFromFirstDayOfYear", "showClear", "dataType", "selectionMode", "maxDateCount", "showButtonBar", "todayButtonStyleClass", "clearButtonStyleClass", "autofocus", "autoZIndex", "baseZIndex", "panelStyleClass", "panelStyle", "keepInvalid", "hideOnDateTimeSelect", "touchUI", "timeSeparator", "focusTrap", "showTransitionOptions", "hideTransitionOptions", "tabindex", "variant", "minDate", "maxDate", "disabledDates", "disabledDays", "yearRange", "showTime", "responsiveOptions", "numberOfMonths", "firstDayOfWeek", "locale", "view", "defaultDate"], outputs: ["onFocus", "onBlur", "onClose", "onSelect", "onClear", "onInput", "onTodayClick", "onClearClick", "onMonthChange", "onYearChange", "onClickOutside", "onShow"] }, { kind: "component", type: DynamicFieldWrapperComponent, selector: "sia-dynamic-field-wrapper", inputs: ["field", "form", "mode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldDateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-date', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        CalendarModule,
+                        DynamicFieldWrapperComponent
+                    ], template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <p-calendar
+          [inputId]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [dateFormat]="field.dateFormat || 'dd/mm/yy'"
+          [showIcon]="true"
+          [showButtonBar]="true"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()"
+          [appendTo]="'body'"
+          styleClass="w-full">
+        </p-calendar>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, styles: ["::ng-deep p-calendar{width:100%;.p-calendar,input{width:100%}}\n"] }]
+        }], ctorParameters: () => [{ type: TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+
+class DynamicFieldDropdownComponent {
+    translationService;
+    field;
+    form;
+    mode = 'form';
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    isFieldDirty() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.dirty);
+    }
+    getPlaceholder() {
+        if (this.mode === 'filter') {
+            return this.translationService.translate('crmx.business.filter_select_placeholder', {
+                label: this.field.label.toLowerCase()
+            });
+        }
+        return this.field.placeholder || this.translationService.translate('crmx.business.select_option');
+    }
+    getOptions() {
+        if (this.field.type === 'enum' && this.field.enumValues) {
+            return this.field.enumValues.map(value => ({
+                label: this.field.enumLabels?.[value] || value,
+                value: value
+            }));
+        }
+        return this.field.options || [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldDropdownComponent, deps: [{ token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldDropdownComponent, isStandalone: true, selector: "sia-dynamic-field-dropdown", inputs: { field: "field", form: "form", mode: "mode" }, ngImport: i0, template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <p-dropdown
+          [inputId]="field.field"
+          [formControlName]="field.field"
+          [options]="getOptions()"
+          [optionLabel]="field.optionLabel || 'label'"
+          [optionValue]="field.optionValue || 'value'"
+          [placeholder]="getPlaceholder()"
+          [showClear]="mode === 'filter' || field.showClear"
+          [filter]="field.filter || false"
+          [filterBy]="field.filterBy"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()"
+          [appendTo]="'body'"
+          panelStyleClass="dynamic-form-dropdown-panel"
+          styleClass="w-full">
+        </p-dropdown>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, isInline: true, styles: ["::ng-deep p-dropdown{width:100%;.p-dropdown{width:100%}}.dynamic-form-dropdown-panel{min-width:100%!important}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: DropdownModule }, { kind: "component", type: i3$3.Dropdown, selector: "p-dropdown", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "fluid", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }, { kind: "component", type: DynamicFieldWrapperComponent, selector: "sia-dynamic-field-wrapper", inputs: ["field", "form", "mode"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldDropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-dropdown', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        DropdownModule,
+                        DynamicFieldWrapperComponent
+                    ], template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <p-dropdown
+          [inputId]="field.field"
+          [formControlName]="field.field"
+          [options]="getOptions()"
+          [optionLabel]="field.optionLabel || 'label'"
+          [optionValue]="field.optionValue || 'value'"
+          [placeholder]="getPlaceholder()"
+          [showClear]="mode === 'filter' || field.showClear"
+          [filter]="field.filter || false"
+          [filterBy]="field.filterBy"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()"
+          [appendTo]="'body'"
+          panelStyleClass="dynamic-form-dropdown-panel"
+          styleClass="w-full">
+        </p-dropdown>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, encapsulation: ViewEncapsulation.None, styles: ["::ng-deep p-dropdown{width:100%;.p-dropdown{width:100%}}.dynamic-form-dropdown-panel{min-width:100%!important}\n"] }]
+        }], ctorParameters: () => [{ type: TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+
+class DynamicFieldLookupComponent {
+    translationService;
+    field;
+    form;
+    formGroup;
+    mode = 'form';
+    displayValue = '';
+    showLookupDialog = false;
+    loading = false;
+    searchTerm = '';
+    data = [];
+    filteredData = [];
+    totalRecords = 0;
+    currentPage = 0;
+    pageSize = 5;
+    selectedItem = null;
+    columns = [];
+    displayField = 'name';
+    valueField = 'id';
+    searchFields = ['name'];
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    ngOnInit() {
+        this.setupLookupConfig();
+        this.watchValueChanges();
+    }
+    watchValueChanges() {
+        const control = this.form.get(this.field.field);
+        if (control) {
+            // Carregar valor inicial
+            if (control.value) {
+                this.handleValueDisplay(control.value);
+            }
+            // Observar mudanças
+            control.valueChanges.subscribe(value => {
+                if (value !== null && value !== undefined && value !== '') {
+                    this.handleValueDisplay(value);
+                }
+                else {
+                    this.displayValue = '';
+                }
+            });
+        }
+    }
+    get value() {
+        return this.form.get(this.field.field)?.value;
+    }
+    get currentValue() {
+        return this.value;
+    }
+    setValue(value) {
+        this.form.get(this.field.field)?.setValue(value);
+    }
+    setupLookupConfig() {
+        if (this.field) {
+            this.displayField = this.field.lookupDisplayField || 'name';
+            this.valueField = this.field.lookupValueField || 'id';
+            this.searchFields = this.field.lookupSearchFields || ['name'];
+            this.columns = this.field.lookupColumns || [
+                { field: this.displayField, header: 'Nome', width: '100%' }
+            ];
+        }
+    }
+    handleValueDisplay(value) {
+        if (value === null || value === undefined || value === '') {
+            this.displayValue = '';
+            return;
+        }
+        if (typeof value === 'object' && value !== null) {
+            this.displayValue = this.formatDisplayValue(value);
+            // Em modo filter, manter o objeto completo
+            // Em modo form, extrair apenas o ID EXCETO se já temos o objeto completo
+            // (evita requisições desnecessárias quando o objeto já está carregado)
+            if (this.mode === 'form') {
+                // Verificar se o objeto tem o campo de display preenchido
+                // Se tiver, significa que já temos os dados completos e não precisamos fazer nada
+                const hasDisplayData = this.field?.lookupDisplayFields
+                    ? this.field.lookupDisplayFields.some(f => this.getFieldValue(value, f))
+                    : value[this.displayField];
+                if (!hasDisplayData) {
+                    // Só extrair o ID se não temos os dados de display
+                    const newValue = value[this.valueField] || value.id || value;
+                    if (this.value !== newValue) {
+                        this.setValue(newValue);
+                    }
+                }
+            }
+            return;
+        }
+        // Se é um ID (string ou number), não fazer requisição
+        // Deixar vazio e só carregar quando abrir o lookup
+        if (typeof value === 'string' || typeof value === 'number') {
+            this.displayValue = '';
+            return;
+        }
+    }
+    formatDisplayValue(item) {
+        if (!item)
+            return '';
+        if (this.field?.lookupDisplayFields && this.field.lookupDisplayFields.length > 0) {
+            const values = this.field.lookupDisplayFields
+                .map(fieldName => this.getFieldValue(item, fieldName))
+                .filter(value => value !== null && value !== undefined && value !== '');
+            return values.join(' - ');
+        }
+        return this.getFieldValue(item, this.displayField) || '';
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    isFieldDisabled() {
+        const control = this.form.get(this.field.field);
+        return control?.disabled || false;
+    }
+    getPlaceholder() {
+        if (this.mode === 'filter') {
+            return this.translationService.translate('crmx.business.filter_search_placeholder', {
+                label: this.field.label.toLowerCase()
+            });
+        }
+        return this.field.placeholder || 'Clique para selecionar';
+    }
+    openLookup() {
+        if (this.isFieldDisabled()) {
+            return;
+        }
+        this.updateSelectedItem();
+        this.showLookupDialog = true;
+        this.currentPage = 0;
+        this.searchTerm = '';
+        this.loadData();
+    }
+    onDialogHide() {
+        this.searchTerm = '';
+        this.currentPage = 0;
+    }
+    onPageChange(event) {
+        if (!this.showLookupDialog) {
+            return;
+        }
+        this.currentPage = event.first / event.rows;
+        this.loadData();
+    }
+    loadData() {
+        if (!this.field?.lookupService) {
+            return;
+        }
+        this.loading = true;
+        const listParams = {
+            page: this.currentPage,
+            size: this.pageSize
+        };
+        if (this.searchTerm.trim()) {
+            const term = this.searchTerm.trim();
+            const filterConditions = [];
+            const isNumericTerm = !isNaN(Number(term)) && term !== '';
+            this.searchFields.forEach(field => {
+                const column = this.columns.find(col => col.field === field);
+                const fieldType = column?.type || 'text';
+                if (fieldType === 'number') {
+                    if (isNumericTerm) {
+                        filterConditions.push(`${field} eq ${term}`);
+                    }
+                }
+                else {
+                    const upperTerm = term.toUpperCase();
+                    filterConditions.push(`UPPER(${field}) like '%${upperTerm}%'`);
+                }
+            });
+            if (filterConditions.length > 0) {
+                listParams.filterQuery = filterConditions.join(' or ');
+            }
+        }
+        if (this.field.lookupFilters) {
+            Object.keys(this.field.lookupFilters).forEach(key => {
+                listParams[key] = this.field.lookupFilters[key];
+            });
+        }
+        if (this.field.lookupDynamicFilters && this.formGroup) {
+            const dynamicFilters = this.field.lookupDynamicFilters(this.formGroup.value);
+            const dynamicFilterConditions = [];
+            Object.keys(dynamicFilters).forEach(key => {
+                const value = dynamicFilters[key];
+                if (value !== null && value !== undefined) {
+                    dynamicFilterConditions.push(`${key} eq '${value}'`);
+                }
+            });
+            if (dynamicFilterConditions.length > 0) {
+                const dynamicFilterQuery = dynamicFilterConditions.join(' and ');
+                if (listParams.filterQuery) {
+                    listParams.filterQuery = `(${listParams.filterQuery}) and (${dynamicFilterQuery})`;
+                }
+                else {
+                    listParams.filterQuery = dynamicFilterQuery;
+                }
+            }
+        }
+        this.field.lookupService.list(listParams).subscribe({
+            next: (response) => {
+                this.data = response.contents || [];
+                this.filteredData = [...this.data];
+                this.totalRecords = response.totalElements || 0;
+                this.updateSelectedItem();
+                // Após carregar os dados da grid, se temos um valor selecionado mas sem displayValue,
+                // tentar encontrar o item nos dados carregados
+                if (this.value && !this.displayValue) {
+                    const item = this.filteredData.find(i => i[this.valueField] === this.value);
+                    if (item) {
+                        this.displayValue = this.formatDisplayValue(item);
+                    }
+                }
+                this.loading = false;
+            },
+            error: (_error) => {
+                this.data = [];
+                this.filteredData = [];
+                this.totalRecords = 0;
+                this.loading = false;
+            }
+        });
+    }
+    updateSelectedItem() {
+        if (!this.value) {
+            this.selectedItem = null;
+            return;
+        }
+        const item = this.filteredData.find(i => i[this.valueField] === this.value);
+        if (item) {
+            this.selectedItem = item;
+        }
+    }
+    onSearch() {
+        if (!this.showLookupDialog) {
+            return;
+        }
+        this.currentPage = 0;
+        this.loadData();
+    }
+    clearSearch() {
+        this.searchTerm = '';
+        this.currentPage = 0;
+        this.loadData();
+    }
+    selectItem(item) {
+        if (this.mode === 'filter') {
+            this.setValue(item);
+            this.displayValue = this.formatDisplayValue(item);
+        }
+        else {
+            const newValue = item[this.valueField];
+            this.setValue(newValue);
+            this.displayValue = this.formatDisplayValue(item);
+        }
+        this.showLookupDialog = false;
+    }
+    onRowSelect(event) {
+        this.selectItem(event.data);
+    }
+    clearValue() {
+        this.setValue(null);
+        this.displayValue = '';
+        this.selectedItem = null;
+    }
+    getFieldValue(item, field) {
+        return field.split('.').reduce((obj, key) => obj?.[key], item) || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldLookupComponent, deps: [{ token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldLookupComponent, isStandalone: true, selector: "sia-dynamic-field-lookup", inputs: { field: "field", form: "form", formGroup: "formGroup", mode: "mode" }, ngImport: i0, template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form" class="lookup-field" [ngClass]="{'disabled': isFieldDisabled()}">
+        <!-- Hidden input para o formControl -->
+        <input type="hidden" [formControlName]="field.field" />
+        
+        <div class="lookup-input-group">
+          <input
+            pInputText
+            [value]="displayValue"
+            [placeholder]="getPlaceholder()"
+            [class.p-invalid]="isFieldInvalid()"
+            [disabled]="isFieldDisabled()"
+            readonly
+            class="lookup-display"
+            (click)="openLookup()"
+          />
+          <div class="lookup-buttons">
+            <p-button
+              *ngIf="currentValue"
+              icon="pi pi-trash"
+              severity="danger"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="clearValue()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Limpar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+            <p-button
+              icon="pi pi-search"
+              severity="secondary"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="openLookup()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Buscar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+          </div>
+        </div>
+      </div>
+
+      <!-- Lookup Dialog -->
+      <p-dialog
+        [(visible)]="showLookupDialog"
+        [modal]="true"
+        [style]="{ width: '800px', maxHeight: '80vh' }"
+        [contentStyle]="{ maxHeight: 'calc(80vh - 120px)', overflow: 'auto' }"
+        [draggable]="false"
+        [resizable]="true"
+        [header]="'Selecionar ' + (field.label | translate)"
+        [appendTo]="'body'"
+        (onHide)="onDialogHide()"
+      >
+        <div class="lookup-dialog-content">
+          <!-- Search Input -->
+          <div class="search-wrapper">
+            <input
+              pInputText
+              [(ngModel)]="searchTerm"
+              [placeholder]="'Buscar ' + (field.label | translate).toLowerCase() + '...'"
+              (keydown.enter)="onSearch()"
+              class="search-input-full"
+            />
+            <div class="search-buttons-inside">
+              <p-button
+                *ngIf="searchTerm"
+                icon="pi pi-trash"
+                severity="danger"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="clearSearch()"
+                class="search-button-clear"
+                pTooltip="Limpar busca"
+                tooltipPosition="top"
+              ></p-button>
+              <p-button
+                icon="pi pi-search"
+                severity="secondary"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="onSearch()"
+                class="search-button-search"
+                pTooltip="Buscar"
+                tooltipPosition="top"
+              ></p-button>
+            </div>
+          </div>
+
+          <!-- Data Table -->
+          <p-table
+            [value]="filteredData"
+            [loading]="loading"
+            [paginator]="true"
+            [rows]="pageSize"
+            [totalRecords]="totalRecords"
+            [lazy]="true"
+            (onLazyLoad)="onPageChange($event)"
+            [showCurrentPageReport]="true"
+            currentPageReportTemplate="Mostrando {first} a {last} de {totalRecords} registros"
+            dataKey="id"
+            [rowHover]="true"
+            responsiveLayout="scroll"
+            styleClass="p-datatable-striped lookup-table"
+            [(selection)]="selectedItem"
+            (onRowSelect)="onRowSelect($event)"
+            selectionMode="single"
+          >
+            <ng-template pTemplate="header">
+              <tr>
+                <th *ngFor="let col of columns" [style.width]="col.width">
+                  {{ col.header }}
+                </th>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="body" let-item>
+              <tr [pSelectableRow]="item">
+                <td *ngFor="let col of columns">
+                  {{ getFieldValue(item, col.field) }}
+                </td>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="emptymessage">
+              <tr>
+                <td [attr.colspan]="columns.length" class="empty-message">
+                  <div class="empty-state">
+                    <i class="pi pi-search"></i>
+                    <p>Nenhum registro encontrado</p>
+                    <small>Tente ajustar os termos de busca</small>
+                  </div>
+                </td>
+              </tr>
+            </ng-template>
+          </p-table>
+        </div>
+      </p-dialog>
+    </sia-dynamic-field-wrapper>
+  `, isInline: true, styles: [".lookup-field{width:100%;position:relative}.lookup-input-group{position:relative;width:100%;.lookup-display{width:100%;cursor:pointer;height:2.857rem;padding:.75rem 4rem .75rem .75rem;font-size:1rem;line-height:1.5;box-sizing:border-box;display:flex;align-items:center;&:focus{outline:none}&:hover{background:transparent}}.lookup-buttons{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;z-index:10}::ng-deep .p-button{width:2rem!important;height:2rem!important;min-width:2rem!important;min-height:2rem!important;padding:0!important;margin:0!important;display:flex!important;align-items:center!important;justify-content:center!important;box-sizing:border-box!important;.p-button-icon{margin:0!important;font-size:.875rem!important}.p-button-label{display:none!important}}}.lookup-dialog-content{height:100%;display:flex;flex-direction:column;padding:0;.search-wrapper{position:relative;margin-bottom:16px;width:100%;.search-input-full{width:100%;padding-right:5.5rem}.search-buttons-inside{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;::ng-deep .p-button{width:2.5rem!important;height:2.5rem!important}}}.lookup-table{flex:1;.empty-state{text-align:center;padding:32px;color:var(--p-text-color-secondary);i{font-size:48px;margin-bottom:16px;display:block}p{margin:8px 0;font-size:16px}small{font-size:14px}}}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i5$1.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "variant", "style", "styleClass", "badgeClass", "badgeSeverity", "ariaLabel", "autofocus", "fluid", "buttonProps"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "directive", type: i5.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i4$1.InputText, selector: "[pInputText]", inputs: ["variant", "fluid", "pSize"] }, { kind: "ngmodule", type: DialogModule }, { kind: "component", type: i3.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: "ngmodule", type: TableModule }, { kind: "component", type: i8.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorStyleClass", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "size", "showGridlines", "stripedRows", "groupRowsByOrder", "responsiveLayout", "breakpoint", "paginatorLocale", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "virtualRowHeight", "selectAll"], outputs: ["contextMenuSelectionChange", "selectAllChange", "selectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i8.SelectableRow, selector: "[pSelectableRow]", inputs: ["pSelectableRow", "pSelectableRowIndex", "pSelectableRowDisabled"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i9.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "component", type: DynamicFieldWrapperComponent, selector: "sia-dynamic-field-wrapper", inputs: ["field", "form", "mode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldLookupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-lookup', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        FormsModule,
+                        ButtonModule,
+                        InputTextModule,
+                        DialogModule,
+                        TableModule,
+                        TooltipModule,
+                        TranslatePipe,
+                        DynamicFieldWrapperComponent
+                    ], template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form" class="lookup-field" [ngClass]="{'disabled': isFieldDisabled()}">
+        <!-- Hidden input para o formControl -->
+        <input type="hidden" [formControlName]="field.field" />
+        
+        <div class="lookup-input-group">
+          <input
+            pInputText
+            [value]="displayValue"
+            [placeholder]="getPlaceholder()"
+            [class.p-invalid]="isFieldInvalid()"
+            [disabled]="isFieldDisabled()"
+            readonly
+            class="lookup-display"
+            (click)="openLookup()"
+          />
+          <div class="lookup-buttons">
+            <p-button
+              *ngIf="currentValue"
+              icon="pi pi-trash"
+              severity="danger"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="clearValue()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Limpar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+            <p-button
+              icon="pi pi-search"
+              severity="secondary"
+              [text]="true"
+              [rounded]="true"
+              (onClick)="openLookup()"
+              [disabled]="isFieldDisabled()"
+              pTooltip="Buscar"
+              tooltipPosition="top"
+              size="small"
+            ></p-button>
+          </div>
+        </div>
+      </div>
+
+      <!-- Lookup Dialog -->
+      <p-dialog
+        [(visible)]="showLookupDialog"
+        [modal]="true"
+        [style]="{ width: '800px', maxHeight: '80vh' }"
+        [contentStyle]="{ maxHeight: 'calc(80vh - 120px)', overflow: 'auto' }"
+        [draggable]="false"
+        [resizable]="true"
+        [header]="'Selecionar ' + (field.label | translate)"
+        [appendTo]="'body'"
+        (onHide)="onDialogHide()"
+      >
+        <div class="lookup-dialog-content">
+          <!-- Search Input -->
+          <div class="search-wrapper">
+            <input
+              pInputText
+              [(ngModel)]="searchTerm"
+              [placeholder]="'Buscar ' + (field.label | translate).toLowerCase() + '...'"
+              (keydown.enter)="onSearch()"
+              class="search-input-full"
+            />
+            <div class="search-buttons-inside">
+              <p-button
+                *ngIf="searchTerm"
+                icon="pi pi-trash"
+                severity="danger"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="clearSearch()"
+                class="search-button-clear"
+                pTooltip="Limpar busca"
+                tooltipPosition="top"
+              ></p-button>
+              <p-button
+                icon="pi pi-search"
+                severity="secondary"
+                [text]="true"
+                [rounded]="true"
+                (onClick)="onSearch()"
+                class="search-button-search"
+                pTooltip="Buscar"
+                tooltipPosition="top"
+              ></p-button>
+            </div>
+          </div>
+
+          <!-- Data Table -->
+          <p-table
+            [value]="filteredData"
+            [loading]="loading"
+            [paginator]="true"
+            [rows]="pageSize"
+            [totalRecords]="totalRecords"
+            [lazy]="true"
+            (onLazyLoad)="onPageChange($event)"
+            [showCurrentPageReport]="true"
+            currentPageReportTemplate="Mostrando {first} a {last} de {totalRecords} registros"
+            dataKey="id"
+            [rowHover]="true"
+            responsiveLayout="scroll"
+            styleClass="p-datatable-striped lookup-table"
+            [(selection)]="selectedItem"
+            (onRowSelect)="onRowSelect($event)"
+            selectionMode="single"
+          >
+            <ng-template pTemplate="header">
+              <tr>
+                <th *ngFor="let col of columns" [style.width]="col.width">
+                  {{ col.header }}
+                </th>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="body" let-item>
+              <tr [pSelectableRow]="item">
+                <td *ngFor="let col of columns">
+                  {{ getFieldValue(item, col.field) }}
+                </td>
+              </tr>
+            </ng-template>
+
+            <ng-template pTemplate="emptymessage">
+              <tr>
+                <td [attr.colspan]="columns.length" class="empty-message">
+                  <div class="empty-state">
+                    <i class="pi pi-search"></i>
+                    <p>Nenhum registro encontrado</p>
+                    <small>Tente ajustar os termos de busca</small>
+                  </div>
+                </td>
+              </tr>
+            </ng-template>
+          </p-table>
+        </div>
+      </p-dialog>
+    </sia-dynamic-field-wrapper>
+  `, styles: [".lookup-field{width:100%;position:relative}.lookup-input-group{position:relative;width:100%;.lookup-display{width:100%;cursor:pointer;height:2.857rem;padding:.75rem 4rem .75rem .75rem;font-size:1rem;line-height:1.5;box-sizing:border-box;display:flex;align-items:center;&:focus{outline:none}&:hover{background:transparent}}.lookup-buttons{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;z-index:10}::ng-deep .p-button{width:2rem!important;height:2rem!important;min-width:2rem!important;min-height:2rem!important;padding:0!important;margin:0!important;display:flex!important;align-items:center!important;justify-content:center!important;box-sizing:border-box!important;.p-button-icon{margin:0!important;font-size:.875rem!important}.p-button-label{display:none!important}}}.lookup-dialog-content{height:100%;display:flex;flex-direction:column;padding:0;.search-wrapper{position:relative;margin-bottom:16px;width:100%;.search-input-full{width:100%;padding-right:5.5rem}.search-buttons-inside{position:absolute;right:4px;top:50%;transform:translateY(-50%);display:flex;gap:2px;::ng-deep .p-button{width:2.5rem!important;height:2.5rem!important}}}.lookup-table{flex:1;.empty-state{text-align:center;padding:32px;color:var(--p-text-color-secondary);i{font-size:48px;margin-bottom:16px;display:block}p{margin:8px 0;font-size:16px}small{font-size:14px}}}}\n"] }]
+        }], ctorParameters: () => [{ type: TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], formGroup: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+
+class DynamicFieldTextareaComponent {
+    translationService;
+    field;
+    form;
+    mode = 'form';
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    isFieldInvalid() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.invalid && (control.dirty || control.touched));
+    }
+    isFieldDirty() {
+        const control = this.form.get(this.field.field);
+        return !!(control && control.dirty);
+    }
+    getPlaceholder() {
+        if (this.mode === 'filter') {
+            return this.translationService.translate('crmx.business.filter_search_placeholder', {
+                label: this.field.label.toLowerCase()
+            });
+        }
+        return this.field.placeholder || '';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldTextareaComponent, deps: [{ token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFieldTextareaComponent, isStandalone: true, selector: "sia-dynamic-field-textarea", inputs: { field: "field", form: "form", mode: "mode" }, ngImport: i0, template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <textarea
+          pInputTextarea
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [rows]="field.rows || 3"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()">
+        </textarea>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, isInline: true, styles: ["textarea{width:100%;resize:vertical}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$1.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { kind: "directive", type: i2$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2$1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: InputTextarea, selector: "[pInputTextarea]", inputs: ["autoResize", "variant", "fluid"], outputs: ["onResize"] }, { kind: "component", type: DynamicFieldWrapperComponent, selector: "sia-dynamic-field-wrapper", inputs: ["field", "form", "mode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFieldTextareaComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-field-textarea', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        InputTextarea,
+                        DynamicFieldWrapperComponent
+                    ], template: `
+    <sia-dynamic-field-wrapper [field]="field" [form]="form" [mode]="mode">
+      <div [formGroup]="form">
+        <textarea
+          pInputTextarea
+          [id]="field.field"
+          [formControlName]="field.field"
+          [placeholder]="getPlaceholder()"
+          [rows]="field.rows || 3"
+          [maxlength]="field.maxLength || 524288"
+          [class.ng-invalid]="isFieldInvalid()"
+          [class.ng-dirty]="isFieldDirty()">
+        </textarea>
+      </div>
+    </sia-dynamic-field-wrapper>
+  `, styles: ["textarea{width:100%;resize:vertical}\n"] }]
+        }], ctorParameters: () => [{ type: TranslationService }], propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }] } });
+
+class DynamicFormComponent {
+    fb;
+    translationService;
+    formFields = [];
+    formSections = [];
+    fixedFilters = []; // Filtros fixos (sempre visíveis no topo)
+    filterSections = []; // Seções de filtros (colapsáveis)
+    entityData = null;
+    mode = 'form';
+    // Display Mode Configuration
+    displayMode = 'inline';
+    visible = false;
+    dialogConfig = {};
+    drawerConfig = {};
+    // Button Configuration
+    showSubmitButton = false;
+    showCancelButton = false;
+    submitButtonLabel;
+    cancelButtonLabel;
+    submitButtonIcon = 'pi pi-check';
+    cancelButtonIcon = 'pi pi-times';
+    formReady = new EventEmitter();
+    formSubmit = new EventEmitter();
+    visibleChange = new EventEmitter();
+    onCancel = new EventEmitter();
+    fieldSave = new EventEmitter();
+    form;
+    loading = false;
+    // Inline edit mode state
+    editingField = null;
+    savingField = false;
+    get hasFields() {
+        return this.formFields.length > 0;
+    }
+    get hasSections() {
+        return this.formSections.length > 0;
+    }
+    get hasFixedFilters() {
+        return this.fixedFilters.length > 0;
+    }
+    get hasFilterSections() {
+        return this.filterSections.length > 0;
+    }
+    get allFields() {
+        // Retorna todos os campos (diretos + das seções + filtros fixos + seções de filtros)
+        const sectionFields = this.formSections.flatMap(section => section.fields);
+        const filterSectionFields = this.filterSections.flatMap(section => section.fields);
+        return [...this.formFields, ...sectionFields, ...this.fixedFilters, ...filterSectionFields];
+    }
+    get isInlineMode() {
+        return this.displayMode === 'inline';
+    }
+    get isInlineEditMode() {
+        return this.mode === 'inline-edit';
+    }
+    get fieldMode() {
+        return this.isInlineEditMode ? 'form' : this.mode;
+    }
+    get isDialogMode() {
+        return this.displayMode === 'dialog';
+    }
+    get isDrawerMode() {
+        return this.displayMode === 'drawer';
+    }
+    // Dialog configuration with defaults
+    get dialogHeader() {
+        return this.dialogConfig.header || this.translationService.translate('crmx.business.form');
+    }
+    get dialogWidth() {
+        return this.dialogConfig.width || '600px';
+    }
+    get dialogDraggable() {
+        return this.dialogConfig.draggable !== undefined ? this.dialogConfig.draggable : false;
+    }
+    get dialogResizable() {
+        return this.dialogConfig.resizable !== undefined ? this.dialogConfig.resizable : false;
+    }
+    get dialogMaximizable() {
+        return this.dialogConfig.maximizable !== undefined ? this.dialogConfig.maximizable : false;
+    }
+    get dialogCloseOnEscape() {
+        return this.dialogConfig.closeOnEscape !== undefined ? this.dialogConfig.closeOnEscape : true;
+    }
+    get dialogDismissableMask() {
+        return this.dialogConfig.dismissableMask !== undefined ? this.dialogConfig.dismissableMask : false;
+    }
+    // Drawer configuration with defaults
+    get drawerHeader() {
+        return this.drawerConfig.header || this.translationService.translate('crmx.business.form');
+    }
+    get drawerPosition() {
+        return this.drawerConfig.position || 'right';
+    }
+    get drawerShowCloseIcon() {
+        return this.drawerConfig.showCloseIcon !== undefined ? this.drawerConfig.showCloseIcon : true;
+    }
+    get drawerCloseOnEscape() {
+        return this.drawerConfig.closeOnEscape !== undefined ? this.drawerConfig.closeOnEscape : true;
+    }
+    get drawerDismissable() {
+        return this.drawerConfig.dismissable !== undefined ? this.drawerConfig.dismissable : true;
+    }
+    get drawerStyle() {
+        const position = this.drawerPosition;
+        const isHorizontal = position === 'left' || position === 'right';
+        // Se tem customWidth, usa ela
+        if (this.drawerConfig.customWidth) {
+            return isHorizontal
+                ? { width: this.drawerConfig.customWidth }
+                : { height: this.drawerConfig.customWidth };
+        }
+        // Usa o tamanho padronizado
+        const size = this.drawerConfig.size || 'medium';
+        const sizeMap = {
+            'small': isHorizontal ? '25%' : '25vh',
+            'medium': isHorizontal ? '40%' : '40vh',
+            'large': isHorizontal ? '60%' : '60vh',
+            'xlarge': isHorizontal ? '80%' : '80vh',
+            'full': isHorizontal ? '100%' : '100vh'
+        };
+        const sizeValue = sizeMap[size];
+        return isHorizontal
+            ? { width: sizeValue }
+            : { height: sizeValue };
+    }
+    get submitLabel() {
+        return this.submitButtonLabel || this.translationService.translate('crmx.business.save');
+    }
+    get cancelLabel() {
+        return this.cancelButtonLabel || this.translationService.translate('crmx.business.cancel');
+    }
+    constructor(fb, translationService) {
+        this.fb = fb;
+        this.translationService = translationService;
+    }
+    ngOnInit() {
+        this.initForm();
+        this.setupConditionalFieldsWatcher();
+        this.formReady.emit(this.form);
+    }
+    ngOnChanges(changes) {
+        if (changes['entityData'] && this.form) {
+            if (this.entityData) {
+                this.loadEntityData();
+            }
+            else {
+                this.resetForm();
+            }
+        }
+        // Reset loading and form when dialog/drawer is opened
+        if (changes['visible'] && changes['visible'].currentValue === true) {
+            this.loading = false;
+            // If opening without entityData (new record), reset form
+            if (!this.entityData && this.form) {
+                this.resetForm();
+            }
+        }
+    }
+    initForm() {
+        const formControls = {};
+        // Processa todos os campos (diretos + das seções)
+        this.allFields.forEach(field => {
+            const defaultValue = this.getDefaultValue(field);
+            const validators = this.mode === 'filter' ? [] : (field.validators || []);
+            const control = this.fb.control({ value: defaultValue, disabled: field.disabled || false }, validators);
+            formControls[field.field] = control;
+        });
+        this.form = this.fb.group(formControls);
+        this.applyInitialDisabledState();
+    }
+    getDefaultValue(field) {
+        if (field.defaultValue !== undefined) {
+            return field.defaultValue;
+        }
+        switch (field.type) {
+            case 'number':
+            case 'date':
+                return null;
+            case 'dropdown':
+            case 'enum':
+                return this.mode === 'filter' ? null : '';
+            default:
+                return '';
+        }
+    }
+    applyInitialDisabledState() {
+        this.allFields.forEach(field => {
+            if (field.disabledWhen) {
+                const control = this.form.get(field.field);
+                if (control && this.isFieldDisabled(field)) {
+                    control.disable();
+                }
+            }
+        });
+    }
+    loadEntityData() {
+        if (this.entityData && this.form) {
+            const processedData = this.processEntityData(this.entityData);
+            this.form.patchValue(processedData);
+        }
+    }
+    processEntityData(entity) {
+        const processedData = { ...entity };
+        this.allFields.forEach(field => {
+            if (field.type === 'lookup' && processedData[field.field]) {
+                const lookupValue = processedData[field.field];
+                // Keep the full object if it has display data, otherwise extract ID
+                if (typeof lookupValue === 'object' && lookupValue.id) {
+                    const hasDisplayData = field.lookupDisplayFields
+                        ? field.lookupDisplayFields.some(f => this.getNestedValue(lookupValue, f))
+                        : lookupValue[field.lookupDisplayField || 'name'];
+                    if (hasDisplayData) {
+                        // Keep the full object to avoid unnecessary API calls
+                        processedData[field.field] = lookupValue;
+                    }
+                    else {
+                        // Only has ID, extract it
+                        processedData[field.field] = lookupValue.id;
+                    }
+                }
+            }
+        });
+        return processedData;
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => current?.[key], obj);
+    }
+    resetForm() {
+        if (this.form) {
+            const resetValues = {};
+            this.allFields.forEach(field => {
+                resetValues[field.field] = this.getDefaultValue(field);
+            });
+            this.form.reset(resetValues);
+        }
+    }
+    processFilterValue(formValue) {
+        const processedValue = { ...formValue };
+        this.allFields.forEach(field => {
+            const fieldValue = processedValue[field.field];
+            if (field.type === 'lookup') {
+                if (fieldValue && typeof fieldValue === 'object' && fieldValue.id) {
+                    processedValue[field.field] = fieldValue;
+                }
+                else if (fieldValue && typeof fieldValue === 'string') {
+                    processedValue[field.field] = { id: fieldValue };
+                }
+                else {
+                    processedValue[field.field] = null;
+                }
+            }
+        });
+        return processedValue;
+    }
+    processFormValue(formValue) {
+        const processedValue = { ...formValue };
+        if (this.entityData?.id) {
+            processedValue.id = this.entityData.id;
+        }
+        this.allFields.forEach(field => {
+            const fieldValue = processedValue[field.field];
+            if (field.type === 'lookup') {
+                // If it's an object, extract the ID
+                if (fieldValue && typeof fieldValue === 'object') {
+                    processedValue[field.field] = fieldValue.id || fieldValue[field.lookupValueField || 'id'] || null;
+                }
+                else if (fieldValue && fieldValue !== '') {
+                    // If it's already an ID, keep it
+                    processedValue[field.field] = { id: fieldValue };
+                }
+                else {
+                    processedValue[field.field] = null;
+                }
+            }
+            else if (field.type === 'date') {
+                if (fieldValue instanceof Date) {
+                    processedValue[field.field] = fieldValue.toISOString().split('T')[0];
+                }
+                else if (!fieldValue) {
+                    processedValue[field.field] = null;
+                }
+            }
+            else if (['text', 'textarea', 'number', 'enum', 'dropdown'].includes(field.type)) {
+                if (fieldValue === '' || fieldValue === undefined) {
+                    processedValue[field.field] = null;
+                }
+            }
+        });
+        return processedValue;
+    }
+    getFieldGridClass(field) {
+        const classes = [];
+        // Colspan base (padrão: 6)
+        let baseColspan = field.colspan || 6;
+        // Verifica condições de colspan dinâmico
+        if (field.colspanWhen && field.colspanWhen.length > 0) {
+            for (const condition of field.colspanWhen) {
+                const dependentFieldValue = this.form.get(condition.field)?.value;
+                if (dependentFieldValue === condition.value) {
+                    baseColspan = condition.colspan;
+                    break;
+                }
+            }
+        }
+        // Adiciona classe base
+        classes.push(`col-${baseColspan}`);
+        // Suporta tanto o objeto size quanto as propriedades antigas (para compatibilidade)
+        const sizeXs = field.size?.xs ?? field.colspanXs;
+        const sizeSm = field.size?.sm ?? field.colspanSm;
+        const sizeMd = field.size?.md ?? field.colspanMd;
+        const sizeLg = field.size?.lg ?? field.colspanLg;
+        const sizeXl = field.size?.xl ?? field.colspanXl;
+        // Adiciona classes responsivas se definidas
+        if (sizeXs !== undefined) {
+            classes.push(`col-xs-${sizeXs}`);
+        }
+        if (sizeSm !== undefined) {
+            classes.push(`col-sm-${sizeSm}`);
+        }
+        if (sizeMd !== undefined) {
+            classes.push(`col-md-${sizeMd}`);
+        }
+        if (sizeLg !== undefined) {
+            classes.push(`col-lg-${sizeLg}`);
+        }
+        if (sizeXl !== undefined) {
+            classes.push(`col-xl-${sizeXl}`);
+        }
+        return classes.join(' ');
+    }
+    isFieldVisible(field) {
+        if (this.mode === 'filter') {
+            return true;
+        }
+        if (!field.visibleWhen) {
+            return true;
+        }
+        const dependentFieldValue = this.form.get(field.visibleWhen.field)?.value;
+        return dependentFieldValue === field.visibleWhen.value;
+    }
+    isFieldDisabled(field) {
+        if (field.disabled) {
+            return true;
+        }
+        if (!('disabledWhen' in field) || !field.disabledWhen) {
+            return false;
+        }
+        const dependentFieldValue = this.form.get(field.disabledWhen.field)?.value;
+        if (field.disabledWhen.value === null) {
+            return !dependentFieldValue;
+        }
+        return dependentFieldValue === field.disabledWhen.value;
+    }
+    setupConditionalFieldsWatcher() {
+        const visibleDependentFields = this.allFields.filter(field => field.visibleWhen);
+        const visibleWatchedFields = [...new Set(visibleDependentFields.map(field => field.visibleWhen.field))];
+        const disabledDependentFields = this.allFields.filter(field => field.disabledWhen);
+        const disabledWatchedFields = [...new Set(disabledDependentFields.map(field => field.disabledWhen.field))];
+        const allWatchedFields = [...new Set([...visibleWatchedFields, ...disabledWatchedFields])];
+        allWatchedFields.forEach(fieldName => {
+            const control = this.form.get(fieldName);
+            if (control) {
+                control.valueChanges.subscribe(() => {
+                    this.clearHiddenFields();
+                    this.updateDisabledFields();
+                });
+            }
+        });
+    }
+    updateDisabledFields() {
+        this.allFields.forEach(field => {
+            if (field.disabledWhen) {
+                const control = this.form.get(field.field);
+                if (control) {
+                    const shouldBeDisabled = this.isFieldDisabled(field);
+                    if (shouldBeDisabled && control.enabled) {
+                        control.setValue(null);
+                        control.disable();
+                    }
+                    else if (!shouldBeDisabled && control.disabled && !field.disabled) {
+                        control.enable();
+                    }
+                }
+            }
+        });
+    }
+    clearHiddenFields() {
+        this.allFields.forEach(field => {
+            if (field.visibleWhen && !this.isFieldVisible(field)) {
+                const control = this.form.get(field.field);
+                if (control) {
+                    const resetValue = this.getDefaultValue(field);
+                    control.setValue(resetValue);
+                    control.markAsUntouched();
+                    control.markAsPristine();
+                }
+            }
+        });
+    }
+    getForm() {
+        return this.form;
+    }
+    clearFilters() {
+        if (this.mode === 'filter') {
+            this.resetForm();
+        }
+    }
+    getTypePersonValue() {
+        const typePersonValue = this.form?.get('typePerson')?.value;
+        return typePersonValue || 'JURIDICAL_PERSON';
+    }
+    // Display Mode Control Methods
+    open(entity) {
+        if (entity) {
+            this.entityData = entity;
+        }
+        else {
+            this.entityData = null;
+            this.resetForm(); // Reset form when opening for new entity
+        }
+        this.loading = false; // Reset loading state
+        this.visible = true;
+        this.visibleChange.emit(true);
+    }
+    close() {
+        this.loading = false; // Reset loading state
+        this.visible = false;
+        this.visibleChange.emit(false);
+        this.resetForm(); // Reset form when closing
+        this.onCancel.emit();
+    }
+    handleCancel() {
+        this.close();
+    }
+    handleSubmit() {
+        if (this.mode === 'form' && this.form.invalid) {
+            this.form.markAllAsTouched();
+            return;
+        }
+        this.loading = true;
+        const formValue = this.mode === 'filter'
+            ? this.processFilterValue(this.form.value)
+            : this.processFormValue(this.form.value);
+        this.formSubmit.emit(formValue);
+    }
+    // Inline Edit Mode Methods
+    startEditField(fieldName) {
+        if (this.isInlineEditMode) {
+            this.editingField = fieldName;
+            // Ensure the field has the current value from entityData
+            if (this.entityData) {
+                const control = this.form.get(fieldName);
+                if (control) {
+                    const field = this.allFields.find(f => f.field === fieldName);
+                    const value = this.entityData[fieldName];
+                    // For lookup fields in inline-edit mode, keep the full object
+                    // This prevents unnecessary API calls since we already have the data
+                    if (field?.type === 'lookup' && value && typeof value === 'object') {
+                        // Keep the full object - the lookup component will use it
+                        control.setValue(value);
+                    }
+                    else {
+                        control.setValue(value);
+                    }
+                }
+            }
+        }
+    }
+    isFieldEditing(fieldName) {
+        return this.editingField === fieldName;
+    }
+    saveInlineField(fieldName) {
+        if (!this.isInlineEditMode)
+            return;
+        const control = this.form.get(fieldName);
+        if (!control || control.invalid) {
+            control?.markAsTouched();
+            return;
+        }
+        this.savingField = true;
+        let fieldValue = control.value;
+        // For lookup fields, extract the ID if it's an object
+        const field = this.allFields.find(f => f.field === fieldName);
+        if (field?.type === 'lookup' && fieldValue && typeof fieldValue === 'object') {
+            fieldValue = fieldValue.id || fieldValue[field.lookupValueField || 'id'];
+        }
+        this.fieldSave.emit({ field: fieldName, value: fieldValue });
+    }
+    cancelInlineEdit() {
+        if (this.isInlineEditMode && this.editingField) {
+            const control = this.form.get(this.editingField);
+            if (control && this.entityData) {
+                // Restore original value
+                const originalValue = this.entityData[this.editingField];
+                control.setValue(originalValue);
+                control.markAsPristine();
+                control.markAsUntouched();
+            }
+            this.editingField = null;
+            this.savingField = false;
+        }
+    }
+    // Method to be called by parent after save completes
+    completeInlineEdit() {
+        this.editingField = null;
+        this.savingField = false;
+    }
+    getFieldDisplayValue(fieldName) {
+        if (!this.entityData)
+            return '';
+        const field = this.allFields.find(f => f.field === fieldName);
+        const value = this.entityData[fieldName];
+        if (!value)
+            return '';
+        // For lookup fields, return the display name
+        if (field?.type === 'lookup' && typeof value === 'object' && value.name) {
+            return value.name;
+        }
+        // For number fields, format appropriately
+        if (field?.type === 'number' && typeof value === 'number') {
+            if (field.numberMode === 'currency') {
+                return new Intl.NumberFormat(field.locale || 'pt-BR', {
+                    style: 'currency',
+                    currency: field.currency || 'BRL'
+                }).format(value);
+            }
+            return new Intl.NumberFormat(field.locale || 'pt-BR', {
+                minimumFractionDigits: field.minFractionDigits || 0,
+                maximumFractionDigits: field.maxFractionDigits || 2
+            }).format(value);
+        }
+        // For date fields, format as date
+        if (field?.type === 'date' && value) {
+            const date = typeof value === 'string' ? new Date(value) : value;
+            return date.toLocaleDateString('pt-BR');
+        }
+        return String(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormComponent, deps: [{ token: i2$1.FormBuilder }, { token: TranslationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: DynamicFormComponent, isStandalone: true, selector: "sia-dynamic-form", inputs: { formFields: "formFields", formSections: "formSections", fixedFilters: "fixedFilters", filterSections: "filterSections", entityData: "entityData", mode: "mode", displayMode: "displayMode", visible: "visible", dialogConfig: "dialogConfig", drawerConfig: "drawerConfig", showSubmitButton: "showSubmitButton", showCancelButton: "showCancelButton", submitButtonLabel: "submitButtonLabel", cancelButtonLabel: "cancelButtonLabel", submitButtonIcon: "submitButtonIcon", cancelButtonIcon: "cancelButtonIcon" }, outputs: { formReady: "formReady", formSubmit: "formSubmit", visibleChange: "visibleChange", onCancel: "onCancel", fieldSave: "fieldSave" }, usesOnChanges: true, ngImport: i0, template: "<!-- Modo Inline (padr\u00E3o) -->\n<ng-container *ngIf=\"isInlineMode\">\n  <ng-container *ngTemplateOutlet=\"formContent\"></ng-container>\n</ng-container>\n\n<!-- Modo Dialog -->\n<p-dialog\n  *ngIf=\"isDialogMode\"\n  [(visible)]=\"visible\"\n  [header]=\"dialogHeader | translate\"\n  [modal]=\"true\"\n  [style]=\"{ width: dialogWidth }\"\n  [draggable]=\"dialogDraggable\"\n  [resizable]=\"dialogResizable\"\n  [maximizable]=\"dialogMaximizable\"\n  [closeOnEscape]=\"dialogCloseOnEscape\"\n  [dismissableMask]=\"dialogDismissableMask\"\n  (onHide)=\"close()\">\n  \n  <ng-container *ngTemplateOutlet=\"formContent\"></ng-container>\n  \n  <ng-template pTemplate=\"footer\" *ngIf=\"showSubmitButton || showCancelButton\">\n    <div class=\"dialog-footer\">\n      <p-button\n        *ngIf=\"showCancelButton\"\n        [label]=\"cancelLabel | translate\"\n        [icon]=\"cancelButtonIcon\"\n        severity=\"secondary\"\n        (onClick)=\"handleCancel()\"\n        [disabled]=\"loading\">\n      </p-button>\n      <p-button\n        *ngIf=\"showSubmitButton\"\n        [label]=\"submitLabel | translate\"\n        [icon]=\"submitButtonIcon\"\n        (onClick)=\"handleSubmit()\"\n        [loading]=\"loading\"\n        [disabled]=\"form.invalid\">\n      </p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n\n<!-- Modo Drawer -->\n<p-drawer\n  *ngIf=\"isDrawerMode\"\n  [(visible)]=\"visible\"\n  [header]=\"drawerHeader | translate\"\n  [position]=\"drawerPosition\"\n  [style]=\"drawerStyle\"\n  [showCloseIcon]=\"drawerShowCloseIcon\"\n  [closeOnEscape]=\"drawerCloseOnEscape\"\n  [modal]=\"drawerDismissable\"\n  (onHide)=\"close()\">\n  \n  <ng-container *ngTemplateOutlet=\"formContent\"></ng-container>\n  \n  <ng-template pTemplate=\"footer\" *ngIf=\"showSubmitButton || showCancelButton\">\n    <div class=\"drawer-footer\">\n      <p-button\n        *ngIf=\"showCancelButton\"\n        [label]=\"cancelLabel | translate\"\n        [icon]=\"cancelButtonIcon\"\n        severity=\"secondary\"\n        (onClick)=\"handleCancel()\"\n        [disabled]=\"loading\">\n      </p-button>\n      <p-button\n        *ngIf=\"showSubmitButton\"\n        [label]=\"submitLabel | translate\"\n        [icon]=\"submitButtonIcon\"\n        (onClick)=\"handleSubmit()\"\n        [loading]=\"loading\"\n        [disabled]=\"form.invalid\">\n      </p-button>\n    </div>\n  </ng-template>\n</p-drawer>\n\n<!-- Template do Formul\u00E1rio (reutiliz\u00E1vel) -->\n<ng-template #formContent>\n  <form [formGroup]=\"form\" class=\"dynamic-form\">\n    \n    <!-- Filtros Fixos (apenas no modo filter) -->\n    <div *ngIf=\"mode === 'filter' && hasFixedFilters\" class=\"fixed-filters-section\">\n      <div class=\"grid\">\n        <ng-container *ngFor=\"let field of fixedFilters\">\n          <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n            <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n          </div>\n        </ng-container>\n      </div>\n    </div>\n\n    <!-- Campos Diretos (sem se\u00E7\u00E3o) -->\n    <div *ngIf=\"hasFields\">\n      <!-- Modo Inline Edit -->\n      <div *ngIf=\"isInlineEditMode\" class=\"inline-edit-fields\">\n        <ng-container *ngFor=\"let field of formFields\">\n          <div *ngIf=\"isFieldVisible(field)\" class=\"inline-edit-field\">\n            <ng-container *ngTemplateOutlet=\"inlineEditFieldTemplate; context: { field: field }\"></ng-container>\n          </div>\n        </ng-container>\n      </div>\n\n      <!-- Modo Form Normal -->\n      <div *ngIf=\"!isInlineEditMode\" class=\"grid\">\n        <ng-container *ngFor=\"let field of formFields\">\n          <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n            <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n          </div>\n        </ng-container>\n      </div>\n    </div>\n\n    <!-- Se\u00E7\u00F5es de Campos (modo form) -->\n    <div *ngIf=\"hasSections\" class=\"sections-container\">\n      <p-panel \n        *ngFor=\"let section of formSections\"\n        [toggleable]=\"section.toggleable !== false\"\n        [collapsed]=\"section.collapsed || false\"\n        [styleClass]=\"'section-panel'\">\n        \n        <ng-template pTemplate=\"header\">\n          <div class=\"section-header\">\n            <i *ngIf=\"section.icon\" [class]=\"section.icon + ' section-icon'\"></i>\n            <span class=\"section-title\">{{ section.title }}</span>\n          </div>\n        </ng-template>\n\n        <!-- Modo Inline Edit -->\n        <div *ngIf=\"isInlineEditMode\" class=\"inline-edit-fields\">\n          <ng-container *ngFor=\"let field of section.fields\">\n            <div *ngIf=\"isFieldVisible(field)\" class=\"inline-edit-field\">\n              <ng-container *ngTemplateOutlet=\"inlineEditFieldTemplate; context: { field: field }\"></ng-container>\n            </div>\n          </ng-container>\n        </div>\n\n        <!-- Modo Form Normal -->\n        <div *ngIf=\"!isInlineEditMode\" class=\"grid\">\n          <ng-container *ngFor=\"let field of section.fields\">\n            <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n              <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n            </div>\n          </ng-container>\n        </div>\n      </p-panel>\n    </div>\n\n    <!-- Se\u00E7\u00F5es de Filtros (apenas no modo filter) -->\n    <div *ngIf=\"mode === 'filter' && hasFilterSections\" class=\"filter-sections-container\">\n      <p-panel \n        *ngFor=\"let section of filterSections\"\n        [header]=\"section.title\"\n        [toggleable]=\"true\"\n        [collapsed]=\"true\">\n\n        <div class=\"grid\">\n          <ng-container *ngFor=\"let field of section.fields\">\n            <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n              <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n            </div>\n          </ng-container>\n        </div>\n      </p-panel>\n    </div>\n\n    <!-- Bot\u00F5es inline (apenas para modo inline) -->\n    <div *ngIf=\"isInlineMode && (showSubmitButton || showCancelButton)\" class=\"form-actions\">\n      <p-button\n        *ngIf=\"showCancelButton\"\n        [label]=\"cancelLabel | translate\"\n        [icon]=\"cancelButtonIcon\"\n        severity=\"secondary\"\n        (onClick)=\"handleCancel()\"\n        [disabled]=\"loading\">\n      </p-button>\n      <p-button\n        *ngIf=\"showSubmitButton\"\n        [label]=\"submitLabel | translate\"\n        [icon]=\"submitButtonIcon\"\n        (onClick)=\"handleSubmit()\"\n        [loading]=\"loading\"\n        [disabled]=\"form.invalid\">\n      </p-button>\n    </div>\n\n  </form>\n</ng-template>\n\n<!-- Template de Campo (reutiliz\u00E1vel) -->\n<ng-template #fieldTemplate let-field=\"field\">\n  <!-- Text Field -->\n  <sia-dynamic-field-text\n    *ngIf=\"field.type === 'text'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-text>\n\n  <!-- Textarea Field -->\n  <sia-dynamic-field-textarea\n    *ngIf=\"field.type === 'textarea'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-textarea>\n\n  <!-- Number Field -->\n  <sia-dynamic-field-number\n    *ngIf=\"field.type === 'number'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-number>\n\n  <!-- Date Field -->\n  <sia-dynamic-field-date\n    *ngIf=\"field.type === 'date'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-date>\n\n  <!-- Dropdown/Enum Field -->\n  <sia-dynamic-field-dropdown\n    *ngIf=\"field.type === 'dropdown' || field.type === 'enum'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-dropdown>\n\n  <!-- Lookup Field -->\n  <sia-dynamic-field-lookup\n    *ngIf=\"field.type === 'lookup'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [formGroup]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-lookup>\n</ng-template>\n\n\n<!-- Template de Campo Inline Edit -->\n<ng-template #inlineEditFieldTemplate let-field=\"field\">\n  <div class=\"edit-inline-field\">\n    <label class=\"field-label\">{{ field.label | translate }}</label>\n    \n    <!-- Display Mode -->\n    <div class=\"field-display\" \n         *ngIf=\"!isFieldEditing(field.field)\" \n         (click)=\"startEditField(field.field)\"\n         [class.disabled]=\"field.disabled\">\n      <span class=\"display-value\" \n            [attr.data-placeholder]=\"field.placeholder || ('crmx.business.not_informed' | translate)\">\n        {{ getFieldDisplayValue(field.field) }}\n      </span>\n      <i class=\"pi pi-pencil edit-icon\" *ngIf=\"!field.disabled\"></i>\n    </div>\n    \n    <!-- Edit Mode -->\n    <div class=\"field-edit\" *ngIf=\"isFieldEditing(field.field)\">\n      <div class=\"input-container\">\n        <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n      </div>\n      \n      <!-- Action Buttons -->\n      <div class=\"edit-actions\">\n        <p-button \n          type=\"button\" \n          icon=\"pi pi-check\" \n          [rounded]=\"true\"\n          severity=\"primary\"\n          (onClick)=\"saveInlineField(field.field)\" \n          [loading]=\"savingField\"\n          [disabled]=\"form.get(field.field)?.invalid\">\n        </p-button>\n        <p-button \n          type=\"button\" \n          icon=\"pi pi-times\" \n          [rounded]=\"true\"\n          severity=\"secondary\"\n          (onClick)=\"cancelInlineEdit()\"\n          [disabled]=\"savingField\">\n        </p-button>\n      </div>\n      \n      <!-- Error Message -->\n      <div class=\"field-error\" *ngIf=\"form.get(field.field)?.invalid && form.get(field.field)?.touched\">\n        <small class=\"p-error\">\n          {{ form.get(field.field)?.errors?.['required'] ? ('crmx.business.required_field' | translate) : '' }}\n        </small>\n      </div>\n    </div>\n  </div>\n</ng-template>\n", styles: [".dynamic-form{width:100%}.dynamic-form .grid{display:grid;grid-template-columns:repeat(12,1fr);gap:1rem}.dynamic-form .grid>div.col-1{grid-column:span 1}.dynamic-form .grid>div.col-2{grid-column:span 2}.dynamic-form .grid>div.col-3{grid-column:span 3}.dynamic-form .grid>div.col-4{grid-column:span 4}.dynamic-form .grid>div.col-5{grid-column:span 5}.dynamic-form .grid>div.col-6{grid-column:span 6}.dynamic-form .grid>div.col-7{grid-column:span 7}.dynamic-form .grid>div.col-8{grid-column:span 8}.dynamic-form .grid>div.col-9{grid-column:span 9}.dynamic-form .grid>div.col-10{grid-column:span 10}.dynamic-form .grid>div.col-11{grid-column:span 11}.dynamic-form .grid>div.col-12{grid-column:span 12}@media (max-width: 575.98px){.dynamic-form .grid>div.col-xs-1{grid-column:span 1}.dynamic-form .grid>div.col-xs-2{grid-column:span 2}.dynamic-form .grid>div.col-xs-3{grid-column:span 3}.dynamic-form .grid>div.col-xs-4{grid-column:span 4}.dynamic-form .grid>div.col-xs-5{grid-column:span 5}.dynamic-form .grid>div.col-xs-6{grid-column:span 6}.dynamic-form .grid>div.col-xs-7{grid-column:span 7}.dynamic-form .grid>div.col-xs-8{grid-column:span 8}.dynamic-form .grid>div.col-xs-9{grid-column:span 9}.dynamic-form .grid>div.col-xs-10{grid-column:span 10}.dynamic-form .grid>div.col-xs-11{grid-column:span 11}.dynamic-form .grid>div.col-xs-12{grid-column:span 12}}@media (min-width: 576px){.dynamic-form .grid>div.col-sm-1{grid-column:span 1}.dynamic-form .grid>div.col-sm-2{grid-column:span 2}.dynamic-form .grid>div.col-sm-3{grid-column:span 3}.dynamic-form .grid>div.col-sm-4{grid-column:span 4}.dynamic-form .grid>div.col-sm-5{grid-column:span 5}.dynamic-form .grid>div.col-sm-6{grid-column:span 6}.dynamic-form .grid>div.col-sm-7{grid-column:span 7}.dynamic-form .grid>div.col-sm-8{grid-column:span 8}.dynamic-form .grid>div.col-sm-9{grid-column:span 9}.dynamic-form .grid>div.col-sm-10{grid-column:span 10}.dynamic-form .grid>div.col-sm-11{grid-column:span 11}.dynamic-form .grid>div.col-sm-12{grid-column:span 12}}@media (min-width: 768px){.dynamic-form .grid>div.col-md-1{grid-column:span 1}.dynamic-form .grid>div.col-md-2{grid-column:span 2}.dynamic-form .grid>div.col-md-3{grid-column:span 3}.dynamic-form .grid>div.col-md-4{grid-column:span 4}.dynamic-form .grid>div.col-md-5{grid-column:span 5}.dynamic-form .grid>div.col-md-6{grid-column:span 6}.dynamic-form .grid>div.col-md-7{grid-column:span 7}.dynamic-form .grid>div.col-md-8{grid-column:span 8}.dynamic-form .grid>div.col-md-9{grid-column:span 9}.dynamic-form .grid>div.col-md-10{grid-column:span 10}.dynamic-form .grid>div.col-md-11{grid-column:span 11}.dynamic-form .grid>div.col-md-12{grid-column:span 12}}@media (min-width: 992px){.dynamic-form .grid>div.col-lg-1{grid-column:span 1}.dynamic-form .grid>div.col-lg-2{grid-column:span 2}.dynamic-form .grid>div.col-lg-3{grid-column:span 3}.dynamic-form .grid>div.col-lg-4{grid-column:span 4}.dynamic-form .grid>div.col-lg-5{grid-column:span 5}.dynamic-form .grid>div.col-lg-6{grid-column:span 6}.dynamic-form .grid>div.col-lg-7{grid-column:span 7}.dynamic-form .grid>div.col-lg-8{grid-column:span 8}.dynamic-form .grid>div.col-lg-9{grid-column:span 9}.dynamic-form .grid>div.col-lg-10{grid-column:span 10}.dynamic-form .grid>div.col-lg-11{grid-column:span 11}.dynamic-form .grid>div.col-lg-12{grid-column:span 12}}@media (min-width: 1200px){.dynamic-form .grid>div.col-xl-1{grid-column:span 1}.dynamic-form .grid>div.col-xl-2{grid-column:span 2}.dynamic-form .grid>div.col-xl-3{grid-column:span 3}.dynamic-form .grid>div.col-xl-4{grid-column:span 4}.dynamic-form .grid>div.col-xl-5{grid-column:span 5}.dynamic-form .grid>div.col-xl-6{grid-column:span 6}.dynamic-form .grid>div.col-xl-7{grid-column:span 7}.dynamic-form .grid>div.col-xl-8{grid-column:span 8}.dynamic-form .grid>div.col-xl-9{grid-column:span 9}.dynamic-form .grid>div.col-xl-10{grid-column:span 10}.dynamic-form .grid>div.col-xl-11{grid-column:span 11}.dynamic-form .grid>div.col-xl-12{grid-column:span 12}}.dynamic-form .sections-container{display:flex;flex-direction:column;gap:1rem;margin-top:1rem}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header{background-color:var(--surface-50);border-color:var(--surface-200)}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header .section-header{display:flex;align-items:center;gap:.5rem;width:100%}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header .section-header .section-icon{font-size:1.1rem;color:var(--primary-color)}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header .section-header .section-title{font-weight:600;color:var(--text-color)}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-content{padding:1.5rem}.dynamic-form .fixed-filters-section{margin-bottom:1rem;padding-bottom:1rem;border-bottom:1px solid var(--surface-200)}.dynamic-form .filter-sections-container{display:flex;flex-direction:column;gap:1rem;margin-top:1rem}.dynamic-form .form-actions{display:flex;justify-content:flex-end;gap:.5rem;margin-top:1.5rem;padding-top:1rem;border-top:1px solid var(--surface-200)}.dialog-footer{display:flex;justify-content:flex-end;gap:.5rem}.drawer-footer{display:flex;justify-content:flex-end;gap:.5rem;padding:1rem;border-top:1px solid var(--surface-200)}.inline-edit-fields{display:flex;flex-direction:column;gap:1rem}.inline-edit-fields .inline-edit-field{display:flex;flex-direction:column;gap:.25rem}.inline-edit-fields .inline-edit-field .field-label{font-weight:500;font-size:.875rem;color:var(--text-color-secondary);margin-bottom:.25rem}.inline-edit-fields .inline-edit-field .field-display{display:flex;align-items:center;justify-content:space-between;padding:.75rem;background-color:var(--surface-50);border:1px solid var(--surface-200);border-radius:var(--border-radius);cursor:pointer;transition:all .2s ease;min-height:42px}.inline-edit-fields .inline-edit-field .field-display:hover:not(.disabled){background-color:var(--surface-100);border-color:var(--primary-color)}.inline-edit-fields .inline-edit-field .field-display:hover:not(.disabled) .edit-icon{opacity:1}.inline-edit-fields .inline-edit-field .field-display.disabled{cursor:not-allowed;opacity:.6}.inline-edit-fields .inline-edit-field .field-display .display-value{flex:1;color:var(--text-color)}.inline-edit-fields .inline-edit-field .field-display .display-value:empty:before{content:attr(data-placeholder);color:var(--text-color-secondary);font-style:italic}.inline-edit-fields .inline-edit-field .field-display .edit-icon{color:var(--primary-color);font-size:.875rem;opacity:.5;transition:opacity .2s ease}.inline-edit-fields .inline-edit-field .field-edit{display:flex;flex-direction:column;gap:.5rem}.inline-edit-fields .inline-edit-field .field-edit .input-container{flex:1}.inline-edit-fields .inline-edit-field .field-edit .input-container ::ng-deep .field{gap:0}.inline-edit-fields .inline-edit-field .field-edit .input-container ::ng-deep .field label{display:none}.inline-edit-fields .inline-edit-field .field-edit .input-container ::ng-deep .field small.p-error{display:none}.inline-edit-fields .inline-edit-field .field-edit .edit-actions{display:flex;gap:.5rem;justify-content:flex-end}.inline-edit-fields .inline-edit-field .field-edit .field-error small.p-error{color:var(--p-red-500);font-size:.875rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2$1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i2$1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2$1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: PanelModule }, { kind: "component", type: i4$2.Panel, selector: "p-panel", inputs: ["toggleable", "header", "collapsed", "style", "styleClass", "iconPos", "expandIcon", "collapseIcon", "showHeader", "toggler", "transitionOptions", "toggleButtonProps"], outputs: ["collapsedChange", "onBeforeToggle", "onAfterToggle"] }, { kind: "directive", type: i5.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: DialogModule }, { kind: "component", type: i3.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: "ngmodule", type: DrawerModule }, { kind: "component", type: i7$1.Drawer, selector: "p-drawer", inputs: ["appendTo", "blockScroll", "style", "styleClass", "ariaCloseLabel", "autoZIndex", "baseZIndex", "modal", "closeButtonProps", "dismissible", "showCloseIcon", "closeOnEscape", "transitionOptions", "visible", "position", "fullScreen", "header", "maskStyle", "closable"], outputs: ["onShow", "onHide", "visibleChange"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "component", type: i5$1.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "variant", "style", "styleClass", "badgeClass", "badgeSeverity", "ariaLabel", "autofocus", "fluid", "buttonProps"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "component", type: DynamicFieldTextComponent, selector: "sia-dynamic-field-text", inputs: ["field", "form", "mode"] }, { kind: "component", type: DynamicFieldNumberComponent, selector: "sia-dynamic-field-number", inputs: ["field", "form", "mode"] }, { kind: "component", type: DynamicFieldDateComponent, selector: "sia-dynamic-field-date", inputs: ["field", "form", "mode"] }, { kind: "component", type: DynamicFieldDropdownComponent, selector: "sia-dynamic-field-dropdown", inputs: ["field", "form", "mode"] }, { kind: "component", type: DynamicFieldLookupComponent, selector: "sia-dynamic-field-lookup", inputs: ["field", "form", "formGroup", "mode"] }, { kind: "component", type: DynamicFieldTextareaComponent, selector: "sia-dynamic-field-textarea", inputs: ["field", "form", "mode"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DynamicFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sia-dynamic-form', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        PanelModule,
+                        DialogModule,
+                        DrawerModule,
+                        ButtonModule,
+                        TranslatePipe,
+                        DynamicFieldTextComponent,
+                        DynamicFieldNumberComponent,
+                        DynamicFieldDateComponent,
+                        DynamicFieldDropdownComponent,
+                        DynamicFieldLookupComponent,
+                        DynamicFieldTextareaComponent
+                    ], template: "<!-- Modo Inline (padr\u00E3o) -->\n<ng-container *ngIf=\"isInlineMode\">\n  <ng-container *ngTemplateOutlet=\"formContent\"></ng-container>\n</ng-container>\n\n<!-- Modo Dialog -->\n<p-dialog\n  *ngIf=\"isDialogMode\"\n  [(visible)]=\"visible\"\n  [header]=\"dialogHeader | translate\"\n  [modal]=\"true\"\n  [style]=\"{ width: dialogWidth }\"\n  [draggable]=\"dialogDraggable\"\n  [resizable]=\"dialogResizable\"\n  [maximizable]=\"dialogMaximizable\"\n  [closeOnEscape]=\"dialogCloseOnEscape\"\n  [dismissableMask]=\"dialogDismissableMask\"\n  (onHide)=\"close()\">\n  \n  <ng-container *ngTemplateOutlet=\"formContent\"></ng-container>\n  \n  <ng-template pTemplate=\"footer\" *ngIf=\"showSubmitButton || showCancelButton\">\n    <div class=\"dialog-footer\">\n      <p-button\n        *ngIf=\"showCancelButton\"\n        [label]=\"cancelLabel | translate\"\n        [icon]=\"cancelButtonIcon\"\n        severity=\"secondary\"\n        (onClick)=\"handleCancel()\"\n        [disabled]=\"loading\">\n      </p-button>\n      <p-button\n        *ngIf=\"showSubmitButton\"\n        [label]=\"submitLabel | translate\"\n        [icon]=\"submitButtonIcon\"\n        (onClick)=\"handleSubmit()\"\n        [loading]=\"loading\"\n        [disabled]=\"form.invalid\">\n      </p-button>\n    </div>\n  </ng-template>\n</p-dialog>\n\n<!-- Modo Drawer -->\n<p-drawer\n  *ngIf=\"isDrawerMode\"\n  [(visible)]=\"visible\"\n  [header]=\"drawerHeader | translate\"\n  [position]=\"drawerPosition\"\n  [style]=\"drawerStyle\"\n  [showCloseIcon]=\"drawerShowCloseIcon\"\n  [closeOnEscape]=\"drawerCloseOnEscape\"\n  [modal]=\"drawerDismissable\"\n  (onHide)=\"close()\">\n  \n  <ng-container *ngTemplateOutlet=\"formContent\"></ng-container>\n  \n  <ng-template pTemplate=\"footer\" *ngIf=\"showSubmitButton || showCancelButton\">\n    <div class=\"drawer-footer\">\n      <p-button\n        *ngIf=\"showCancelButton\"\n        [label]=\"cancelLabel | translate\"\n        [icon]=\"cancelButtonIcon\"\n        severity=\"secondary\"\n        (onClick)=\"handleCancel()\"\n        [disabled]=\"loading\">\n      </p-button>\n      <p-button\n        *ngIf=\"showSubmitButton\"\n        [label]=\"submitLabel | translate\"\n        [icon]=\"submitButtonIcon\"\n        (onClick)=\"handleSubmit()\"\n        [loading]=\"loading\"\n        [disabled]=\"form.invalid\">\n      </p-button>\n    </div>\n  </ng-template>\n</p-drawer>\n\n<!-- Template do Formul\u00E1rio (reutiliz\u00E1vel) -->\n<ng-template #formContent>\n  <form [formGroup]=\"form\" class=\"dynamic-form\">\n    \n    <!-- Filtros Fixos (apenas no modo filter) -->\n    <div *ngIf=\"mode === 'filter' && hasFixedFilters\" class=\"fixed-filters-section\">\n      <div class=\"grid\">\n        <ng-container *ngFor=\"let field of fixedFilters\">\n          <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n            <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n          </div>\n        </ng-container>\n      </div>\n    </div>\n\n    <!-- Campos Diretos (sem se\u00E7\u00E3o) -->\n    <div *ngIf=\"hasFields\">\n      <!-- Modo Inline Edit -->\n      <div *ngIf=\"isInlineEditMode\" class=\"inline-edit-fields\">\n        <ng-container *ngFor=\"let field of formFields\">\n          <div *ngIf=\"isFieldVisible(field)\" class=\"inline-edit-field\">\n            <ng-container *ngTemplateOutlet=\"inlineEditFieldTemplate; context: { field: field }\"></ng-container>\n          </div>\n        </ng-container>\n      </div>\n\n      <!-- Modo Form Normal -->\n      <div *ngIf=\"!isInlineEditMode\" class=\"grid\">\n        <ng-container *ngFor=\"let field of formFields\">\n          <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n            <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n          </div>\n        </ng-container>\n      </div>\n    </div>\n\n    <!-- Se\u00E7\u00F5es de Campos (modo form) -->\n    <div *ngIf=\"hasSections\" class=\"sections-container\">\n      <p-panel \n        *ngFor=\"let section of formSections\"\n        [toggleable]=\"section.toggleable !== false\"\n        [collapsed]=\"section.collapsed || false\"\n        [styleClass]=\"'section-panel'\">\n        \n        <ng-template pTemplate=\"header\">\n          <div class=\"section-header\">\n            <i *ngIf=\"section.icon\" [class]=\"section.icon + ' section-icon'\"></i>\n            <span class=\"section-title\">{{ section.title }}</span>\n          </div>\n        </ng-template>\n\n        <!-- Modo Inline Edit -->\n        <div *ngIf=\"isInlineEditMode\" class=\"inline-edit-fields\">\n          <ng-container *ngFor=\"let field of section.fields\">\n            <div *ngIf=\"isFieldVisible(field)\" class=\"inline-edit-field\">\n              <ng-container *ngTemplateOutlet=\"inlineEditFieldTemplate; context: { field: field }\"></ng-container>\n            </div>\n          </ng-container>\n        </div>\n\n        <!-- Modo Form Normal -->\n        <div *ngIf=\"!isInlineEditMode\" class=\"grid\">\n          <ng-container *ngFor=\"let field of section.fields\">\n            <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n              <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n            </div>\n          </ng-container>\n        </div>\n      </p-panel>\n    </div>\n\n    <!-- Se\u00E7\u00F5es de Filtros (apenas no modo filter) -->\n    <div *ngIf=\"mode === 'filter' && hasFilterSections\" class=\"filter-sections-container\">\n      <p-panel \n        *ngFor=\"let section of filterSections\"\n        [header]=\"section.title\"\n        [toggleable]=\"true\"\n        [collapsed]=\"true\">\n\n        <div class=\"grid\">\n          <ng-container *ngFor=\"let field of section.fields\">\n            <div *ngIf=\"isFieldVisible(field)\" [ngClass]=\"getFieldGridClass(field)\">\n              <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n            </div>\n          </ng-container>\n        </div>\n      </p-panel>\n    </div>\n\n    <!-- Bot\u00F5es inline (apenas para modo inline) -->\n    <div *ngIf=\"isInlineMode && (showSubmitButton || showCancelButton)\" class=\"form-actions\">\n      <p-button\n        *ngIf=\"showCancelButton\"\n        [label]=\"cancelLabel | translate\"\n        [icon]=\"cancelButtonIcon\"\n        severity=\"secondary\"\n        (onClick)=\"handleCancel()\"\n        [disabled]=\"loading\">\n      </p-button>\n      <p-button\n        *ngIf=\"showSubmitButton\"\n        [label]=\"submitLabel | translate\"\n        [icon]=\"submitButtonIcon\"\n        (onClick)=\"handleSubmit()\"\n        [loading]=\"loading\"\n        [disabled]=\"form.invalid\">\n      </p-button>\n    </div>\n\n  </form>\n</ng-template>\n\n<!-- Template de Campo (reutiliz\u00E1vel) -->\n<ng-template #fieldTemplate let-field=\"field\">\n  <!-- Text Field -->\n  <sia-dynamic-field-text\n    *ngIf=\"field.type === 'text'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-text>\n\n  <!-- Textarea Field -->\n  <sia-dynamic-field-textarea\n    *ngIf=\"field.type === 'textarea'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-textarea>\n\n  <!-- Number Field -->\n  <sia-dynamic-field-number\n    *ngIf=\"field.type === 'number'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-number>\n\n  <!-- Date Field -->\n  <sia-dynamic-field-date\n    *ngIf=\"field.type === 'date'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-date>\n\n  <!-- Dropdown/Enum Field -->\n  <sia-dynamic-field-dropdown\n    *ngIf=\"field.type === 'dropdown' || field.type === 'enum'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-dropdown>\n\n  <!-- Lookup Field -->\n  <sia-dynamic-field-lookup\n    *ngIf=\"field.type === 'lookup'\"\n    [field]=\"field\"\n    [form]=\"form\"\n    [formGroup]=\"form\"\n    [mode]=\"fieldMode\">\n  </sia-dynamic-field-lookup>\n</ng-template>\n\n\n<!-- Template de Campo Inline Edit -->\n<ng-template #inlineEditFieldTemplate let-field=\"field\">\n  <div class=\"edit-inline-field\">\n    <label class=\"field-label\">{{ field.label | translate }}</label>\n    \n    <!-- Display Mode -->\n    <div class=\"field-display\" \n         *ngIf=\"!isFieldEditing(field.field)\" \n         (click)=\"startEditField(field.field)\"\n         [class.disabled]=\"field.disabled\">\n      <span class=\"display-value\" \n            [attr.data-placeholder]=\"field.placeholder || ('crmx.business.not_informed' | translate)\">\n        {{ getFieldDisplayValue(field.field) }}\n      </span>\n      <i class=\"pi pi-pencil edit-icon\" *ngIf=\"!field.disabled\"></i>\n    </div>\n    \n    <!-- Edit Mode -->\n    <div class=\"field-edit\" *ngIf=\"isFieldEditing(field.field)\">\n      <div class=\"input-container\">\n        <ng-container *ngTemplateOutlet=\"fieldTemplate; context: { field: field }\"></ng-container>\n      </div>\n      \n      <!-- Action Buttons -->\n      <div class=\"edit-actions\">\n        <p-button \n          type=\"button\" \n          icon=\"pi pi-check\" \n          [rounded]=\"true\"\n          severity=\"primary\"\n          (onClick)=\"saveInlineField(field.field)\" \n          [loading]=\"savingField\"\n          [disabled]=\"form.get(field.field)?.invalid\">\n        </p-button>\n        <p-button \n          type=\"button\" \n          icon=\"pi pi-times\" \n          [rounded]=\"true\"\n          severity=\"secondary\"\n          (onClick)=\"cancelInlineEdit()\"\n          [disabled]=\"savingField\">\n        </p-button>\n      </div>\n      \n      <!-- Error Message -->\n      <div class=\"field-error\" *ngIf=\"form.get(field.field)?.invalid && form.get(field.field)?.touched\">\n        <small class=\"p-error\">\n          {{ form.get(field.field)?.errors?.['required'] ? ('crmx.business.required_field' | translate) : '' }}\n        </small>\n      </div>\n    </div>\n  </div>\n</ng-template>\n", styles: [".dynamic-form{width:100%}.dynamic-form .grid{display:grid;grid-template-columns:repeat(12,1fr);gap:1rem}.dynamic-form .grid>div.col-1{grid-column:span 1}.dynamic-form .grid>div.col-2{grid-column:span 2}.dynamic-form .grid>div.col-3{grid-column:span 3}.dynamic-form .grid>div.col-4{grid-column:span 4}.dynamic-form .grid>div.col-5{grid-column:span 5}.dynamic-form .grid>div.col-6{grid-column:span 6}.dynamic-form .grid>div.col-7{grid-column:span 7}.dynamic-form .grid>div.col-8{grid-column:span 8}.dynamic-form .grid>div.col-9{grid-column:span 9}.dynamic-form .grid>div.col-10{grid-column:span 10}.dynamic-form .grid>div.col-11{grid-column:span 11}.dynamic-form .grid>div.col-12{grid-column:span 12}@media (max-width: 575.98px){.dynamic-form .grid>div.col-xs-1{grid-column:span 1}.dynamic-form .grid>div.col-xs-2{grid-column:span 2}.dynamic-form .grid>div.col-xs-3{grid-column:span 3}.dynamic-form .grid>div.col-xs-4{grid-column:span 4}.dynamic-form .grid>div.col-xs-5{grid-column:span 5}.dynamic-form .grid>div.col-xs-6{grid-column:span 6}.dynamic-form .grid>div.col-xs-7{grid-column:span 7}.dynamic-form .grid>div.col-xs-8{grid-column:span 8}.dynamic-form .grid>div.col-xs-9{grid-column:span 9}.dynamic-form .grid>div.col-xs-10{grid-column:span 10}.dynamic-form .grid>div.col-xs-11{grid-column:span 11}.dynamic-form .grid>div.col-xs-12{grid-column:span 12}}@media (min-width: 576px){.dynamic-form .grid>div.col-sm-1{grid-column:span 1}.dynamic-form .grid>div.col-sm-2{grid-column:span 2}.dynamic-form .grid>div.col-sm-3{grid-column:span 3}.dynamic-form .grid>div.col-sm-4{grid-column:span 4}.dynamic-form .grid>div.col-sm-5{grid-column:span 5}.dynamic-form .grid>div.col-sm-6{grid-column:span 6}.dynamic-form .grid>div.col-sm-7{grid-column:span 7}.dynamic-form .grid>div.col-sm-8{grid-column:span 8}.dynamic-form .grid>div.col-sm-9{grid-column:span 9}.dynamic-form .grid>div.col-sm-10{grid-column:span 10}.dynamic-form .grid>div.col-sm-11{grid-column:span 11}.dynamic-form .grid>div.col-sm-12{grid-column:span 12}}@media (min-width: 768px){.dynamic-form .grid>div.col-md-1{grid-column:span 1}.dynamic-form .grid>div.col-md-2{grid-column:span 2}.dynamic-form .grid>div.col-md-3{grid-column:span 3}.dynamic-form .grid>div.col-md-4{grid-column:span 4}.dynamic-form .grid>div.col-md-5{grid-column:span 5}.dynamic-form .grid>div.col-md-6{grid-column:span 6}.dynamic-form .grid>div.col-md-7{grid-column:span 7}.dynamic-form .grid>div.col-md-8{grid-column:span 8}.dynamic-form .grid>div.col-md-9{grid-column:span 9}.dynamic-form .grid>div.col-md-10{grid-column:span 10}.dynamic-form .grid>div.col-md-11{grid-column:span 11}.dynamic-form .grid>div.col-md-12{grid-column:span 12}}@media (min-width: 992px){.dynamic-form .grid>div.col-lg-1{grid-column:span 1}.dynamic-form .grid>div.col-lg-2{grid-column:span 2}.dynamic-form .grid>div.col-lg-3{grid-column:span 3}.dynamic-form .grid>div.col-lg-4{grid-column:span 4}.dynamic-form .grid>div.col-lg-5{grid-column:span 5}.dynamic-form .grid>div.col-lg-6{grid-column:span 6}.dynamic-form .grid>div.col-lg-7{grid-column:span 7}.dynamic-form .grid>div.col-lg-8{grid-column:span 8}.dynamic-form .grid>div.col-lg-9{grid-column:span 9}.dynamic-form .grid>div.col-lg-10{grid-column:span 10}.dynamic-form .grid>div.col-lg-11{grid-column:span 11}.dynamic-form .grid>div.col-lg-12{grid-column:span 12}}@media (min-width: 1200px){.dynamic-form .grid>div.col-xl-1{grid-column:span 1}.dynamic-form .grid>div.col-xl-2{grid-column:span 2}.dynamic-form .grid>div.col-xl-3{grid-column:span 3}.dynamic-form .grid>div.col-xl-4{grid-column:span 4}.dynamic-form .grid>div.col-xl-5{grid-column:span 5}.dynamic-form .grid>div.col-xl-6{grid-column:span 6}.dynamic-form .grid>div.col-xl-7{grid-column:span 7}.dynamic-form .grid>div.col-xl-8{grid-column:span 8}.dynamic-form .grid>div.col-xl-9{grid-column:span 9}.dynamic-form .grid>div.col-xl-10{grid-column:span 10}.dynamic-form .grid>div.col-xl-11{grid-column:span 11}.dynamic-form .grid>div.col-xl-12{grid-column:span 12}}.dynamic-form .sections-container{display:flex;flex-direction:column;gap:1rem;margin-top:1rem}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header{background-color:var(--surface-50);border-color:var(--surface-200)}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header .section-header{display:flex;align-items:center;gap:.5rem;width:100%}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header .section-header .section-icon{font-size:1.1rem;color:var(--primary-color)}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-header .section-header .section-title{font-weight:600;color:var(--text-color)}.dynamic-form .sections-container ::ng-deep .section-panel .p-panel-content{padding:1.5rem}.dynamic-form .fixed-filters-section{margin-bottom:1rem;padding-bottom:1rem;border-bottom:1px solid var(--surface-200)}.dynamic-form .filter-sections-container{display:flex;flex-direction:column;gap:1rem;margin-top:1rem}.dynamic-form .form-actions{display:flex;justify-content:flex-end;gap:.5rem;margin-top:1.5rem;padding-top:1rem;border-top:1px solid var(--surface-200)}.dialog-footer{display:flex;justify-content:flex-end;gap:.5rem}.drawer-footer{display:flex;justify-content:flex-end;gap:.5rem;padding:1rem;border-top:1px solid var(--surface-200)}.inline-edit-fields{display:flex;flex-direction:column;gap:1rem}.inline-edit-fields .inline-edit-field{display:flex;flex-direction:column;gap:.25rem}.inline-edit-fields .inline-edit-field .field-label{font-weight:500;font-size:.875rem;color:var(--text-color-secondary);margin-bottom:.25rem}.inline-edit-fields .inline-edit-field .field-display{display:flex;align-items:center;justify-content:space-between;padding:.75rem;background-color:var(--surface-50);border:1px solid var(--surface-200);border-radius:var(--border-radius);cursor:pointer;transition:all .2s ease;min-height:42px}.inline-edit-fields .inline-edit-field .field-display:hover:not(.disabled){background-color:var(--surface-100);border-color:var(--primary-color)}.inline-edit-fields .inline-edit-field .field-display:hover:not(.disabled) .edit-icon{opacity:1}.inline-edit-fields .inline-edit-field .field-display.disabled{cursor:not-allowed;opacity:.6}.inline-edit-fields .inline-edit-field .field-display .display-value{flex:1;color:var(--text-color)}.inline-edit-fields .inline-edit-field .field-display .display-value:empty:before{content:attr(data-placeholder);color:var(--text-color-secondary);font-style:italic}.inline-edit-fields .inline-edit-field .field-display .edit-icon{color:var(--primary-color);font-size:.875rem;opacity:.5;transition:opacity .2s ease}.inline-edit-fields .inline-edit-field .field-edit{display:flex;flex-direction:column;gap:.5rem}.inline-edit-fields .inline-edit-field .field-edit .input-container{flex:1}.inline-edit-fields .inline-edit-field .field-edit .input-container ::ng-deep .field{gap:0}.inline-edit-fields .inline-edit-field .field-edit .input-container ::ng-deep .field label{display:none}.inline-edit-fields .inline-edit-field .field-edit .input-container ::ng-deep .field small.p-error{display:none}.inline-edit-fields .inline-edit-field .field-edit .edit-actions{display:flex;gap:.5rem;justify-content:flex-end}.inline-edit-fields .inline-edit-field .field-edit .field-error small.p-error{color:var(--p-red-500);font-size:.875rem}\n"] }]
+        }], ctorParameters: () => [{ type: i2$1.FormBuilder }, { type: TranslationService }], propDecorators: { formFields: [{
+                type: Input
+            }], formSections: [{
+                type: Input
+            }], fixedFilters: [{
+                type: Input
+            }], filterSections: [{
+                type: Input
+            }], entityData: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], displayMode: [{
+                type: Input
+            }], visible: [{
+                type: Input
+            }], dialogConfig: [{
+                type: Input
+            }], drawerConfig: [{
+                type: Input
+            }], showSubmitButton: [{
+                type: Input
+            }], showCancelButton: [{
+                type: Input
+            }], submitButtonLabel: [{
+                type: Input
+            }], cancelButtonLabel: [{
+                type: Input
+            }], submitButtonIcon: [{
+                type: Input
+            }], cancelButtonIcon: [{
+                type: Input
+            }], formReady: [{
+                type: Output
+            }], formSubmit: [{
+                type: Output
+            }], visibleChange: [{
+                type: Output
+            }], onCancel: [{
+                type: Output
+            }], fieldSave: [{
+                type: Output
+            }] } });
+
+const apiInterceptor = (req, next) => {
+    const authService = inject(AuthService);
+    const router = inject(Router);
+    // Get the access token, token type, and base URL
+    const accessToken = authService.getAccessToken();
+    const tokenType = authService.getTokenType();
+    const baseUrl = authService.getApiBaseUrl();
+    let modifiedReq = req;
+    // Add Authorization header if token exists
+    if (accessToken && tokenType) {
+        const authHeader = `${tokenType} ${accessToken}`;
+        modifiedReq = modifiedReq.clone({
+            setHeaders: {
+                Authorization: authHeader
+            }
+        });
+    }
+    // Prepend base URL if it exists and the request URL is relative
+    if (baseUrl && !isAbsoluteUrl(modifiedReq.url)) {
+        const fullUrl = combineUrls(baseUrl, modifiedReq.url);
+        modifiedReq = modifiedReq.clone({
+            url: fullUrl
+        });
+    }
+    return next(modifiedReq).pipe(catchError$1((error) => {
+        // Handle 401 Unauthorized errors
+        if (error.status === 401) {
+            // Redirect to forbidden route
+            router.navigate(['/forbidden']);
+        }
+        // Re-throw the error so other error handlers can process it
+        return throwError(() => error);
+    }));
+};
+/**
+ * Check if URL is absolute
+ */
+function isAbsoluteUrl(url) {
+    return /^https?:\/\//.test(url);
+}
+/**
+ * Combine base URL with relative URL
+ */
+function combineUrls(baseUrl, relativeUrl) {
+    // Remove trailing slash from base URL
+    const cleanBaseUrl = baseUrl.replace(/\/$/, '');
+    // Remove leading slash from relative URL
+    const cleanRelativeUrl = relativeUrl.replace(/^\//, '');
+    return `${cleanBaseUrl}/${cleanRelativeUrl}`;
+}
+
+/*
+ * Public API Surface of @seniorsistemas/components-ia
+ *
+ * Este arquivo será populado conforme os componentes forem migrados.
+ * Por enquanto, exporta apenas o módulo principal.
+ */
+// ============================================================================
+// MODULE
+// ============================================================================
+// ============================================================================
+// NOTA: Os exports abaixo serão descomentados conforme os arquivos forem migrados
+// ============================================================================
+// COMPONENTS - BASE
+// export * from './lib/components/base/entity-list-base/entity-list-base.component';
+// export * from './lib/components/base/entity-form-base/entity-form-base.component';
+// COMPONENTS - FORMS
+// export * from './lib/components/forms/entity-form-fields/entity-form-fields.component';
+// export * from './lib/components/forms/entity-form-dialog/entity-form-dialog.component';
+// export * from './lib/components/forms/entity-form-drawer/entity-form-drawer.component';
+// export * from './lib/components/forms/sub-resource-form-dialog/sub-resource-form-dialog.component';
+// COMPONENTS - LISTS
+// export * from './lib/components/lists/form-filter/form-filter.component';
+// export * from './lib/components/lists/export-dialog/export-dialog.component';
+// export * from './lib/components/lists/bulk-delete-dialog/bulk-delete-dialog.component';
+// COMPONENTS - UI
+// export * from './lib/components/ui/breadcrumb/breadcrumb.component';
+// export * from './lib/components/ui/edit-inline/edit-inline.component';
+// export * from './lib/components/ui/lookup-field/lookup-field.component';
+// export * from './lib/components/ui/kanban-board/kanban-board.component';
+// export * from './lib/components/ui/theme-toggle/theme-toggle.component';
+// SERVICES
+// export * from './lib/services/entity.service';
+// export * from './lib/services/auth.service';
+// export * from './lib/services/translation.service';
+// export * from './lib/services/theme.service';
+// export * from './lib/services/permission.service';
+// export * from './lib/services/cookie.service';
+// export * from './lib/services/senior-token.service';
+// export * from './lib/services/mask.service';
+// DIRECTIVES
+// export * from './lib/directives/cep-mask.directive';
+// export * from './lib/directives/document-mask.directive';
+// export * from './lib/directives/phone-mask.directive';
+// PIPES
+// export * from './lib/pipes/translate.pipe';
+// INTERCEPTORS
+// export * from './lib/interceptors/api.interceptor';
+// MODELS - INTERFACES
+// export * from './lib/models/interfaces/base-entity.interface';
+// export * from './lib/models/interfaces/entity-config.interface';
+// export * from './lib/models/interfaces/entity-list.config';
+// MODELS - ENUMS
+// export * from './lib/models/enums/status.enum';
+// export * from './lib/models/enums/type-person.enum';
+// UTILS
+// export * from './lib/utils/utils';
+// I18N
+// export * from './lib/i18n/translation.config';
+// export * from './lib/i18n/locale.config';
+// export * from './lib/i18n/fallback';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AngularComponentsModule, AuthService, BreadcrumbComponent, BulkDeleteDialogComponent, CookieService, DEFAULT_LANGUAGE, DynamicFieldDateComponent, DynamicFieldDropdownComponent, DynamicFieldLookupComponent, DynamicFieldNumberComponent, DynamicFieldTextComponent, DynamicFieldTextareaComponent, DynamicFieldWrapperComponent, DynamicFormComponent, EntityService, ExportDialogComponent, PermissionService, SUPPORTED_LANGUAGES, SeniorTokenService, TRANSLATION_CONFIG, ThemeService, TranslationService, apiInterceptor, getLanguageInfo, mapTokenLocaleToLanguage };
+//# sourceMappingURL=seniorsistemas-components-ai.mjs.map