@seniorsistemas/components-ai 0.0.0-master-d4a804fe

package/lib/directives/phone-mask.directive.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PhoneMaskDirective {
+    private el;
+    constructor(el: ElementRef);
+    onInput(event: any): void;
+    onBlur(event: any): void;
+    private applyPhoneMask;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PhoneMaskDirective, "[siaPhoneMask]", never, {}, {}, never, never, true, never>;
+}

package/lib/interceptors/api.interceptor.d.ts

@@ -0,0 +1,2 @@
+import { HttpInterceptorFn } from '@angular/common/http';
+export declare const apiInterceptor: HttpInterceptorFn;

package/lib/models/base-entity.interface.d.ts

@@ -0,0 +1,7 @@
+export interface BaseEntity {
+    createdBy?: string;
+    createdAt?: Date;
+    changedBy?: string;
+    changedAt?: Date;
+    custom?: any;
+}

package/lib/models/entity-list.config.d.ts

@@ -0,0 +1,161 @@
+import { TemplateRef } from '@angular/core';
+import { ValidatorFn } from '@angular/forms';
+/**
+ * Column configuration for entity list table
+ */
+export interface ColumnConfig {
+    field: string;
+    header: string;
+    sortable?: boolean;
+    width?: string;
+    type?: 'text' | 'number' | 'status' | 'custom';
+    customTemplate?: TemplateRef<any>;
+}
+/**
+ * Lookup column configuration
+ */
+export interface LookupColumn {
+    field: string;
+    header: string;
+    width?: string;
+    type?: 'text' | 'number';
+}
+/**
+ * Responsive size configuration for filter fields
+ */
+export interface FilterFieldSize {
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+}
+/**
+ * Filter section configuration for grouping filters
+ */
+export interface FilterSection {
+    title: string;
+    filters: FilterConfig[];
+}
+/**
+ * Filter configuration for entity list
+ */
+export interface FilterConfig {
+    field: string;
+    label: string;
+    type: 'text' | 'number' | 'dropdown' | 'lookup' | 'date';
+    options?: any[];
+    placeholder?: string;
+    optionLabel?: string;
+    optionValue?: string;
+    defaultValue?: any;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    disabledWhen?: {
+        field: string;
+        value: any;
+    };
+    colspan?: number;
+    size?: FilterFieldSize;
+    colspanXs?: number;
+    colspanSm?: number;
+    colspanMd?: number;
+    colspanLg?: number;
+    colspanXl?: number;
+    lookupService?: any;
+    lookupDisplayField?: string;
+    lookupDisplayFields?: string[];
+    lookupValueField?: string;
+    lookupSearchFields?: string[];
+    lookupColumns?: LookupColumn[];
+    lookupDynamicFilters?: (formValues: any) => {
+        [key: string]: any;
+    };
+}
+/**
+ * Form field configuration for entity form
+ */
+export interface FormFieldConfig {
+    field: string;
+    label: string;
+    type: 'text' | 'number' | 'dropdown' | 'lookup' | 'textarea' | 'enum' | 'date';
+    validators?: ValidatorFn[];
+    options?: any[];
+    required?: boolean;
+    placeholder?: string;
+    optionLabel?: string;
+    optionValue?: string;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    useGrouping?: boolean;
+    rows?: number;
+    fullSize?: boolean;
+    colspan?: number;
+    colspanWhen?: {
+        field: string;
+        value: any;
+        colspan: number;
+    }[];
+    visibleWhen?: {
+        field: string;
+        value: any;
+    };
+    disabledWhen?: {
+        field: string;
+        value: any;
+    };
+    defaultValue?: any;
+    lookupService?: any;
+    lookupDisplayField?: string;
+    lookupDisplayFields?: string[];
+    lookupValueField?: string;
+    lookupSearchFields?: string[];
+    lookupColumns?: LookupColumn[];
+    lookupFilters?: {
+        [key: string]: any;
+    };
+    lookupDynamicFilters?: (formValues: any) => {
+        [key: string]: any;
+    };
+    enumOptions?: {
+        value: any;
+        label: string;
+    }[];
+    enumValues?: string[];
+    enumLabels?: {
+        [key: string]: string;
+    };
+    useCepMask?: boolean;
+    usePhoneMask?: boolean;
+    mask?: 'dynamic' | 'cpf' | 'cnpj' | 'cep' | 'phone' | 'document';
+    disabled?: boolean;
+    dateFormat?: string;
+    minFractionDigits?: number;
+    maxFractionDigits?: number;
+    numberMode?: 'decimal' | 'currency';
+    currency?: string;
+    locale?: string;
+    showClear?: boolean;
+    filter?: boolean;
+    filterBy?: string;
+    lookupEntity?: string;
+}
+/**
+ * Entity list configuration
+ */
+export interface EntityListConfig {
+    entityName: string;
+    entityIcon: string;
+    subtitle: string;
+    columns: ColumnConfig[];
+    filters: FilterConfig[];
+    fixedFilters?: FilterConfig[];
+    filterSections?: FilterSection[];
+    formFields: FormFieldConfig[];
+    exportEnabled?: boolean;
+    bulkDeleteEnabled?: boolean;
+    addButtonLabel?: string;
+}

