@ramonbsales/noah-angular 1.0.0 → 1.1.1

package/types/ramonbsales-noah-angular.d.ts

@@ -0,0 +1,754 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, EventEmitter, SimpleChanges, Injector, OnDestroy, InjectionToken } from '@angular/core';
+import { ControlValueAccessor, NgControl, FormControl, FormGroup } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+
+declare class SharedComponentsService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedComponentsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SharedComponentsService>;
+}
+
+declare class SharedComponentsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedComponentsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SharedComponentsComponent, "lib-shared-components", never, {}, {}, never, never, true, never>;
+}
+
+declare class DropdownComponent implements OnInit, OnChanges, ControlValueAccessor {
+    label: string;
+    placeholder: string;
+    options: {
+        value: any;
+        label: any;
+    }[];
+    disabled: boolean;
+    required: boolean;
+    errorMessage: string;
+    selectedOption: any;
+    hideLabel: boolean;
+    valueChange: EventEmitter<any>;
+    private internalValue;
+    isOpen: boolean;
+    private onChange;
+    private onTouched;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    selectOption(option: {
+        value: any;
+        label: any;
+    }): void;
+    toggleDropdown(): void;
+    getSelectedLabel(): string;
+    hasValue(): boolean;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "lib-dropdown", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "selectedOption": { "alias": "selectedOption"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+type InputType = 'text' | 'number' | 'date' | 'email' | 'password';
+declare class InputComponent implements OnInit, ControlValueAccessor {
+    private injector;
+    label: string;
+    placeholder: string;
+    type: InputType;
+    customErrorMessages: {
+        [key: string]: string;
+    };
+    get isRequired(): boolean;
+    get isDisabled(): boolean;
+    value: any;
+    isFocused: boolean;
+    control?: NgControl;
+    private onChange;
+    private onTouched;
+    private defaultErrorMessages;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    onFocus(): void;
+    onBlur(): void;
+    onInput(event: Event): void;
+    get showError(): boolean;
+    get showRequiredAsterisk(): boolean;
+    get errorMessage(): string;
+    private interpolateErrorMessage;
+    private validateField;
+    hasValue(): boolean;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "lib-input", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "customErrorMessages": { "alias": "customErrorMessages"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ButtonComponent {
+    title: string;
+    backgroundColor: string;
+    color: string;
+    borderColor: string;
+    minWidth: string;
+    disabled: boolean;
+    loading: boolean;
+    loadingText: string;
+    onClickEvent: EventEmitter<void>;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "lib-button", never, { "title": { "alias": "title"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "color": { "alias": "color"; "required": false; }; "borderColor": { "alias": "borderColor"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; }, { "onClickEvent": "onClickEvent"; }, never, never, true, never>;
+}
+
+declare class CheckboxComponent {
+    /** Array de opções: [{ label: string, value: any }] */
+    options: Array<{
+        label: string;
+        value: any;
+    }>;
+    /** Se true, permite múltipla seleção */
+    multiple: boolean;
+    /** FormControl do Reactive Forms */
+    control?: FormControl;
+    /** Emite valor selecionado ao pai (opcional) */
+    selectedChange: EventEmitter<any>;
+    get disabled(): boolean;
+    get selected(): any[] | any;
+    isChecked(value: any): boolean;
+    onOptionChange(event: Event, value: any): void;
+    get showError(): boolean;
+    get errorMessage(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "lib-checkbox", never, { "options": { "alias": "options"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+declare class ToggleComponent implements ControlValueAccessor {
+    title: string;
+    enableTitle: boolean;
+    value: boolean;
+    onChange: (value: boolean) => void;
+    onTouched: () => void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleComponent, "lib-toggle", never, { "title": { "alias": "title"; "required": false; }; "enableTitle": { "alias": "enableTitle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbComponent {
+    items: Array<{
+        label: string;
+        url?: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "lib-breadcrumb", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface TableAction {
+    title: string;
+    callback: (row: any) => void;
+    icon?: string;
+}
+interface TableColumn {
+    title: string;
+    prop: string;
+    sortable?: boolean;
+    width?: string;
+    actions?: TableAction[];
+}
+declare class TableComponent {
+    columns: TableColumn[];
+    data: any[];
+    columnTypes: {
+        [key: string]: 'string' | 'date' | 'time' | 'tag';
+    };
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    pageSizeOptions: {
+        value: number;
+        label: string;
+    }[];
+    pageChange: EventEmitter<number>;
+    pageSizeChange: EventEmitter<number>;
+    get hasActions(): boolean;
+    get actionsList(): TableAction[];
+    onPageSizeChange(newSize: number): void;
+    get totalPages(): number;
+    get currentPage(): number;
+    goToPage(page: number): void;
+    getPages(): (number | string)[];
+    toNumber(val: any): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "lib-table", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "columnTypes": { "alias": "columnTypes"; "required": false; }; "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
+}
+
+/**
+ * Interface para itens do menu lateral
+ */
+interface SidebarMenuItem {
+    id: string;
+    label: string;
+    icon: string;
+    route?: string;
+    action?: () => void;
+    children?: SidebarMenuItem[];
+    isExpanded?: boolean;
+    isActive?: boolean;
+    disabled?: boolean;
+    badge?: string | number;
+    divider?: boolean;
+}
+/**
+ * Configurações do sidebar
+ */
+interface SidebarConfig {
+    width?: string;
+    collapsedWidth?: string;
+    position?: 'left' | 'right';
+    collapsible?: boolean;
+    autoCollapse?: boolean;
+    overlay?: boolean;
+    logo?: {
+        src: string;
+        alt: string;
+        route?: string;
+    };
+    theme?: 'light' | 'dark';
+    customCssClass?: string;
+}
+/**
+ * Estado do sidebar
+ */
+interface SidebarState {
+    isCollapsed: boolean;
+    isMobile: boolean;
+    isOverlayOpen: boolean;
+    activeItemId?: string;
+}
+/**
+ * Eventos emitidos pelo sidebar
+ */
+interface SidebarEvents {
+    itemClick: SidebarMenuItem;
+    toggle: boolean;
+    overlayToggle: boolean;
+    logoClick: void;
+}
+
+declare class SidebarComponent implements OnInit, OnDestroy {
+    private destroy$;
+    private router;
+    config: Partial<SidebarConfig>;
+    menuItems: SidebarMenuItem[];
+    isCollapsed: boolean;
+    itemClick: EventEmitter<SidebarMenuItem>;
+    toggle: EventEmitter<boolean>;
+    overlayToggle: EventEmitter<boolean>;
+    logoClick: EventEmitter<void>;
+    private state$;
+    defaultConfig: Required<SidebarConfig>;
+    get currentState(): SidebarState;
+    get finalConfig(): Required<SidebarConfig>;
+    get sidebarWidth(): string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Detecta mudanças de tela
+     */
+    onResize(event: any): void;
+    /**
+     * Inicializa o estado do sidebar
+     */
+    private initializeState;
+    /**
+     * Verifica se está em modo mobile
+     */
+    private checkMobileState;
+    /**
+     * Detecta rota ativa
+     */
+    private detectActiveRoute;
+    /**
+     * Encontra item ativo baseado na URL
+     */
+    private findActiveItem;
+    /**
+     * Atualiza o estado
+     */
+    private updateState;
+    /**
+     * Toggle do sidebar
+     */
+    toggleSidebar(): void;
+    /**
+     * Toggle do overlay (mobile)
+     */
+    toggleOverlay(): void;
+    /**
+     * Clique no item do menu
+     */
+    onItemClick(item: SidebarMenuItem, event: Event): void;
+    /**
+     * Toggle expansão de item com filhos
+     */
+    toggleItemExpansion(item: SidebarMenuItem): void;
+    /**
+     * Clique no logo
+     */
+    onLogoClick(): void;
+    /**
+     * Fecha overlay ao clicar fora (mobile)
+     */
+    closeOverlay(): void;
+    /**
+     * Verifica se item está ativo
+     */
+    isItemActive(item: SidebarMenuItem): boolean;
+    /**
+     * Verifica se item tem filhos ativos
+     */
+    hasActiveChild(item: SidebarMenuItem): boolean;
+    /**
+     * TrackBy function para performance
+     */
+    trackByItemId(index: number, item: SidebarMenuItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SidebarComponent, "lib-sidebar", never, { "config": { "alias": "config"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "isCollapsed": { "alias": "isCollapsed"; "required": false; }; }, { "itemClick": "itemClick"; "toggle": "toggle"; "overlayToggle": "overlayToggle"; "logoClick": "logoClick"; }, never, ["[slot=footer]"], true, never>;
+}
+
+/**
+ * Tipos e interfaces para autenticação
+ */
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+interface LoginResponse {
+    success: boolean;
+    accessToken?: string;
+    user?: UserInfo;
+    expiresIn?: number;
+    message?: string;
+    errors?: string[];
+}
+interface UserInfo {
+    id: string;
+    nome: string;
+    email: string;
+    perfil: string;
+    permissoes: string[];
+    avatar?: string;
+    lastLogin?: Date;
+}
+interface LogoutResponse {
+    success: boolean;
+    message?: string;
+}
+interface RefreshTokenResponse {
+    success: boolean;
+    accessToken?: string;
+    expiresIn?: number;
+    message?: string;
+}
+/**
+ * Estados do processo de login
+ */
+declare enum LoginStatus {
+    IDLE = "IDLE",
+    LOADING = "LOADING",
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+/**
+ * Configurações opcionais para o login
+ */
+interface LoginOptions {
+    title?: string;
+    subtitle?: string;
+    logoUrl?: string;
+    backgroundUrl?: string;
+    footerText?: string;
+    redirectUrl?: string;
+    showForgotPassword?: boolean;
+    showRegisterLink?: boolean;
+    passwordMinLength?: number;
+    links?: {
+        forgotPassword?: string;
+        register?: string;
+        termsOfService?: string;
+        privacyPolicy?: string;
+    };
+    theme?: 'light' | 'dark' | 'auto';
+    primaryColor?: string;
+}
+/**
+ * Interface que a aplicação deve implementar para comunicação com o backend
+ */
+interface AuthProvider {
+    /**
+     * Realiza login no backend
+     */
+    login(credentials: LoginCredentials): Promise<LoginResponse>;
+    /**
+     * Realiza logout no backend
+     */
+    logout(): Promise<LogoutResponse>;
+    /**
+     * Renova o access token (opcional - se não implementado, usa apenas frontend)
+     */
+    refreshToken?(): Promise<RefreshTokenResponse>;
+    /**
+     * Verifica se o token ainda é válido no backend (opcional)
+     */
+    validateToken?(token: string): Promise<boolean>;
+}
+/**
+ * Dados de erro de validação de formulário
+ */
+interface LoginValidationErrors {
+    email?: string[];
+    password?: string[];
+    general?: string[];
+}
+/**
+ * Estado completo do login para uso reativo
+ */
+interface LoginState {
+    status: LoginStatus;
+    user: UserInfo | null;
+    isAuthenticated: boolean;
+    errors: LoginValidationErrors;
+    lastAttempt: Date | null;
+}
+
+type StorageType = 'localStorage' | 'sessionStorage';
+interface StorageOptions {
+    encrypt?: boolean;
+    compress?: boolean;
+}
+declare class LocalStorageService {
+    private storageAvailable;
+    get storageAvailable$(): Observable<boolean>;
+    /**
+     * Salva item no storage com validação básica
+     */
+    setItem<T>(key: string, value: T, storageType?: StorageType, options?: StorageOptions): Promise<boolean>;
+    /**
+     * Recupera item do storage com tipo seguro
+     */
+    getItem<T>(key: string, storageType?: StorageType, options?: StorageOptions): Promise<T | null>;
+    /**
+     * Remove item específico
+     */
+    removeItem(key: string, storageType?: StorageType): boolean;
+    /**
+     * Limpa todo o storage
+     */
+    clear(storageType?: StorageType): boolean;
+    /**
+     * Verifica se item existe
+     */
+    hasItem(key: string, storageType?: StorageType): boolean;
+    /**
+     * Salva item com expiração
+     */
+    setItemWithExpiry<T>(key: string, value: T, expiryInMinutes: number, storageType?: StorageType): Promise<boolean>;
+    /**
+     * Recupera item com verificação de expiração
+     */
+    getItemWithExpiry<T>(key: string, storageType?: StorageType): Promise<T | null>;
+    /**
+     * Obtém todas as chaves do storage
+     */
+    getAllKeys(storageType?: StorageType): string[];
+    /**
+     * Obtém tamanho ocupado do storage em bytes (aproximado)
+     */
+    getStorageSize(storageType?: StorageType): number;
+    /**
+     * Monitor de eventos de storage
+     */
+    monitorStorageEvents(): Observable<StorageEvent>;
+    /**
+     * Limpa itens expirados do storage
+     */
+    cleanExpiredItems(storageType?: StorageType): Promise<number>;
+    /**
+     * Backup de todos os dados do storage
+     */
+    backup(storageType?: StorageType): {
+        [key: string]: any;
+    };
+    /**
+     * Restaura backup para o storage
+     */
+    restore(backup: {
+        [key: string]: any;
+    }, storageType?: StorageType): boolean;
+    /**
+     * MÉTODOS PRIVADOS SIMPLIFICADOS
+     */
+    private isStorageAvailable;
+    private getStorage;
+    private sanitizeKey;
+    private validateKey;
+    private safeJsonStringify;
+    private safeJsonParse;
+    private encryptData;
+    private decryptData;
+    private validateStorageEvent;
+    private lastEventTime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
+}
+
+declare class AuthStorageService {
+    private storage;
+    private readonly TOKEN_KEY;
+    private readonly USER_DATA_KEY;
+    private isAuthenticated$;
+    get authState$(): Observable<boolean>;
+    constructor(storage: LocalStorageService);
+    private initAuthState;
+    /**
+     * Salva Access Token COM CRIPTOGRAFIA (backend fará todas as validações)
+     */
+    setToken(token: string, expiryInMinutes?: number): Promise<boolean>;
+    /**
+     * Recupera Access Token COM DESCRIPTOGRAFIA e validação de expiração
+     */
+    getToken(): Promise<string | null>;
+    /**
+     * Salva dados do usuário COM CRIPTOGRAFIA e validação básica
+     */
+    setUserData(userData: any): Promise<boolean>;
+    /**
+     * Recupera dados do usuário COM DESCRIPTOGRAFIA
+     */
+    getUserData<T = any>(): Promise<T | null>;
+    /**
+     * Verifica apenas se possui token (backend validará se é válido)
+     */
+    hasToken(): Promise<boolean>;
+    /**
+     * Verifica se está "aparentemente" autenticado (token existe)
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Limpa APENAS dados do cliente (não afeta refresh token no servidor)
+     */
+    clearAuthData(): void;
+    /**
+     * Decodifica payload do JWT (SEM validação - apenas para UI)
+     * IMPORTANTE: Use apenas para exibição, nunca para lógica de segurança
+     *
+     * ⚠️ ATENÇÃO: Agora requer token como parâmetro ou uso assíncrono
+     */
+    decodeTokenPayload(token?: string): any;
+    /**
+     * Versão síncrona DESATUALIZADA (tokens agora são criptografados)
+     * ⚠️ AVISO: Esta versão não funciona mais com tokens criptografados
+     * Use getToken() async para acessar tokens de forma segura
+     */
+    private getTokenSync;
+    /**
+     * Verifica se token está próximo de expirar (para UI)
+     * ⚠️ ATENÇÃO: Agora é assíncrono devido à criptografia
+     */
+    isTokenExpiringSoon(minutesThreshold?: number): Promise<boolean>;
+    /**
+     * Método utilitário: Obtém e decodifica token em uma operação
+     * Ideal para componentes que precisam dos dados do token para UI
+     */
+    getDecodedTokenData(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthStorageService>;
+}
+
+/**
+ * Token de injeção para o AuthProvider
+ */
+declare const AUTH_PROVIDER: InjectionToken<AuthProvider>;
+declare class LoginService {
+    private authStorage;
+    private authProvider?;
+    private readonly DEFAULT_OPTIONS;
+    private loginState$;
+    private currentOptions;
+    constructor(authStorage: AuthStorageService, authProvider?: AuthProvider | undefined);
+    /**
+     * Observable do estado completo do login
+     */
+    get state$(): Observable<LoginState>;
+    /**
+     * Observable apenas do status de loading
+     */
+    get isLoading$(): Observable<boolean>;
+    /**
+     * Observable apenas do status de autenticação
+     */
+    get isAuthenticated$(): Observable<boolean>;
+    /**
+     * Observable apenas dos erros
+     */
+    get errors$(): Observable<LoginValidationErrors>;
+    /**
+     * Observable do usuário atual
+     */
+    get currentUser$(): Observable<UserInfo | null>;
+    /**
+     * Configura opções do serviço de login
+     */
+    configure(options: Partial<LoginOptions>): void;
+    /**
+     * Realiza login com as credenciais fornecidas
+     */
+    login(credentials: LoginCredentials): Promise<LoginResponse>;
+    /**
+     * Realiza logout
+     */
+    logout(): Promise<LogoutResponse>;
+    /**
+     * Verifica se o usuário atual está autenticado
+     */
+    checkAuthenticationStatus(): Promise<boolean>;
+    /**
+     * Obtém informações do usuário atual
+     */
+    getCurrentUser(): Promise<UserInfo | null>;
+    /**
+     * Verifica se token está expirando em breve
+     * ⚠️ ATENÇÃO: Agora é assíncrono devido à criptografia
+     */
+    isTokenExpiringSoon(minutesThreshold?: number): Promise<boolean>;
+    /**
+     * Limpa erros do estado atual
+     */
+    clearErrors(): void;
+    /**
+     * Reseta estado do login
+     */
+    resetLoginState(): Promise<void>;
+    /**
+     * Inicializa o serviço
+     */
+    private initializeService;
+    /**
+     * Atualiza estado reativo
+     */
+    private updateState;
+    /**
+     * Valida credenciais do formulário
+     */
+    private validateCredentials;
+    /**
+     * Trata login bem-sucedido
+     */
+    private handleSuccessfulLogin;
+    /**
+     * Trata falha de login
+     */
+    private handleFailedLogin;
+    /**
+     * Simula resposta de login para desenvolvimento/demo
+     */
+    private simulateLogin;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginService>;
+}
+
+declare class LoginComponent implements OnInit, OnDestroy {
+    private loginService;
+    private destroy$;
+    private fb;
+    options: Partial<LoginOptions>;
+    showHeader: boolean;
+    showFooter: boolean;
+    logoUrl?: string;
+    backgroundImageUrl?: string;
+    customCssClass?: string;
+    loginSuccess: EventEmitter<LoginResponse>;
+    loginError: EventEmitter<string>;
+    formChange: EventEmitter<LoginCredentials>;
+    loginForm: FormGroup;
+    loginState$: rxjs.Observable<LoginState>;
+    isLoading$: rxjs.Observable<boolean>;
+    errors$: rxjs.Observable<any>;
+    showPassword: boolean;
+    LoginStatus: typeof LoginStatus;
+    constructor(loginService: LoginService);
+    /**
+     * Inicializa os observables
+     */
+    private initializeObservables;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Cria o formulário reativo
+     */
+    private createForm;
+    /**
+     * Manipula mudanças de estado do login
+     */
+    private handleStateChange;
+    /**
+     * Submete o formulário de login
+     */
+    onSubmit(): Promise<void>;
+    /**
+     * Alterna visibilidade da senha
+     */
+    togglePasswordVisibility(): void;
+    /**
+     * Marca todos os campos como tocados para mostrar erros
+     */
+    private markFormGroupTouched;
+    /**
+     * Verifica se campo tem erro específico
+     */
+    hasFieldError(fieldName: string, errorType: string): boolean;
+    /**
+     * Obtém mensagem de erro do campo
+     */
+    getFieldErrorMessage(fieldName: string): string;
+    /**
+     * Obtém label do campo
+     */
+    private getFieldLabel;
+    /**
+     * Reseta o formulário
+     */
+    resetForm(): void;
+    /**
+     * Tenta fazer login com credenciais de demonstração
+     */
+    loginWithDemo(userType: 'admin' | 'professor' | 'aluno'): Promise<void>;
+    /**
+     * Manipula esqueci minha senha
+     */
+    onForgotPassword(): void;
+    /**
+     * Manipula criação de conta
+     */
+    onCreateAccount(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoginComponent, "lib-login", never, { "options": { "alias": "options"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "logoUrl": { "alias": "logoUrl"; "required": false; }; "backgroundImageUrl": { "alias": "backgroundImageUrl"; "required": false; }; "customCssClass": { "alias": "customCssClass"; "required": false; }; }, { "loginSuccess": "loginSuccess"; "loginError": "loginError"; "formChange": "formChange"; }, never, never, true, never>;
+}
+
+/**
+ * Interceptor HTTP para autenticação automática
+ * Adiciona o Access Token nas requisições e trata erros 401
+ */
+declare class AuthInterceptor implements HttpInterceptor {
+    private authStorage;
+    constructor(authStorage: AuthStorageService);
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+}
+
+export { AUTH_PROVIDER, AuthInterceptor, AuthStorageService, BreadcrumbComponent, ButtonComponent, CheckboxComponent, DropdownComponent, InputComponent, LocalStorageService, LoginComponent, LoginService, LoginStatus, SharedComponentsComponent, SharedComponentsService, SidebarComponent, TableComponent, ToggleComponent };
+export type { AuthProvider, InputType, LoginCredentials, LoginOptions, LoginResponse, LoginState, LoginValidationErrors, LogoutResponse, RefreshTokenResponse, SidebarConfig, SidebarEvents, SidebarMenuItem, SidebarState, StorageOptions, StorageType, TableAction, TableColumn, UserInfo };