@elasticias/ui 0.0.10

package/types/elasticias-ui.d.ts

@@ -0,0 +1,1868 @@
+import * as _angular_core from '@angular/core';
+import { PipeTransform, OnInit, OnDestroy, OnChanges, TemplateRef, EventEmitter, SimpleChanges } from '@angular/core';
+import { AppUtils } from '@elasticias/utils';
+import { Menu } from 'primeng/menu';
+import { ScreenContext } from '@elasticias/screens';
+import { BlockableUI } from 'primeng/api';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { InputNumber, InputNumberInputEvent } from 'primeng/inputnumber';
+import { Nullable } from 'primeng/ts-helpers';
+import * as _elasticias_ui from '@elasticias/ui';
+import { Table, TableLazyLoadEvent } from 'primeng/table';
+import { PrimeNG } from 'primeng/config';
+import { EfThemeConfigService } from '@elasticias/core';
+import { EmailMetrics, EmailEventRecord, EmailEventKind } from '@elasticias/types';
+
+/**
+ * Merged currency pipe from ERP (AppCurrencyPipe) and Store (CurrencyFormatPipe).
+ * Uses Intl.NumberFormat for formatting — no CurrencyPipe dependency needed.
+ * Default: MAD currency, fr-MA locale.
+ */
+declare class EfCurrencyPipe implements PipeTransform {
+    transform(value: number | null | undefined, currency?: string, locale?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfCurrencyPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<EfCurrencyPipe, "efCurrency", true>;
+}
+
+declare class TruncatePipe implements PipeTransform {
+    transform(value: string, maxLength?: number, suffix?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TruncatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
+}
+
+declare class EfPriceDisplayComponent {
+    readonly amount: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfPriceDisplayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfPriceDisplayComponent, "ef-price-display", never, { "amount": { "alias": "amount"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EfQuantitySelectorComponent {
+    readonly quantity: _angular_core.InputSignal<number>;
+    readonly quantityChange: _angular_core.OutputEmitterRef<number>;
+    increment(): void;
+    decrement(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfQuantitySelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfQuantitySelectorComponent, "ef-quantity-selector", never, { "quantity": { "alias": "quantity"; "required": false; "isSignal": true; }; }, { "quantityChange": "quantityChange"; }, never, never, true, never>;
+}
+
+/**
+ * Summary item for product count groups
+ */
+interface OrderSummaryItem {
+    code: string;
+    label: string;
+    count: number;
+    column: number;
+}
+/**
+ * Order products summary grouped by countGroup
+ */
+interface OrderProductsSummary {
+    items: OrderSummaryItem[];
+    totalCount: number;
+}
+/**
+ * Represents a line item in an order, invoice, or quote
+ */
+interface OrderLineItem {
+    id?: string | number;
+    product?: Record<string, unknown>;
+    productId?: unknown;
+    variantId?: string | null;
+    countGroup?: string;
+    productDescription?: string;
+    productUnitPrice: number;
+    quantity: number;
+    discount: number;
+    grossAmount: number;
+    amount?: number;
+    taxeId?: number | null;
+    taxRate?: number;
+    taxAmount?: number;
+    position?: number;
+    isEditing?: boolean;
+    editingField?: string | null;
+}
+/**
+ * Standard order entity contract
+ */
+interface OrderEntity {
+    id?: number;
+    documentNumber?: string;
+    documentType: 'order' | 'invoice' | 'quote';
+    status?: 'draft' | 'confirmed' | 'processing' | 'completed' | 'cancelled';
+    customerId?: string | null;
+    customerName?: string;
+    orderDate: Date;
+    deliveryDate?: Date | null;
+    dueDate?: Date | null;
+    orderLines: OrderLineItem[];
+    grossTotal: number;
+    discountTotal: number;
+    taxTotal: number;
+    finalTotal: number;
+    notes?: string;
+    internalNotes?: string;
+    paymentTerms?: string;
+    shippingAddress?: string;
+    billingAddress?: string;
+    productsSummary?: OrderProductsSummary;
+}
+/**
+ * Configuration for document types (order, invoice, quote)
+ */
+interface DocumentConfig {
+    documentType: 'order' | 'invoice' | 'quote';
+    headerLabel: string;
+    dateLabel: string;
+    customerLabel: string;
+    enableTax?: boolean;
+    enableDiscount?: boolean;
+    showCatalogue?: boolean;
+    allowInlineEdit?: boolean;
+    enableQuickAdd?: boolean;
+    showNotes?: boolean;
+    showProductsSummary?: boolean;
+    currencyCode?: string;
+    locale?: string;
+}
+/**
+ * Change tracking metadata
+ */
+interface OrderChangeInfo {
+    hasChanges: boolean;
+    lastModified: Date;
+    modifiedFields: Set<string>;
+}
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    isValid: boolean;
+    errors: {
+        [key: string]: string[];
+    };
+    warnings?: {
+        [key: string]: string[];
+    };
+}
+/**
+ * Helper functions for order line items
+ */
+declare class OrderLineItemHelper {
+    /**
+     * Calculate subtotal for a line item (price * quantity - discount)
+     */
+    static calculateSubtotal(item: OrderLineItem): number;
+    /**
+     * Calculate tax amount for a line item
+     */
+    static calculateTaxAmount(item: OrderLineItem): number;
+    /**
+     * Calculate final amount including tax
+     */
+    static calculateFinalAmount(item: OrderLineItem): number;
+    /**
+     * Compose a line description from a product and (optionally) its variant.
+     * Variable product → "{displayName} ({variantTitle})"
+     * Simple product → displayName
+     * Mirrors the legacy PDF format `[PF] {ref} - {NAME} ({volume})` after
+     * the parent displayName has been cleaned of its baked-in volume suffix.
+     */
+    static composeDescription(product: Record<string, unknown> | null | undefined, variant?: Record<string, unknown>): string;
+    /**
+     * Create a new empty line item
+     */
+    static createEmptyItem(): OrderLineItem;
+    /**
+     * Create a line item from product selection
+     * @param keyField - Field name used to identify the product (default: 'id')
+     */
+    static createFromProduct(product: Record<string, unknown>, quantity?: number, keyField?: string, variantId?: string): OrderLineItem;
+    /**
+     * Update calculations for an existing line item
+     */
+    static updateCalculations(item: OrderLineItem): OrderLineItem;
+    /**
+     * Validate a line item
+     */
+    static validate(item: OrderLineItem): ValidationResult;
+    /**
+     * Compare two line items for equality
+     */
+    static areEqual(item1: OrderLineItem, item2: OrderLineItem): boolean;
+}
+/**
+ * Helper functions for order entity
+ */
+declare class OrderEntityHelper {
+    /**
+     * Create a new empty order entity
+     */
+    static createEmpty(documentType?: 'order' | 'invoice' | 'quote'): OrderEntity;
+    /**
+     * Calculate all totals for an order
+     */
+    static calculateTotals(order: OrderEntity): OrderEntity;
+    /**
+     * Validate order entity
+     */
+    static validate(order: OrderEntity): ValidationResult;
+    /**
+     * Clone order entity for immutability
+     */
+    static clone(order: OrderEntity): OrderEntity;
+    /**
+     * Compare two orders for changes
+     */
+    static detectChanges(original: OrderEntity, current: OrderEntity): OrderChangeInfo;
+}
+
+/**
+ * Product count group entry for displaying grouped counts
+ */
+interface ProductCountGroup {
+    code: string;
+    label: string;
+    count: number;
+    column: number;
+}
+/**
+ * Reference data item for product count group labels
+ */
+interface ProductCountGroupLabel {
+    code: string;
+    label: string;
+    description?: string;
+    isActive?: boolean;
+    sortOrder?: number;
+    column?: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Product with countGroup field
+ */
+interface ProductWithCountGroup {
+    countGroup?: string;
+    [key: string]: unknown;
+}
+/**
+ * Displays a summary of product quantities grouped by their countGroup field.
+ * Maps countGroup codes to labels from product_count_group_labels reference data.
+ *
+ * @example
+ * <ef-order-summary
+ *   [orderLines]="orderLines()"
+ *   [countGroupLabels]="countGroupLabels"
+ * />
+ */
+declare class EfOrderSummaryComponent {
+    /**
+     * Order line items to summarize
+     */
+    orderLines: _angular_core.InputSignal<OrderLineItem[]>;
+    /**
+     * Product count group labels from reference data
+     */
+    countGroupLabels: _angular_core.InputSignal<ProductCountGroupLabel[]>;
+    /**
+     * Legend text for the fieldset
+     */
+    legend: _angular_core.InputSignal<string>;
+    /**
+     * Computed grouped counts by countGroup
+     */
+    groupedCounts: _angular_core.Signal<ProductCountGroup[]>;
+    /**
+     * Total quantity across all groups
+     */
+    totalCount: _angular_core.Signal<number>;
+    /**
+     * Split groups into columns based on column field from reference data
+     */
+    columnGroups: _angular_core.Signal<ProductCountGroup[][]>;
+    /**
+     * Check if there are any groups to display
+     */
+    hasGroups: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfOrderSummaryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfOrderSummaryComponent, "ef-order-summary", never, { "orderLines": { "alias": "orderLines"; "required": true; "isSignal": true; }; "countGroupLabels": { "alias": "countGroupLabels"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Reusable order builder component for orders, invoices, and quotes
+ * Manages complete order entity with automatic change tracking
+ *
+ * @example
+ * <ef-order-builder
+ *   [(order)]="orderEntity"
+ *   [config]="documentConfig"
+ *   [products]="products"
+ *   [customers]="customers"
+ *   (openCatalogue)="handleCatalogueOpen()"
+ *   (orderChanged)="handleOrderChange($event)"
+ * />
+ */
+declare class EfOrderBuilderComponent implements OnInit, OnDestroy {
+    rowTrackBy: (_: number, item: OrderLineItem) => string | number;
+    protected readonly AppUtils: typeof AppUtils;
+    config: _angular_core.InputSignal<DocumentConfig>;
+    order: _angular_core.ModelSignal<OrderEntity>;
+    products: _angular_core.InputSignal<Record<string, unknown>[]>;
+    customers: _angular_core.InputSignal<Record<string, unknown>[]>;
+    readonly: _angular_core.InputSignal<boolean>;
+    countGroupLabels: _angular_core.InputSignal<ProductCountGroupLabel[]>;
+    /** Field name used to identify products (must match catalogue's trackByField) */
+    productKeyField: _angular_core.InputSignal<string>;
+    backendErrors: _angular_core.InputSignal<{
+        [key: string]: string[];
+    }>;
+    openCatalogue: _angular_core.OutputEmitterRef<void>;
+    orderChanged: _angular_core.OutputEmitterRef<OrderChangeInfo>;
+    orderValidated: _angular_core.OutputEmitterRef<ValidationResult>;
+    productsAdded: _angular_core.OutputEmitterRef<OrderLineItem[]>;
+    private originalOrder;
+    private updateTimeout;
+    private initialized;
+    quickAddProduct: _angular_core.WritableSignal<Record<string, unknown>>;
+    quickAddPrice: _angular_core.WritableSignal<number>;
+    quickAddQuantity: _angular_core.WritableSignal<number>;
+    quickAddDisabled: _angular_core.Signal<boolean>;
+    orderLines: _angular_core.Signal<OrderLineItem[]>;
+    /**
+     * Flatten products → one option per active variant for the inline ef-select.
+     * Simple products (no variants) get a single row with the product label.
+     * Each option exposes `_displayLabel` for `optionLabel` and carries the
+     * underlying product/variant references for `onProductSelect`.
+     */
+    flattenedProductOptions: _angular_core.Signal<Record<string, unknown>[]>;
+    grossTotal: _angular_core.Signal<number>;
+    discountTotal: _angular_core.Signal<number>;
+    tvaTotal: _angular_core.Signal<number>;
+    finalTotal: _angular_core.Signal<number>;
+    currency: _angular_core.Signal<string>;
+    locale: _angular_core.Signal<string>;
+    hasItems: _angular_core.Signal<boolean>;
+    productsSummary: _angular_core.Signal<OrderProductsSummary>;
+    hasEditingRow: _angular_core.Signal<boolean>;
+    validationResult: _angular_core.Signal<ValidationResult>;
+    combinedErrors: _angular_core.Signal<{
+        [x: string]: string[];
+    }>;
+    hasErrors: _angular_core.Signal<boolean>;
+    isValid: _angular_core.Signal<boolean>;
+    changeInfo: _angular_core.Signal<OrderChangeInfo>;
+    hasChanges: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    addNewProductRow(): void;
+    removeOrderLine(id: number | undefined): void;
+    onProductSelect(item: OrderLineItem): void;
+    startEditField(item: OrderLineItem, fieldName: string): void;
+    stopEditField(item: OrderLineItem): void;
+    onFieldChange(item: OrderLineItem): void;
+    saveEditingRow(item: OrderLineItem): void;
+    calculateSubtotal(item: OrderLineItem): number;
+    handleOpenCatalogue(): void;
+    onQuickAddProductSelect(option: Record<string, unknown> | null): void;
+    addQuickProduct(): void;
+    addProductsFromCatalogue(selectedProducts: Array<{
+        product: Record<string, unknown>;
+        quantity: number;
+        variantId?: string;
+    }>): void;
+    updateCustomer(customerId: string | null): void;
+    updateOrderDate(date: Date): void;
+    updateDeliveryDate(date: Date | null): void;
+    updateNotes(notes: string): void;
+    resetChanges(): void;
+    markAsSaved(): void;
+    validate(): ValidationResult;
+    private updateOrderLines;
+    private getCustomerName;
+    private productKey;
+    getProduct(productId: unknown): Record<string, unknown> | undefined;
+    getCustomer(customerId: string): Record<string, unknown> | undefined;
+    initializeOrderLines(): void;
+    getTotals(): {
+        grossTotal: number;
+        discountTotal: number;
+        tvaTotal: number;
+        finalTotal: number;
+    };
+    exportOrder(): OrderEntity;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfOrderBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfOrderBuilderComponent, "ef-order-builder", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "order": { "alias": "order"; "required": true; "isSignal": true; }; "products": { "alias": "products"; "required": true; "isSignal": true; }; "customers": { "alias": "customers"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "countGroupLabels": { "alias": "countGroupLabels"; "required": false; "isSignal": true; }; "productKeyField": { "alias": "productKeyField"; "required": false; "isSignal": true; }; "backendErrors": { "alias": "backendErrors"; "required": false; "isSignal": true; }; }, { "order": "orderChange"; "openCatalogue": "openCatalogue"; "orderChanged": "orderChanged"; "orderValidated": "orderValidated"; "productsAdded": "productsAdded"; }, never, never, true, never>;
+}
+
+interface CategoryItem {
+    code: string;
+    label: string;
+    description?: string | null;
+    isActive: boolean;
+    sortOrder: number;
+    metadata?: Record<string, unknown> | null;
+    children?: CategoryItem[];
+}
+interface CategoryGroup {
+    code: string;
+    label: string;
+    description?: string | null;
+    isActive: boolean;
+    sortOrder: number;
+    metadata?: Record<string, unknown> | null;
+    children?: CategoryItem[];
+}
+interface CategoryAssignment {
+    type: string;
+    code: string;
+}
+interface SelectedFilter {
+    type: string;
+    code: string;
+    label: string;
+}
+declare class EfProductCatalogueFilterComponent {
+    /** Category groups from reference_data (product_categories items with children) */
+    categoryGroups: _angular_core.InputSignal<CategoryGroup[]>;
+    /** Products to calculate counts */
+    products: _angular_core.InputSignal<{
+        categoryAssignments?: CategoryAssignment[];
+    }[]>;
+    /** Selected filters (two-way binding) */
+    selectedFilters: _angular_core.ModelSignal<SelectedFilter[]>;
+    /** Emitted when filters change */
+    filtersChanged: _angular_core.OutputEmitterRef<SelectedFilter[]>;
+    /** Search terms for each category group */
+    searchTerms: _angular_core.WritableSignal<Record<string, string>>;
+    /** Accordion panel values (expanded panels) */
+    expandedPanels: _angular_core.Signal<string[]>;
+    /** Get filtered children for a category group based on search */
+    getFilteredChildren(group: CategoryGroup): CategoryItem[];
+    /** Get product count for a specific category item */
+    getItemCount(groupCode: string, itemCode: string): number;
+    /** Check if a filter is selected */
+    isFilterSelected(groupCode: string, itemCode: string): boolean;
+    /** Toggle a filter selection */
+    toggleFilter(group: CategoryGroup, item: CategoryItem): void;
+    /** Remove a specific filter */
+    removeFilter(filter: SelectedFilter): void;
+    /** Clear all filters */
+    clearAllFilters(): void;
+    /** Update search term for a category group */
+    updateSearchTerm(groupCode: string, term: string): void;
+    /** Get color class from metadata if available */
+    getColorClass(item: CategoryItem): string | null;
+    /** Check if group should show search input (more than 5 items) */
+    shouldShowSearch(group: CategoryGroup): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfProductCatalogueFilterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfProductCatalogueFilterComponent, "ef-product-catalogue-filter", never, { "categoryGroups": { "alias": "categoryGroups"; "required": true; "isSignal": true; }; "products": { "alias": "products"; "required": true; "isSignal": true; }; "selectedFilters": { "alias": "selectedFilters"; "required": false; "isSignal": true; }; }, { "selectedFilters": "selectedFiltersChange"; "filtersChanged": "filtersChanged"; }, never, never, true, never>;
+}
+
+interface CatalogueProductVariant {
+    variantId: string;
+    title: string;
+    sku?: string | null;
+    price: number;
+    compareAtPrice?: number | null;
+    optionValues?: Record<string, string>;
+    isActive?: boolean;
+    countGroup?: string | null;
+    [key: string]: unknown;
+}
+interface CatalogueProduct {
+    id: number;
+    productCode: string;
+    name: string;
+    displayName: string;
+    unitPrice?: number | null;
+    packagingVolume?: number | null;
+    categoryAssignments?: CategoryAssignment[];
+    productType?: string | null;
+    variants?: CatalogueProductVariant[];
+    defaultVariantId?: string | null;
+    [key: string]: unknown;
+}
+declare class EfProductCatalogueComponent implements OnChanges {
+    private readonly locale;
+    private readonly currencyPipe;
+    /** Products to display */
+    products: _angular_core.InputSignal<CatalogueProduct[]>;
+    /** Category groups for filtering */
+    categoryGroups: _angular_core.InputSignal<CategoryGroup[]>;
+    /** Initial selected items (for editing existing orders) */
+    initialSelectedItems: _angular_core.InputSignal<{
+        productId?: unknown;
+        quantity: number;
+        variantId?: string | null;
+    }[]>;
+    /** Default filters to apply on init */
+    defaultFilters: _angular_core.InputSignal<SelectedFilter[]>;
+    /** Property name used as unique key for tracking products in the list */
+    trackByField: _angular_core.InputSignal<string>;
+    /** Currency code for price formatting */
+    currencyCode: _angular_core.InputSignal<string>;
+    /** Locale used for number/currency formatting and the quantity stepper */
+    localeCode: _angular_core.InputSignal<string>;
+    /**
+     * Custom product thumbnail template.
+     * Context: { $implicit: CatalogueProduct }
+     *
+     * @example
+     * <ef-product-catalogue [products]="products()">
+     *   <ng-template #productThumbnail let-product>
+     *     <my-custom-thumbnail [product]="product" />
+     *   </ng-template>
+     * </ef-product-catalogue>
+     */
+    productThumbnailTpl: _angular_core.Signal<TemplateRef<unknown>>;
+    sortMenu: Menu;
+    /** Emitted when products are validated */
+    productsValidated: _angular_core.OutputEmitterRef<{
+        product: CatalogueProduct;
+        quantity: number;
+        variantId?: string;
+    }[]>;
+    productSearch: _angular_core.WritableSignal<string>;
+    selectedFilters: _angular_core.WritableSignal<SelectedFilter[]>;
+    selectedSort: _angular_core.WritableSignal<string>;
+    selectedProducts: _angular_core.WritableSignal<{
+        product: CatalogueProduct;
+        quantity: number;
+        variantId?: string;
+    }[]>;
+    /** Tracks the currently selected variantId per product key */
+    selectedVariants: _angular_core.WritableSignal<Record<string, string>>;
+    filteredProducts: _angular_core.Signal<CatalogueProduct[]>;
+    sortOptions: {
+        label: string;
+        icon: string;
+        command: () => void;
+    }[];
+    onFiltersChanged(filters: SelectedFilter[]): void;
+    ngOnChanges(): void;
+    productKey(product: CatalogueProduct): unknown;
+    private initializeSelectedProducts;
+    private initializeDefaultFilters;
+    toggleSortMenu(event: Event): void;
+    /** Composite key for tracking product+variant selections */
+    private selectionKey;
+    /** Get the selected variantId for a product, or its defaultVariantId */
+    getSelectedVariantId(product: CatalogueProduct): string | undefined;
+    /** Set the selected variant for a product */
+    setSelectedVariant(product: CatalogueProduct, variantId: string): void;
+    /** Check if product is a VARIABLE product with variants */
+    isVariableProduct(product: CatalogueProduct): boolean;
+    /** Get active variants for a product */
+    getActiveVariants(product: CatalogueProduct): CatalogueProductVariant[];
+    /** Get total quantity for a product across all its variants */
+    getProductQuantity(product: CatalogueProduct): number;
+    /** Get quantity for a specific product+variant combination */
+    getVariantQuantity(product: CatalogueProduct, variantId: string): number;
+    addProduct(product: CatalogueProduct): void;
+    removeProduct(product: CatalogueProduct): void;
+    removeVariantSelection(product: CatalogueProduct, variantId: string): void;
+    updateProductQuantity(product: CatalogueProduct, quantity: number): void;
+    updateVariantQuantity(product: CatalogueProduct, variantId: string, quantity: number): void;
+    validateSelection(): void;
+    getPackagingLabel(product: CatalogueProduct): string;
+    getVariantTitle(product: CatalogueProduct, variantId: string): string;
+    trackKey(product: CatalogueProduct): unknown;
+    formatPrice(product: CatalogueProduct): string;
+    formatVariantPrice(variant: CatalogueProductVariant): string;
+    private formatCurrency;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfProductCatalogueComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfProductCatalogueComponent, "ef-product-catalogue", never, { "products": { "alias": "products"; "required": false; "isSignal": true; }; "categoryGroups": { "alias": "categoryGroups"; "required": false; "isSignal": true; }; "initialSelectedItems": { "alias": "initialSelectedItems"; "required": false; "isSignal": true; }; "defaultFilters": { "alias": "defaultFilters"; "required": false; "isSignal": true; }; "trackByField": { "alias": "trackByField"; "required": false; "isSignal": true; }; "currencyCode": { "alias": "currencyCode"; "required": false; "isSignal": true; }; "localeCode": { "alias": "localeCode"; "required": false; "isSignal": true; }; }, { "productsValidated": "productsValidated"; }, ["productThumbnailTpl"], never, true, never>;
+}
+
+declare class EfDialogComponent {
+    /** Direct header text (not translated) */
+    header?: string;
+    /** Translation key — takes priority over header */
+    headerKey?: string;
+    visible: boolean;
+    modal: boolean;
+    closable: boolean;
+    draggable: boolean;
+    resizable: boolean;
+    style?: {
+        [key: string]: string;
+    };
+    styleClass?: string;
+    position: 'center' | 'top' | 'bottom' | 'left' | 'right' | 'topleft' | 'topright' | 'bottomleft' | 'bottomright';
+    appendTo?: string;
+    /**
+     * Render a standard cancel + save action footer. Caller wires (saveAction)
+     * and (cancelAction). When false (default), the footer falls back to the
+     * `[dialogFooter]` projection slot for fully custom footers.
+     */
+    defaultActions: boolean;
+    saveLabelKey: string;
+    cancelLabelKey: string;
+    saveLabel?: string;
+    cancelLabel?: string;
+    saveIcon: string;
+    saveDisabled: boolean;
+    saveStyleClass: string;
+    cancelStyleClass: string;
+    visibleChange: EventEmitter<boolean>;
+    showEvent: EventEmitter<void>;
+    hideEvent: EventEmitter<void>;
+    saveAction: EventEmitter<void>;
+    cancelAction: EventEmitter<void>;
+    defaultFooterTpl?: TemplateRef<void>;
+    handleVisibleChange(value: boolean): void;
+    handleShow(): void;
+    handleHide(): void;
+    /**
+     * Default cancel handler — emits and also closes the dialog. Callers can
+     * override behavior via (cancelAction) (close still happens).
+     */
+    onDefaultCancel(): void;
+    onDefaultSave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfDialogComponent, "ef-dialog", never, { "header": { "alias": "header"; "required": false; }; "headerKey": { "alias": "headerKey"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "modal": { "alias": "modal"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "position": { "alias": "position"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "defaultActions": { "alias": "defaultActions"; "required": false; }; "saveLabelKey": { "alias": "saveLabelKey"; "required": false; }; "cancelLabelKey": { "alias": "cancelLabelKey"; "required": false; }; "saveLabel": { "alias": "saveLabel"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; "saveIcon": { "alias": "saveIcon"; "required": false; }; "saveDisabled": { "alias": "saveDisabled"; "required": false; }; "saveStyleClass": { "alias": "saveStyleClass"; "required": false; }; "cancelStyleClass": { "alias": "cancelStyleClass"; "required": false; }; }, { "visibleChange": "visibleChange"; "showEvent": "showEvent"; "hideEvent": "hideEvent"; "saveAction": "saveAction"; "cancelAction": "cancelAction"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_visible: unknown;
+    static ngAcceptInputType_modal: unknown;
+    static ngAcceptInputType_closable: unknown;
+    static ngAcceptInputType_draggable: unknown;
+    static ngAcceptInputType_resizable: unknown;
+    static ngAcceptInputType_defaultActions: unknown;
+    static ngAcceptInputType_saveDisabled: unknown;
+}
+
+declare class EfFieldsetComponent {
+    /** Direct legend text (not translated) */
+    legend?: string;
+    /** Translation key — takes priority over legend */
+    legendKey?: string;
+    toggleable: boolean;
+    collapsed: boolean;
+    styleClass?: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfFieldsetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfFieldsetComponent, "ef-fieldset", never, { "legend": { "alias": "legend"; "required": false; }; "legendKey": { "alias": "legendKey"; "required": false; }; "toggleable": { "alias": "toggleable"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_toggleable: unknown;
+    static ngAcceptInputType_collapsed: unknown;
+}
+
+declare class EfButtonComponent {
+    /** Direct label text (not translated) */
+    label?: string;
+    /** Translation key — takes priority over label */
+    labelKey?: string;
+    icon?: string;
+    severity: 'primary' | 'secondary' | 'success' | 'info' | 'warn' | 'danger' | 'help' | 'contrast';
+    size: 'small' | 'large';
+    disabled: boolean;
+    rounded: boolean;
+    outlined: boolean;
+    raised: boolean;
+    text: boolean;
+    loading: boolean;
+    styleClass?: string;
+    type: 'button' | 'submit';
+    badge?: string;
+    badgeSeverity?: 'success' | 'info' | 'warn' | 'danger' | 'help' | 'primary' | 'secondary' | 'contrast';
+    /** Direct tooltip text (not translated) */
+    tooltip?: string;
+    /** Translation key for tooltip — takes priority over tooltip */
+    tooltipKey?: string;
+    tooltipPosition: 'top' | 'bottom' | 'left' | 'right';
+    clickEvent: EventEmitter<Event>;
+    handleClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfButtonComponent, "ef-button", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "severity": { "alias": "severity"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "outlined": { "alias": "outlined"; "required": false; }; "raised": { "alias": "raised"; "required": false; }; "text": { "alias": "text"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "type": { "alias": "type"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "badgeSeverity": { "alias": "badgeSeverity"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "tooltipKey": { "alias": "tooltipKey"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, { "clickEvent": "clickEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_rounded: unknown;
+    static ngAcceptInputType_outlined: unknown;
+    static ngAcceptInputType_raised: unknown;
+    static ngAcceptInputType_text: unknown;
+    static ngAcceptInputType_loading: unknown;
+}
+
+declare class EfLabelComponent {
+    /** Direct label text (not translated) */
+    label?: string;
+    /** Translation key — takes priority over label */
+    labelKey?: string;
+    /** The for attribute linking to an input id */
+    for?: string;
+    /** CSS classes for the label element */
+    styleClass: string;
+    /** Show required indicator */
+    required: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfLabelComponent, "ef-label", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "for": { "alias": "for"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+}
+
+/**
+ * Available Tailwind color names for badges
+ */
+type EfBadgeColor = 'emerald' | 'green' | 'lime' | 'orange' | 'amber' | 'yellow' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose' | 'slate' | 'gray' | 'zinc' | 'neutral' | 'stone' | 'red';
+/**
+ * Badge size variants
+ */
+type EfBadgeSize = 'sm' | 'md' | 'lg';
+/**
+ * Badge style variants
+ */
+type EfBadgeVariant = 'filled' | 'outline' | 'dot' | 'pill';
+/**
+ * Badge configuration interface
+ */
+interface EfBadgeConfig {
+    /**
+     * Text label to display (optional for 'dot' variant)
+     */
+    label?: string;
+    /**
+     * Badge color (Tailwind color name)
+     * @default 'blue'
+     */
+    color?: EfBadgeColor;
+    /**
+     * Badge size
+     * @default 'md'
+     */
+    size?: EfBadgeSize;
+    /**
+     * Badge style variant
+     * @default 'filled'
+     */
+    variant?: EfBadgeVariant;
+    /**
+     * Custom CSS classes to apply
+     */
+    styleClass?: string;
+    /**
+     * Icon class (e.g., PrimeIcons) to display before label
+     */
+    icon?: string;
+    /**
+     * Whether to show the dot indicator
+     * @default true for 'dot' variant, false otherwise
+     */
+    showDot?: boolean;
+}
+/**
+ * Default badge configuration
+ */
+declare const EF_BADGE_DEFAULTS: Required<Omit<EfBadgeConfig, 'label' | 'icon'>>;
+/**
+ * Maps Tailwind colors to their background classes
+ */
+declare const EF_BADGE_BG_COLORS: Record<EfBadgeColor, string>;
+/**
+ * Maps Tailwind colors to their text classes
+ */
+declare const EF_BADGE_TEXT_COLORS: Record<EfBadgeColor, string>;
+/**
+ * Maps Tailwind colors to their border classes
+ */
+declare const EF_BADGE_BORDER_COLORS: Record<EfBadgeColor, string>;
+/**
+ * Maps Tailwind colors to their light background classes (for filled variant)
+ */
+declare const EF_BADGE_BG_LIGHT_COLORS: Record<EfBadgeColor, string>;
+
+/**
+ * ef-badge - Reusable status badge component
+ *
+ * Features:
+ * - Multiple color variants (Tailwind colors)
+ * - Multiple size options (sm, md, lg)
+ * - Multiple style variants (filled, outline, dot, pill)
+ * - Icon support
+ * - Fully customizable with styleClass
+ *
+ * @example
+ * ```html
+ * <!-- Simple filled badge -->
+ * <ef-badge label="Active" color="green" />
+ *
+ * <!-- Dot variant -->
+ * <ef-badge label="En attente" color="yellow" variant="dot" />
+ *
+ * <!-- With icon -->
+ * <ef-badge label="Error" color="red" icon="pi pi-exclamation-circle" />
+ *
+ * <!-- Outline variant -->
+ * <ef-badge label="Info" color="blue" variant="outline" />
+ *
+ * <!-- Pill variant -->
+ * <ef-badge label="New" color="purple" variant="pill" />
+ * ```
+ */
+declare class EfBadgeComponent {
+    /**
+     * Badge label text
+     */
+    label: _angular_core.InputSignal<string>;
+    /**
+     * Badge color (Tailwind color name)
+     */
+    color: _angular_core.InputSignal<EfBadgeColor>;
+    /**
+     * Badge size
+     */
+    size: _angular_core.InputSignal<EfBadgeSize>;
+    /**
+     * Badge style variant
+     */
+    variant: _angular_core.InputSignal<EfBadgeVariant>;
+    /**
+     * Custom CSS classes
+     */
+    styleClass: _angular_core.InputSignal<string>;
+    /**
+     * Icon class (e.g., PrimeIcons)
+     */
+    icon: _angular_core.InputSignal<string>;
+    /**
+     * Whether to show the dot indicator
+     */
+    showDot: _angular_core.InputSignal<boolean>;
+    /**
+     * Computed badge configuration with defaults
+     */
+    config: _angular_core.Signal<Required<EfBadgeConfig>>;
+    /**
+     * Computed CSS classes for the badge
+     */
+    badgeClasses: _angular_core.Signal<string>;
+    /**
+     * Computed CSS classes for the dot indicator
+     */
+    dotClasses: _angular_core.Signal<string>;
+    /**
+     * Computed CSS classes for the icon
+     */
+    iconClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfBadgeComponent, "ef-badge", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showDot": { "alias": "showDot"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EfToolbarComponent {
+    context: ScreenContext;
+    state: string;
+    disabled: boolean;
+    back: EventEmitter<any>;
+    save: EventEmitter<any>;
+    delete: EventEmitter<any>;
+    duplicate: EventEmitter<any>;
+    print: EventEmitter<any>;
+    triggerCustoAction: EventEmitter<any>;
+    add: EventEmitter<any>;
+    search: EventEmitter<any>;
+    clear: EventEmitter<any>;
+    searchText: string;
+    backButton: boolean;
+    deleteButton: boolean;
+    duplicateButton: boolean;
+    saveButton: boolean;
+    exportButton: boolean;
+    printButton: boolean;
+    addButton: boolean;
+    clearButton: boolean;
+    searchButton: boolean;
+    showFreeSearchInput: boolean;
+    private router;
+    get isSearchState(): boolean;
+    get isDetailState(): boolean;
+    get hasReadPermission(): boolean;
+    get hasWritePermission(): boolean;
+    get hasEditPermission(): boolean;
+    get hasDeletePermission(): boolean;
+    get hasDuplicatePermission(): boolean;
+    get hasExportPermission(): boolean;
+    get isDuplicateMode(): boolean;
+    backAction(): void;
+    deleteAction(): void;
+    saveAction(): void;
+    duplicateAction(): void;
+    printAction(): void;
+    exportAction(): void;
+    addAction(): void;
+    searchAction(): void;
+    clearAction(): void;
+    navigateBack(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfToolbarComponent, "ef-toolbar", never, { "context": { "alias": "context"; "required": false; }; "state": { "alias": "state"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "backButton": { "alias": "backButton"; "required": false; }; "deleteButton": { "alias": "deleteButton"; "required": false; }; "duplicateButton": { "alias": "duplicateButton"; "required": false; }; "saveButton": { "alias": "saveButton"; "required": false; }; "exportButton": { "alias": "exportButton"; "required": false; }; "printButton": { "alias": "printButton"; "required": false; }; "addButton": { "alias": "addButton"; "required": false; }; "clearButton": { "alias": "clearButton"; "required": false; }; "searchButton": { "alias": "searchButton"; "required": false; }; "showFreeSearchInput": { "alias": "showFreeSearchInput"; "required": false; }; }, { "back": "back"; "save": "save"; "delete": "delete"; "duplicate": "duplicate"; "print": "print"; "triggerCustoAction": "triggerCustoAction"; "add": "add"; "search": "search"; "clear": "clear"; }, never, ["[toolbarStart]", "[toolbarEnd]"], true, never>;
+}
+
+declare class EfBlockUiComponent {
+    isLoading: boolean;
+    contentPanel: any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfBlockUiComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfBlockUiComponent, "ef-block-ui", never, { "isLoading": { "alias": "isLoading"; "required": false; }; "contentPanel": { "alias": "contentPanel"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class EfBlockableDivComponent implements BlockableUI {
+    style: {
+        [key: string]: string;
+    };
+    cssClass: string;
+    private readonly el;
+    getBlockableElement(): HTMLElement;
+    get componentStyle(): {
+        [key: string]: string;
+    };
+    get componentClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfBlockableDivComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfBlockableDivComponent, "ef-blockable-div", never, { "style": { "alias": "style"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class EfInputTextComponent implements ControlValueAccessor {
+    label?: string;
+    labelKey?: string;
+    inputId?: string;
+    name?: string;
+    placeholder?: string;
+    placeholderKey?: string;
+    size: 'small' | 'large';
+    type: string;
+    maxlength?: number;
+    readonly: boolean;
+    required: boolean;
+    fluid: boolean;
+    inline: boolean;
+    autocomplete?: string;
+    get isInline(): boolean;
+    valueChangeEvent: EventEmitter<string>;
+    value: string;
+    disabled: boolean;
+    private onChange;
+    private onTouched;
+    readonly ngControl: NgControl;
+    private readonly translateService;
+    constructor();
+    get effectivePlaceholder(): string;
+    get effectiveId(): string;
+    get showRequired(): boolean;
+    get serverErrors(): string[] | null;
+    get isInvalid(): boolean;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInput(value: string): void;
+    handleBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfInputTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfInputTextComponent, "ef-input-text", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "fluid": { "alias": "fluid"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; }, { "valueChangeEvent": "valueChangeEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_readonly: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_fluid: unknown;
+    static ngAcceptInputType_inline: unknown;
+}
+
+declare class EfSelectComponent implements ControlValueAccessor, OnInit, OnChanges {
+    label?: string;
+    labelKey?: string;
+    inputId?: string;
+    name?: string;
+    options: any[];
+    optionLabel: string;
+    optionValue?: string;
+    placeholder: string;
+    placeholderKey?: string;
+    size: 'small' | 'large';
+    required: boolean;
+    fluid: boolean;
+    inline: boolean;
+    filter: boolean;
+    showClear: boolean;
+    disabled: boolean;
+    appendTo?: string;
+    /** Filter options by matching key-value pairs */
+    filterByKeys?: {
+        [key: string]: any;
+    };
+    get isInline(): boolean;
+    itemTemplate: TemplateRef<any> | null;
+    selectedItemTemplate: TemplateRef<any> | null;
+    selectionChangeEvent: EventEmitter<any>;
+    value: any;
+    filteredOptions: any[];
+    private onChange;
+    private onTouched;
+    /** Resolved lazily in ngOnInit to avoid circular DI with NG_VALUE_ACCESSOR */
+    ngControl: NgControl | null;
+    private readonly injector;
+    private readonly translateService;
+    ngOnInit(): void;
+    get effectivePlaceholder(): string;
+    get effectiveId(): string;
+    get showRequired(): boolean;
+    get serverErrors(): string[] | null;
+    get isInvalid(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleSelectionChange(event: {
+        originalEvent?: Event;
+        value: any;
+    }): void;
+    handleClear(): void;
+    private applyFilters;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfSelectComponent, "ef-select", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionLabel": { "alias": "optionLabel"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "size": { "alias": "size"; "required": false; }; "required": { "alias": "required"; "required": false; }; "fluid": { "alias": "fluid"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "filterByKeys": { "alias": "filterByKeys"; "required": false; }; }, { "selectionChangeEvent": "selectionChangeEvent"; }, ["itemTemplate", "selectedItemTemplate"], never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_fluid: unknown;
+    static ngAcceptInputType_inline: unknown;
+    static ngAcceptInputType_filter: unknown;
+    static ngAcceptInputType_showClear: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class EfCheckboxComponent implements ControlValueAccessor {
+    /** Direct label text (not translated) */
+    label?: string;
+    /** Translation key — takes priority over label */
+    labelKey?: string;
+    inputId?: string;
+    name?: string;
+    value?: any;
+    binary: boolean;
+    required: boolean;
+    disabled: boolean;
+    checked: any;
+    private onChange;
+    private onTouched;
+    readonly ngControl: NgControl;
+    constructor();
+    get effectiveId(): string;
+    get effectiveLabel(): string | undefined;
+    get showRequired(): boolean;
+    get serverErrors(): string[] | null;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleChange(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfCheckboxComponent, "ef-checkbox", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "binary": { "alias": "binary"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_binary: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+declare class EfDatepickerComponent implements ControlValueAccessor {
+    label?: string;
+    labelKey?: string;
+    inputId?: string;
+    name?: string;
+    placeholder?: string;
+    placeholderKey?: string;
+    size: 'small' | 'large';
+    required: boolean;
+    fluid: boolean;
+    inline: boolean;
+    disabled: boolean;
+    showIcon: boolean;
+    iconDisplay: 'input' | 'button';
+    selectionMode: 'single' | 'multiple' | 'range';
+    dateFormat?: string;
+    appendTo?: string;
+    showTime: boolean;
+    showButtonBar: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    get isInline(): boolean;
+    dateSelectEvent: EventEmitter<any>;
+    value: any;
+    private onChange;
+    private onTouched;
+    readonly ngControl: NgControl;
+    private readonly translateService;
+    constructor();
+    get effectivePlaceholder(): string;
+    get effectiveId(): string;
+    get showRequired(): boolean;
+    get serverErrors(): string[] | null;
+    get isInvalid(): boolean;
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleChange(value: any): void;
+    handleBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfDatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfDatepickerComponent, "ef-datepicker", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "size": { "alias": "size"; "required": false; }; "required": { "alias": "required"; "required": false; }; "fluid": { "alias": "fluid"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "iconDisplay": { "alias": "iconDisplay"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "showButtonBar": { "alias": "showButtonBar"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "dateSelectEvent": "dateSelectEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_fluid: unknown;
+    static ngAcceptInputType_inline: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_showIcon: unknown;
+    static ngAcceptInputType_showTime: unknown;
+    static ngAcceptInputType_showButtonBar: unknown;
+}
+
+declare class EfInputNumberComponent implements ControlValueAccessor {
+    inputNumber?: InputNumber;
+    label?: string;
+    labelKey?: string;
+    required: boolean;
+    value?: Nullable<number>;
+    invalid: boolean;
+    disabled?: boolean;
+    readonly: boolean;
+    format: boolean;
+    showButtons: boolean;
+    buttonLayout: 'stacked' | 'horizontal' | 'vertical';
+    incrementButtonClass?: string;
+    decrementButtonClass?: string;
+    incrementButtonIcon?: string;
+    decrementButtonIcon?: string;
+    prefix?: string;
+    suffix?: string;
+    currency?: string;
+    currencyDisplay?: string;
+    locale?: string;
+    localeMatcher?: 'lookup' | 'best fit';
+    mode: 'decimal' | 'currency';
+    useGrouping: boolean;
+    minFractionDigits?: number;
+    maxFractionDigits?: number;
+    min?: number;
+    max?: number;
+    step: number;
+    allowEmpty: boolean;
+    inputId?: string;
+    name?: string;
+    placeholder?: string;
+    placeholderKey?: string;
+    inputSize?: number;
+    size?: 'small' | 'large';
+    maxlength?: number;
+    minlength?: number;
+    pattern?: string;
+    tabindex?: number;
+    title?: string;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+    ariaRequired?: boolean;
+    inputStyle?: any;
+    inputStyleClass?: string;
+    style?: any;
+    styleClass?: string;
+    showClear: boolean;
+    variant?: 'filled' | 'outlined';
+    autofocus?: boolean;
+    autocomplete?: string;
+    fluid?: boolean;
+    inline: boolean;
+    get isInline(): boolean;
+    pt?: any;
+    ptOptions?: any;
+    dt?: any;
+    unstyled?: boolean;
+    inputEvent: EventEmitter<InputNumberInputEvent>;
+    focusEvent: EventEmitter<Event>;
+    blurEvent: EventEmitter<Event>;
+    keyDownEvent: EventEmitter<KeyboardEvent>;
+    clearEvent: EventEmitter<void>;
+    private onChange;
+    private onTouched;
+    readonly ngControl: NgControl;
+    private readonly translateService;
+    constructor();
+    get effectivePlaceholder(): string;
+    get effectiveId(): string;
+    get showRequired(): boolean;
+    get serverErrors(): string[] | null;
+    get isInvalid(): boolean;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInput(event: InputNumberInputEvent): void;
+    handleFocus(event: Event): void;
+    handleBlur(event: Event): void;
+    handleKeyDown(event: KeyboardEvent): void;
+    handleClear(): void;
+    focus(): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfInputNumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfInputNumberComponent, "ef-inputnumber", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "format": { "alias": "format"; "required": false; }; "showButtons": { "alias": "showButtons"; "required": false; }; "buttonLayout": { "alias": "buttonLayout"; "required": false; }; "incrementButtonClass": { "alias": "incrementButtonClass"; "required": false; }; "decrementButtonClass": { "alias": "decrementButtonClass"; "required": false; }; "incrementButtonIcon": { "alias": "incrementButtonIcon"; "required": false; }; "decrementButtonIcon": { "alias": "decrementButtonIcon"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "currency": { "alias": "currency"; "required": false; }; "currencyDisplay": { "alias": "currencyDisplay"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "localeMatcher": { "alias": "localeMatcher"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "useGrouping": { "alias": "useGrouping"; "required": false; }; "minFractionDigits": { "alias": "minFractionDigits"; "required": false; }; "maxFractionDigits": { "alias": "maxFractionDigits"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "inputSize": { "alias": "inputSize"; "required": false; }; "size": { "alias": "size"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "title": { "alias": "title"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; }; "ariaRequired": { "alias": "ariaRequired"; "required": false; }; "inputStyle": { "alias": "inputStyle"; "required": false; }; "inputStyleClass": { "alias": "inputStyleClass"; "required": false; }; "style": { "alias": "style"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "fluid": { "alias": "fluid"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "pt": { "alias": "pt"; "required": false; }; "ptOptions": { "alias": "ptOptions"; "required": false; }; "dt": { "alias": "dt"; "required": false; }; "unstyled": { "alias": "unstyled"; "required": false; }; }, { "inputEvent": "inputEvent"; "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; "keyDownEvent": "keyDownEvent"; "clearEvent": "clearEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_inline: unknown;
+}
+
+declare class EfPasswordComponent implements ControlValueAccessor {
+    label?: string;
+    labelKey?: string;
+    inputId?: string;
+    name?: string;
+    placeholder?: string;
+    placeholderKey?: string;
+    size: 'small' | 'large';
+    required: boolean;
+    fluid: boolean;
+    inline: boolean;
+    toggleMask: boolean;
+    feedback: boolean;
+    autocomplete?: string;
+    get isInline(): boolean;
+    valueChangeEvent: EventEmitter<string>;
+    value: string;
+    disabled: boolean;
+    private onChange;
+    private onTouched;
+    readonly ngControl: NgControl;
+    private readonly translateService;
+    constructor();
+    get effectivePlaceholder(): string;
+    get effectiveId(): string;
+    get showRequired(): boolean;
+    get serverErrors(): string[] | null;
+    get isInvalid(): boolean;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleChange(value: string): void;
+    handleBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfPasswordComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfPasswordComponent, "ef-password", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "size": { "alias": "size"; "required": false; }; "required": { "alias": "required"; "required": false; }; "fluid": { "alias": "fluid"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "toggleMask": { "alias": "toggleMask"; "required": false; }; "feedback": { "alias": "feedback"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; }, { "valueChangeEvent": "valueChangeEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_fluid: unknown;
+    static ngAcceptInputType_inline: unknown;
+    static ngAcceptInputType_toggleMask: unknown;
+    static ngAcceptInputType_feedback: unknown;
+}
+
+declare class EfMultiSelectComponent implements ControlValueAccessor, OnChanges {
+    changeEvent: EventEmitter<string[]>;
+    label?: string;
+    labelKey?: string;
+    id: string;
+    name: string;
+    optionLabel: string;
+    optionValue: string;
+    options: any;
+    filteredOptions: any;
+    maxSelectedLabels: number;
+    disabled: boolean;
+    display: 'comma' | 'chip';
+    size: 'large' | 'small';
+    selectionLimit: any;
+    filters: any;
+    placeholder: string;
+    placeholderKey?: string;
+    showClear: boolean;
+    required: boolean;
+    inline: boolean;
+    get isInline(): boolean;
+    get isRequired(): boolean;
+    selectedValues: any[];
+    private propagateChange;
+    private propagateTouched;
+    readonly ngControl: NgControl;
+    private readonly translateService;
+    constructor();
+    get effectivePlaceholder(): string;
+    get showRequired(): boolean;
+    get serverErrors(): string[] | null;
+    writeValue(value: string[]): void;
+    registerOnChange(fn: (value: any[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInternalModelChange(val: any[]): void;
+    handleClear(): void;
+    ngOnChanges(): void;
+    private applyFilters;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfMultiSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfMultiSelectComponent, "ef-multi-select", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "optionLabel": { "alias": "optionLabel"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "options": { "alias": "options"; "required": false; }; "filteredOptions": { "alias": "filteredOptions"; "required": false; }; "maxSelectedLabels": { "alias": "maxSelectedLabels"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "display": { "alias": "display"; "required": false; }; "size": { "alias": "size"; "required": false; }; "selectionLimit": { "alias": "selectionLimit"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "required": { "alias": "required"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, { "changeEvent": "changeEvent"; }, never, never, true, never>;
+    static ngAcceptInputType_showClear: unknown;
+    static ngAcceptInputType_inline: unknown;
+}
+
+declare class EfSelectButtonComponent implements ControlValueAccessor {
+    /** Direct label text above the selectbutton (not translated) */
+    label?: string;
+    /** Translation key for label — takes priority over label */
+    labelKey?: string;
+    options: any[];
+    optionLabel: string;
+    optionValue: string;
+    multiple: boolean;
+    allowEmpty: boolean;
+    disabled: boolean;
+    size: 'small' | 'large';
+    styleClass?: string;
+    itemTemplate?: TemplateRef<any>;
+    value: any;
+    private onChange;
+    private onTouched;
+    readonly ngControl: NgControl;
+    constructor();
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleChange(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfSelectButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfSelectButtonComponent, "ef-selectbutton", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionLabel": { "alias": "optionLabel"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; }, {}, ["itemTemplate"], never, true, never>;
+    static ngAcceptInputType_multiple: unknown;
+    static ngAcceptInputType_allowEmpty: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * EfQuantityStepper is a specialized component for quantity selection with increment/decrement buttons.
+ * Perfect for shopping carts, POS systems, and order forms where users need to adjust quantities.
+ *
+ * Features:
+ * - Increment/decrement buttons with customizable styling
+ * - Min/max value constraints
+ * - Configurable step value
+ * - Fully integrated with Angular Forms (ngModel, FormControl)
+ * - Rounded button design optimized for touch interfaces
+ *
+ * @group Components
+ */
+declare class EfQuantityStepperComponent implements ControlValueAccessor {
+    /**
+     * Current quantity value
+     */
+    value: Nullable<number>;
+    /**
+     * Minimum allowed value
+     */
+    min: number;
+    /**
+     * Maximum allowed value
+     */
+    max: number;
+    /**
+     * Step increment/decrement value
+     */
+    step: number;
+    /**
+     * Minimum fraction digits to display (forwarded to ef-inputnumber).
+     */
+    minFractionDigits?: number;
+    /**
+     * Maximum fraction digits to display (forwarded to ef-inputnumber).
+     */
+    maxFractionDigits?: number;
+    /**
+     * Locale used for number formatting (forwarded to ef-inputnumber).
+     */
+    locale?: string;
+    /**
+     * When present, it specifies that the component should be disabled
+     */
+    disabled: boolean;
+    /**
+     * Callback to invoke when the value changes
+     */
+    valueChange: EventEmitter<number>;
+    /**
+     * Pass Through configuration for custom styling
+     */
+    ptConfig: {
+        root: {
+            class: string;
+        };
+        pcInputText: {
+            root: {
+                class: string;
+            };
+        };
+        decrementButton: {
+            class: string;
+        };
+        incrementButton: {
+            class: string;
+        };
+        decrementButtonIcon: {
+            innerHTML: string;
+        };
+        incrementButtonIcon: {
+            innerHTML: string;
+        };
+    };
+    private onChange;
+    private onTouched;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleValueChange(value: number | null): void;
+    handleBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfQuantityStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfQuantityStepperComponent, "ef-quantity-stepper", never, { "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "minFractionDigits": { "alias": "minFractionDigits"; "required": false; }; "maxFractionDigits": { "alias": "maxFractionDigits"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Column alignment options for ef-datatable
+ */
+type EfDatatableColumnAlign = 'start' | 'center' | 'end';
+/**
+ * Column data types for automatic formatting
+ */
+type EfDatatableColumnType = 'text' | 'number' | 'money' | 'date' | 'datetime' | 'boolean' | 'reference';
+/**
+ * Column definition interface for ef-datatable
+ */
+interface EfDatatableColumn {
+    /** Property name in data object */
+    field: string;
+    /** Column header text */
+    header: string;
+    /** Data type for automatic formatting (default: 'text') */
+    type?: EfDatatableColumnType;
+    /** Text alignment (default: 'start' except money/number = 'end') */
+    align?: EfDatatableColumnAlign;
+    /** Enable sorting for this column (default: true) */
+    sortable?: boolean;
+    /** Enable resizing for this column (default: true) */
+    resizable?: boolean;
+    /** CSS width (e.g., '100px', 'w-[200px]') */
+    width?: string;
+    /** Custom Tailwind or CSS classes */
+    styleClass?: string;
+    /** Date format string for DatePipe (default: 'shortDate') */
+    dateFormat?: string;
+    /** Currency code for money type (default: 'EUR') */
+    currencyCode?: string;
+    /** Currency display format (default: 'symbol') */
+    currencyDisplay?: 'symbol' | 'code' | 'name';
+    /** Locale for number/date/currency formatting (default: 'fr-FR') */
+    locale?: string;
+    /** Minimum fraction digits for numbers (default: 2) */
+    minFractionDigits?: number;
+    /** Maximum fraction digits for numbers (default: 2) */
+    maxFractionDigits?: number;
+    /** Key for context.ref.get() to lookup reference data */
+    referenceKey?: string;
+    /** Field to match in reference data (default: 'code') */
+    referenceValueField?: string;
+    /** Field to display from reference data (default: 'name') */
+    referenceLabelField?: string;
+    /** Custom cell template (receives rowData and column) */
+    template?: TemplateRef<unknown>;
+    /** Custom header template (receives column) */
+    headerTemplate?: TemplateRef<unknown>;
+}
+/**
+ * Action column configuration for edit/delete/duplicate buttons
+ */
+interface EfDatatableActions {
+    /** Show action column (default: true if config provided) */
+    show?: boolean;
+    /** Action column width (default: 'w-20') */
+    width?: string;
+    /** Show edit button (default: true) */
+    showEdit?: boolean;
+    /** Show delete button (default: true) */
+    showDelete?: boolean;
+    /** Show duplicate button (default: false) */
+    showDuplicate?: boolean;
+    /** Position of action column (default: 'end') */
+    position?: 'start' | 'end';
+}
+/**
+ * Main table configuration options
+ */
+interface EfDatatableConfig {
+    /** Enable lazy loading (default: true) */
+    lazy?: boolean;
+    /** Unique identifier field name (default: 'id') */
+    dataKey?: string;
+    /** Enable pagination (default: true) */
+    paginator?: boolean;
+    /** Rows per page (default: 10) */
+    rows?: number;
+    /** Page size options (default: [5, 10, 25, 50]) */
+    rowsPerPageOptions?: number[];
+    /** Enable scrolling (default: true) */
+    scrollable?: boolean;
+    /** Scroll viewport height (default: '300px') */
+    scrollHeight?: string;
+    /** Enable column resizing (default: true) */
+    resizableColumns?: boolean;
+    /** Column resize behavior (default: 'expand') */
+    columnResizeMode?: 'fit' | 'expand';
+    /** State storage location (default: 'local') */
+    stateStorage?: 'local' | 'session';
+    /** State storage key (auto-generated if not provided) */
+    stateKey?: string;
+    /** Table size (default: 'small') */
+    size?: 'small' | 'large';
+    /** Custom CSS classes (default: 'text-sm') */
+    styleClass?: string;
+    /** Inline table styles */
+    tableStyle?: Record<string, string>;
+    /** Message when no data (default: 'Aucune entree trouvee') */
+    emptyMessage?: string;
+    /** Pagination report template */
+    currentPageReportTemplate?: string;
+}
+/**
+ * Default table configuration values
+ */
+declare const EF_DATATABLE_DEFAULTS: Required<EfDatatableConfig>;
+/**
+ * Default column configuration values
+ */
+declare const EF_DATATABLE_COLUMN_DEFAULTS: Partial<EfDatatableColumn>;
+/**
+ * Default action column configuration
+ */
+declare const EF_DATATABLE_ACTIONS_DEFAULTS: Required<EfDatatableActions>;
+/**
+ * Helper function to determine column alignment based on type
+ * @param column - The column configuration
+ * @returns The computed alignment
+ */
+declare function getColumnAlignment(column: EfDatatableColumn): EfDatatableColumnAlign;
+/**
+ * Helper function to merge column configuration with defaults
+ * @param column - The column configuration
+ * @returns Column with defaults applied
+ */
+declare function mergeColumnDefaults(column: EfDatatableColumn): EfDatatableColumn;
+
+/**
+ * SearchEntity interface for datatable consumption.
+ * Matches the shape expected from the consuming application's SearchEntity.
+ */
+interface DatatableSearchEntity {
+    items?: Record<string, unknown>[];
+    totalCount?: number;
+    pagination?: {
+        pageNumber: number;
+        pageSize: number;
+    };
+    sort?: Array<{
+        field: string;
+        sortDirection: string;
+    }>;
+}
+/**
+ * ef-datatable - Reusable table component wrapping PrimeNG Table
+ *
+ * Features:
+ * - Typed columns with automatic formatting (text, number, money, date, datetime, boolean, reference)
+ * - Built-in action column with edit/delete/duplicate buttons
+ * - Support for custom templates
+ * - PassThrough (PT) support for deep customization
+ * - Lazy loading, pagination, sorting, column resizing
+ * - State persistence (localStorage/sessionStorage)
+ * - Reference data integration via ScreenContext
+ *
+ * @example
+ * ```html
+ * <ef-datatable
+ *   [columns]="tableColumns"
+ *   [searchEntity]="searchEntity"
+ *   [context]="context"
+ *   [screenStateKey]="screenStateKey"
+ *   [actions]="{ showDuplicate: true }"
+ *   (editRow)="edit($event)"
+ *   (deleteRow)="delete($event)"
+ *   (lazyLoad)="search($event)">
+ * </ef-datatable>
+ * ```
+ */
+declare class EfDatatableComponent implements OnInit {
+    /**
+     * Reference to the underlying PrimeNG Table component
+     */
+    pTable?: Table;
+    selectedItem: Record<string, unknown> | undefined;
+    /**
+     * Column definitions with type, alignment, and formatting options
+     */
+    columns: _angular_core.InputSignal<EfDatatableColumn[]>;
+    /**
+     * Table configuration (pagination, scrolling, sizing, etc.)
+     */
+    config: _angular_core.InputSignal<EfDatatableConfig>;
+    /**
+     * Action column configuration (edit/delete/duplicate buttons)
+     */
+    actions: _angular_core.InputSignal<EfDatatableActions>;
+    /**
+     * SearchEntity containing items, pagination, etc.
+     */
+    searchEntity: _angular_core.InputSignal<DatatableSearchEntity>;
+    /**
+     * ScreenContext for reference data access
+     */
+    context: _angular_core.InputSignal<ScreenContext>;
+    /**
+     * PassThrough options for deep DOM customization
+     */
+    pt: _angular_core.InputSignal<Record<string, unknown>>;
+    /**
+     * Screen state key for state persistence (auto-generates stateKey if not provided in config)
+     */
+    screenStateKey: _angular_core.InputSignal<string>;
+    /**
+     * Emitted when edit button is clicked (emits row ID)
+     */
+    editRow: _angular_core.OutputEmitterRef<unknown>;
+    /**
+     * Emitted when delete button is clicked (emits row ID)
+     */
+    deleteRow: _angular_core.OutputEmitterRef<unknown>;
+    /**
+     * Emitted when duplicate button is clicked (emits row ID)
+     */
+    duplicateRow: _angular_core.OutputEmitterRef<unknown>;
+    /**
+     * Emitted on lazy load events (pagination, sorting, filtering)
+     */
+    lazyLoad: _angular_core.OutputEmitterRef<TableLazyLoadEvent>;
+    /**
+     * Emitted when a row is selected
+     */
+    rowSelect: _angular_core.OutputEmitterRef<unknown>;
+    /**
+     * Loading indicator
+     */
+    loading: _angular_core.WritableSignal<boolean>;
+    /**
+     * Merged configuration with defaults
+     */
+    mergedConfig: Required<EfDatatableConfig>;
+    /**
+     * Merged action configuration with defaults
+     */
+    mergedActions: Required<EfDatatableActions>;
+    /**
+     * Processed columns with defaults and computed alignment
+     * Reactive to changes in columns input
+     */
+    processedColumns: _angular_core.Signal<{
+        align: EfDatatableColumnAlign;
+        field: string;
+        header: string;
+        type?: _elasticias_ui.EfDatatableColumnType;
+        sortable?: boolean;
+        resizable?: boolean;
+        width?: string;
+        styleClass?: string;
+        dateFormat?: string;
+        currencyCode?: string;
+        currencyDisplay?: "symbol" | "code" | "name";
+        locale?: string;
+        minFractionDigits?: number;
+        maxFractionDigits?: number;
+        referenceKey?: string;
+        referenceValueField?: string;
+        referenceLabelField?: string;
+        template?: _angular_core.TemplateRef<unknown>;
+        headerTemplate?: _angular_core.TemplateRef<unknown>;
+    }[]>;
+    /**
+     * Computed sort field from searchEntity for restoring table state
+     */
+    sortField: _angular_core.Signal<string>;
+    /**
+     * Computed sort order from searchEntity for restoring table state
+     * 1 = ascending, -1 = descending
+     */
+    sortOrder: _angular_core.Signal<1 | -1>;
+    private readonly locale;
+    private readonly datePipe;
+    private readonly decimalPipe;
+    private readonly currencyPipe;
+    ngOnInit(): void;
+    /**
+     * Handle lazy loading events from PrimeNG Table
+     * Prevents duplicate events caused by reactive sortField/sortOrder binding updates
+     * @param event - Table lazy load event containing pagination, sorting, filtering info
+     */
+    handleLazyLoad(event: TableLazyLoadEvent): void;
+    /**
+     * Detects if the event is a reactive binding echo (matches current searchEntity state)
+     */
+    private isBindingEcho;
+    /**
+     * Handle edit button click
+     * @param rowData - The row data object
+     */
+    handleEdit(rowData: Record<string, unknown>): void;
+    handleDelete(rowData: Record<string, unknown>): void;
+    handleDuplicate(rowData: Record<string, unknown>): void;
+    /**
+     * Format cell value based on column type
+     * @param rowData - The row data object
+     * @param column - The column configuration
+     * @returns Formatted string value
+     */
+    formatCellValue(rowData: Record<string, unknown>, column: EfDatatableColumn): string | null;
+    /**
+     * Resolve reference data value to display label
+     * @param rowData - The row data object
+     * @param column - The column configuration
+     * @returns Display label from reference data
+     */
+    private resolveReferenceValue;
+    /**
+     * Get CSS class for text alignment
+     * @param align - Alignment option
+     * @returns CSS class name
+     */
+    getAlignmentClass(align?: EfDatatableColumnAlign): string;
+    /**
+     * Reset table to first page and clear filters
+     */
+    reset(): void;
+    /**
+     * Export table data as CSV
+     */
+    exportCSV(): void;
+    /**
+     * Get the current filter state
+     */
+    getFilters(): Record<string, unknown> | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfDatatableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfDatatableComponent, "ef-datatable", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "searchEntity": { "alias": "searchEntity"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "pt": { "alias": "pt"; "required": false; "isSignal": true; }; "screenStateKey": { "alias": "screenStateKey"; "required": false; "isSignal": true; }; }, { "editRow": "editRow"; "deleteRow": "deleteRow"; "duplicateRow": "duplicateRow"; "lazyLoad": "lazyLoad"; "rowSelect": "rowSelect"; }, never, never, true, never>;
+}
+
+declare class EfDatatableActionBarComponent {
+    context?: ScreenContext;
+    state?: string;
+    duplicate: EventEmitter<any>;
+    edit: EventEmitter<any>;
+    delete: EventEmitter<any>;
+    duplicateButton: boolean;
+    editButton: boolean;
+    deleteButton: boolean;
+    get hasReadPermission(): boolean;
+    get hasEditPermission(): boolean;
+    get hasDeletePermission(): boolean;
+    duplicateAction(): void;
+    editAction(): void;
+    deleteAction(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfDatatableActionBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfDatatableActionBarComponent, "ef-datatable-actionbar", never, { "context": { "alias": "context"; "required": false; }; "state": { "alias": "state"; "required": false; }; "duplicateButton": { "alias": "duplicateButton"; "required": false; }; "editButton": { "alias": "editButton"; "required": false; }; "deleteButton": { "alias": "deleteButton"; "required": false; }; }, { "duplicate": "duplicate"; "edit": "edit"; "delete": "delete"; }, never, never, true, never>;
+}
+
+/**
+ * Theme configurator panel for switching PrimeNG presets, primary colors,
+ * surface palettes, ripple effect, and RTL direction.
+ *
+ * All labels use translation keys (ngx-translate). Pass keys via inputs.
+ *
+ * Usage:
+ * ```html
+ * <ef-theme-configurator
+ *   primaryLabelKey="configurator.primary_color"
+ *   surfaceLabelKey="configurator.surface"
+ *   presetLabelKey="configurator.preset"
+ *   rippleLabelKey="configurator.ripple"
+ *   rtlLabelKey="configurator.rtl"
+ *   [presetsDisplayNameKeys]="{ Aura: 'configurator.preset_compact', Lara: 'configurator.preset_modern', Material: 'configurator.preset_google', Nora: 'configurator.preset_classic' }"
+ * />
+ * ```
+ */
+declare class EfThemeConfiguratorComponent implements OnInit {
+    primaryLabelKey: string;
+    surfaceLabelKey: string;
+    presetLabelKey: string;
+    rippleLabelKey: string;
+    rtlLabelKey: string;
+    presetsDisplayNameKeys: Record<string, string>;
+    get ripple(): boolean;
+    set ripple(value: boolean);
+    get isRTL(): boolean;
+    config: PrimeNG;
+    configService: EfThemeConfigService;
+    platformId: Object;
+    presetsOptions: string[];
+    onRTLChange(value: boolean): void;
+    ngOnInit(): void;
+    surfaces: {
+        name: string;
+        palette: {
+            0: string;
+            50: string;
+            100: string;
+            200: string;
+            300: string;
+            400: string;
+            500: string;
+            600: string;
+            700: string;
+            800: string;
+            900: string;
+            950: string;
+        };
+    }[];
+    selectedPrimaryColor: _angular_core.Signal<string>;
+    selectedSurfaceColor: _angular_core.Signal<string>;
+    selectedPreset: _angular_core.Signal<string>;
+    primaryColors: _angular_core.Signal<{
+        name: string;
+        palette: Record<string, string>;
+    }[]>;
+    getPresetExt(): Record<string, unknown>;
+    updateColors(event: Event, type: string, color: {
+        name: string;
+        palette: Record<string, string>;
+    }): void;
+    applyTheme(type: string, color: {
+        name: string;
+        palette: Record<string, string>;
+    }): void;
+    onPresetChange(event: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfThemeConfiguratorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfThemeConfiguratorComponent, "ef-theme-configurator", never, { "primaryLabelKey": { "alias": "primaryLabelKey"; "required": false; }; "surfaceLabelKey": { "alias": "surfaceLabelKey"; "required": false; }; "presetLabelKey": { "alias": "presetLabelKey"; "required": false; }; "rippleLabelKey": { "alias": "rippleLabelKey"; "required": false; }; "rtlLabelKey": { "alias": "rtlLabelKey"; "required": false; }; "presetsDisplayNameKeys": { "alias": "presetsDisplayNameKeys"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type RangeKey = '7d' | '30d' | '90d';
+/**
+ * Manager dashboard widget: email engagement KPIs, category breakdown, recent events.
+ * Keep this presentational — host app fetches metrics + supplies `rangeChange` callback.
+ *
+ * @example
+ * <ef-email-metrics-card
+ *   [metrics]="metrics()"
+ *   [recentEvents]="events()"
+ *   [loading]="loading()"
+ *   (rangeChange)="reload($event)"
+ * />
+ */
+declare class EfEmailMetricsCardComponent {
+    metrics: _angular_core.InputSignal<EmailMetrics>;
+    recentEvents: _angular_core.InputSignal<EmailEventRecord[]>;
+    loading: _angular_core.InputSignal<boolean>;
+    title: _angular_core.InputSignal<string>;
+    selectedRange: RangeKey;
+    rangeOptions: {
+        label: string;
+        value: string;
+    }[];
+    hasData: _angular_core.Signal<boolean>;
+    kpis: _angular_core.Signal<({
+        label: string;
+        value: number;
+        tone: "neutral";
+        rate?: undefined;
+    } | {
+        label: string;
+        value: number;
+        rate: boolean;
+        tone: "warn" | "neutral" | "good";
+    })[]>;
+    onRangeChange(value: RangeKey): void;
+    readonly rangeChange: _angular_core.OutputEmitterRef<RangeKey>;
+    kindSeverity(kind: EmailEventKind): 'success' | 'info' | 'warn' | 'danger' | 'secondary';
+    private rateTone;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EfEmailMetricsCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EfEmailMetricsCardComponent, "ef-email-metrics-card", never, { "metrics": { "alias": "metrics"; "required": false; "isSignal": true; }; "recentEvents": { "alias": "recentEvents"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, { "rangeChange": "rangeChange"; }, never, never, true, never>;
+}
+
+export { EF_BADGE_BG_COLORS, EF_BADGE_BG_LIGHT_COLORS, EF_BADGE_BORDER_COLORS, EF_BADGE_DEFAULTS, EF_BADGE_TEXT_COLORS, EF_DATATABLE_ACTIONS_DEFAULTS, EF_DATATABLE_COLUMN_DEFAULTS, EF_DATATABLE_DEFAULTS, EfBadgeComponent, EfBlockUiComponent, EfBlockableDivComponent, EfButtonComponent, EfCheckboxComponent, EfCurrencyPipe, EfDatatableActionBarComponent, EfDatatableComponent, EfDatepickerComponent, EfDialogComponent, EfEmailMetricsCardComponent, EfFieldsetComponent, EfInputNumberComponent, EfInputTextComponent, EfLabelComponent, EfMultiSelectComponent, EfOrderBuilderComponent, EfOrderSummaryComponent, EfPasswordComponent, EfPriceDisplayComponent, EfProductCatalogueComponent, EfProductCatalogueFilterComponent, EfQuantitySelectorComponent, EfQuantityStepperComponent, EfSelectButtonComponent, EfSelectComponent, EfThemeConfiguratorComponent, EfToolbarComponent, OrderEntityHelper, OrderLineItemHelper, TruncatePipe, getColumnAlignment, mergeColumnDefaults };
+export type { CatalogueProduct, CatalogueProductVariant, CategoryAssignment, CategoryGroup, CategoryItem, DatatableSearchEntity, DocumentConfig, EfBadgeColor, EfBadgeConfig, EfBadgeSize, EfBadgeVariant, EfDatatableActions, EfDatatableColumn, EfDatatableColumnAlign, EfDatatableColumnType, EfDatatableConfig, OrderChangeInfo, OrderEntity, OrderLineItem, OrderProductsSummary, OrderSummaryItem, ProductCountGroup, ProductCountGroupLabel, ProductWithCountGroup, SelectedFilter, ValidationResult };