package/lib/pipes/translate.pipe.d.ts

@@ -0,0 +1,21 @@
+import { PipeTransform, OnDestroy, ChangeDetectorRef } from '@angular/core';
+import { TranslationService } from '../services/translation.service';
+import * as i0 from "@angular/core";
+export declare class TranslatePipe implements PipeTransform, OnDestroy {
+    private translationService;
+    private cdr;
+    private subscription?;
+    private lastKey?;
+    private lastParams?;
+    private lastTranslation?;
+    private isLoading;
+    constructor(translationService: TranslationService, cdr: ChangeDetectorRef);
+    transform(key: string, params?: {
+        [key: string]: any;
+    }): string;
+    ngOnDestroy(): void;
+    private shouldUpdate;
+    private updateTranslation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TranslatePipe, "translate", true>;
+}

package/lib/services/auth.service.d.ts

@@ -0,0 +1,82 @@
+import { CookieService } from './cookie.service';
+import * as i0 from "@angular/core";
+export interface UserToken {
+    access_token: string;
+    expires_in: number;
+    refresh_token: string;
+    token_type: string;
+    refresh_expires_in: number;
+    username: string;
+    email: string;
+    fullName: string;
+    tenantName: string;
+    locale: string;
+    type: string;
+}
+export declare class AuthService {
+    private cookieService;
+    private readonly TOKEN_COOKIE_NAME;
+    private readonly API_URL_COOKIE_NAME;
+    private readonly API_PATH_SUFFIX;
+    private currentUserSubject;
+    currentUser$: import("rxjs").Observable<UserToken | null>;
+    constructor(cookieService: CookieService);
+    /**
+     * Load user token from cookie
+     */
+    private loadUserFromCookie;
+    /**
+     * Get current user token
+     */
+    getCurrentUser(): UserToken | null;
+    /**
+     * Get access token
+     */
+    getAccessToken(): string | null;
+    /**
+     * Get token type (e.g., "Bearer")
+     */
+    getTokenType(): string;
+    /**
+     * Get refresh token
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Get API base URL from cookie
+     */
+    getApiBaseUrl(): string | null;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Check if token is valid (not expired)
+     */
+    private isTokenValid;
+    /**
+     * Check if refresh token is valid
+     */
+    isRefreshTokenValid(): boolean;
+    /**
+     * Get user locale
+     */
+    getUserLocale(): string;
+    /**
+     * Get user full name
+     */
+    getUserFullName(): string;
+    /**
+     * Get user email
+     */
+    getUserEmail(): string;
+    /**
+     * Get tenant name
+     */
+    getTenantName(): string;
+    /**
+     * Get username
+     */
+    getUsername(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/lib/services/cookie.service.d.ts

@@ -0,0 +1,31 @@
+import * as i0 from "@angular/core";
+export declare class CookieService {
+    /**
+     * Obtém o valor de um cookie pelo nome
+     */
+    getCookie(name: string): string | null;
+    /**
+     * Define um cookie
+     */
+    setCookie(name: string, value: string, days?: number, path?: string): void;
+    /**
+     * Remove um cookie
+     */
+    deleteCookie(name: string, path?: string): void;
+    /**
+     * Verifica se um cookie existe
+     */
+    hasCookie(name: string): boolean;
+    /**
+     * Obtém todos os cookies como objeto
+     */
+    getAllCookies(): {
+        [key: string]: string;
+    };
+    /**
+     * Debug: Lista todos os cookies disponíveis
+     */
+    debugAllCookies(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CookieService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CookieService>;
+}

package/lib/services/entity.service.d.ts

@@ -0,0 +1,99 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface SortMeta {
+    field: string;
+    order: number;
+}
+export interface ListParams {
+    page?: number;
+    size?: number;
+    sort?: SortMeta[];
+    filterQuery?: string;
+    displayFields?: string[];
+}
+export interface BodyParams {
+    offset?: number;
+    size?: number;
+    orderBy?: string;
+    filter?: string;
+    displayfields?: string;
+}
+export interface EntityListResponse<T> {
+    contents: T[];
+    totalElements: number;
+    totalPages: number;
+    size?: number;
+    number?: number;
+    first?: boolean;
+    last?: boolean;
+}
+export interface TranslationService {
+    translate(key: string, params?: any): string;
+}
+export declare abstract class EntityService<T> {
+    protected http: HttpClient;
+    protected translationService?: TranslationService | undefined;
+    protected abstract entityUrl: string;
+    protected abstract actionsUrl: string;
+    protected queriesUrl: string;
+    constructor(http: HttpClient, translationService?: TranslationService | undefined);
+    /**
+     * Initialize the service - call this after setting actionsUrl
+     */
+    protected initializeService(): void;
+    /**
+     * Convert ListParams to HttpParams for GET requests
+     */
+    protected getListQueryParams(listParams: ListParams): HttpParams;
+    /**
+     * Convert ListParams to body parameters for POST requests
+     */
+    protected getBodyParams(listParams: ListParams): BodyParams;
+    /**
+     * Default error handler
+     */
+    protected handleError: (error: any) => Observable<never>;
+    /**
+     * List entities with pagination, sorting, and filtering
+     */
+    list(listParams?: ListParams): Observable<EntityListResponse<T>>;
+    /**
+     * Get entity by ID
+     */
+    get(id: any): Observable<T>;
+    /**
+     * Create new entity
+     */
+    insert(entity: T): Observable<T>;
+    /**
+     * Update existing entity
+     */
+    update(id: any, entity: T): Observable<T>;
+    /**
+     * Delete entity by ID
+     */
+    delete(id: any): Observable<void>;
+    /**
+     * Execute custom filter action
+     */
+    listCustomFilter(listParams: ListParams, action: string): Observable<EntityListResponse<T>>;
+    /**
+     * Execute custom query
+     */
+    executeQuery(queryName: string, params?: any): Observable<any>;
+    /**
+     * Execute custom action
+     */
+    executeAction(actionName: string, params?: any): Observable<any>;
+    /**
+     * Check if entity exists by ID
+     */
+    exists(id: any): Observable<boolean>;
+    /**
+     * Bulk delete entities
+     */
+    bulkDelete(ids: any[]): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityService<any>>;
+}

package/lib/services/mask.service.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from "@angular/core";
+export declare class MaskService {
+    /**
+     * Aplica máscara de CPF (999.999.999-99) - 100% numérico
+     */
+    applyCpfMask(value: string): string;
+    /**
+     * Aplica máscara de CNPJ alfanumérico (XX.XXX.XXX/XXXX-XX)
+     * Aceita letras e números em todos os caracteres
+     */
+    applyCnpjMask(value: string): string;
+    /**
+     * 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: string, typePerson: 'NATURAL_PERSON' | 'JURIDICAL_PERSON'): string;
+    /**
+     * Remove a máscara de um documento (mantém apenas alfanuméricos)
+     */
+    removeMask(value: string): string;
+    /**
+     * Determina se um documento é CPF ou CNPJ baseado no comprimento
+     */
+    getDocumentType(value: string): 'cpf' | 'cnpj' | 'unknown';
+    /**
+     * Valida se um CPF tem formato válido (11 dígitos numéricos)
+     */
+    isValidCpfFormat(value: string): boolean;
+    /**
+     * Valida se um CNPJ tem formato válido (14 caracteres alfanuméricos)
+     */
+    isValidCnpjFormat(value: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaskService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MaskService>;
+}

package/lib/services/permission.service.d.ts

@@ -0,0 +1,91 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface PermissionRequest {
+    resource: string;
+    action: string;
+    context?: {
+        [key: string]: any;
+    };
+}
+export interface PermissionResponse {
+    allowed: boolean;
+    resource: string;
+    action: string;
+    reason?: string;
+}
+export interface CheckAccessRequest {
+    permissions: PermissionRequest[];
+}
+export interface CheckAccessResponse {
+    results: PermissionResponse[];
+}
+export interface AuthServiceInterface {
+    isAuthenticated(): boolean;
+    getAccessToken(): string | null;
+}
+export declare class PermissionService {
+    private http;
+    private authService?;
+    private readonly PERMISSION_ENDPOINT;
+    private permissionCache;
+    private cacheExpiry;
+    private readonly CACHE_DURATION;
+    constructor(http: HttpClient, authService?: AuthServiceInterface | undefined);
+    /**
+     * Check access for a single permission
+     */
+    checkAccess(resource: string, action: string, context?: {
+        [key: string]: any;
+    }): Observable<boolean>;
+    /**
+     * Check access for multiple permissions
+     */
+    checkMultipleAccess(permissions: PermissionRequest[]): Observable<PermissionResponse[]>;
+    /**
+     * Check if user can read a resource
+     */
+    canRead(resource: string, context?: {
+        [key: string]: any;
+    }): Observable<boolean>;
+    /**
+     * Check if user can write to a resource
+     */
+    canWrite(resource: string, context?: {
+        [key: string]: any;
+    }): Observable<boolean>;
+    /**
+     * Check if user can delete a resource
+     */
+    canDelete(resource: string, context?: {
+        [key: string]: any;
+    }): Observable<boolean>;
+    /**
+     * Check if user can execute an action on a resource
+     */
+    canExecute(resource: string, action: string, context?: {
+        [key: string]: any;
+    }): Observable<boolean>;
+    /**
+     * Clear permission cache
+     */
+    clearCache(): void;
+    /**
+     * Clear expired cache entries
+     */
+    clearExpiredCache(): void;
+    /**
+     * Generate cache key for permission
+     */
+    private getCacheKey;
+    /**
+     * Get cached permission result
+     */
+    private getCachedPermission;
+    /**
+     * Cache permission result
+     */
+    private cachePermission;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionService>;
+}

package/lib/services/senior-token.service.d.ts

@@ -0,0 +1,70 @@
+import { CookieService } from './cookie.service';
+import * as i0 from "@angular/core";
+export interface SeniorTokenData {
+    locale?: string;
+    userId?: string;
+    userName?: string;
+    access_token?: string;
+    expires_in?: number;
+    refresh_token?: string;
+    token_type?: string;
+    refresh_expires_in?: number;
+    username?: string;
+    email?: string;
+    fullName?: string;
+    tenantName?: string;
+    type?: string;
+    [key: string]: any;
+}
+/**
+ * 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.
+ */
+export declare class SeniorTokenService {
+    private cookieService;
+    private readonly SENIOR_TOKEN_COOKIE;
+    constructor(cookieService: CookieService);
+    /**
+     * Obtém o token Senior completo do cookie
+     */
+    getSeniorToken(): string | null;
+    /**
+     * Decodifica e obtém os dados do token Senior
+     */
+    getSeniorTokenData(): SeniorTokenData | null;
+    /**
+     * Obtém o locale do usuário do token Senior
+     */
+    getUserLocale(): string | null;
+    /**
+     * Obtém informações do usuário do token Senior
+     */
+    getUserInfo(): {
+        userId?: string;
+        userName?: string;
+        locale?: string;
+        email?: string;
+        fullName?: string;
+    } | null;
+    /**
+     * Verifica se o usuário está logado (token existe e é válido)
+     */
+    isUserLoggedIn(): boolean;
+    /**
+     * Monitora mudanças no cookie do token (para detectar login/logout)
+     */
+    watchTokenChanges(callback: (tokenData: SeniorTokenData | null) => void): void;
+    /**
+     * Valida se o token tem a estrutura esperada do Senior
+     */
+    validateTokenStructure(): {
+        isValid: boolean;
+        issues: string[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeniorTokenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SeniorTokenService>;
+}

package/lib/services/theme.service.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+export declare class ThemeService {
+    private document;
+    private isDarkModeSubject;
+    isDarkMode$: import("rxjs").Observable<boolean>;
+    private mediaQuery;
+    constructor(document: Document);
+    private followSystemTheme;
+    toggleTheme(): void;
+    setThemeMode(mode: 'light' | 'dark' | 'auto'): void;
+    private setTheme;
+    get isDarkMode(): boolean;
+    get currentThemeMode(): 'light' | 'dark' | 'auto';
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}

package/lib/services/translation.service.d.ts

@@ -0,0 +1,54 @@
+import { Observable } from 'rxjs';
+import { LanguageConfig } from '../config/translation.config';
+import { SeniorTokenService } from './senior-token.service';
+import * as i0 from "@angular/core";
+export type SupportedLanguage = 'pt-BR' | 'en-US' | 'es-ES';
+export interface TranslationLoader {
+    loadTranslations(language: string): Promise<any>;
+}
+export declare class TranslationService {
+    private seniorTokenService;
+    private currentLanguage;
+    private translations;
+    private loadingLanguages;
+    private translationLoader?;
+    constructor(seniorTokenService: SeniorTokenService, loader?: TranslationLoader);
+    get currentLanguage$(): Observable<SupportedLanguage>;
+    getCurrentLanguage(): SupportedLanguage;
+    setLanguage(language: SupportedLanguage): Promise<void>;
+    waitForTranslations(): Promise<void>;
+    /**
+     * Verifica se as traduções do idioma atual estão carregadas
+     */
+    isLanguageLoaded(language?: SupportedLanguage): boolean;
+    translate(key: string, params?: {
+        [key: string]: any;
+    }): string;
+    private loadTranslations;
+    private doLoadTranslations;
+    private loadStoredLanguage;
+    private replaceParams;
+    getSupportedLanguages(): LanguageConfig[];
+    /**
+     * Força o recarregamento das traduções (útil para desenvolvimento)
+     */
+    reloadTranslations(): Promise<void>;
+    /**
+     * Obtém todas as chaves de tradução carregadas
+     */
+    getLoadedKeys(): string[];
+    /**
+     * Verifica se um código de idioma é suportado
+     */
+    private isValidLanguage;
+    /**
+     * Monitora mudanças no token Senior para atualizar idioma automaticamente
+     */
+    private watchTokenChanges;
+    /**
+     * Força atualização do idioma baseado no token atual
+     */
+    syncWithToken(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationService>;
+}