@arsedizioni/ars-utils 22.0.23 → 22.0.30

package/types/arsedizioni-ars-utils-core.d.ts

@@ -178,1077 +178,1077 @@ interface INode {
     level?: number;
     bag?: unknown;
 }
-declare enum DateFormat {
-    Short = 1,// dd/mm/yyyy
-    Long = 2,// d mmmm yyyy
-    LongWithShortMonth = 3,// d mmm yyyy
-    LongWithWeekDay = 4,// wwww, d mmmm yyyy
-    LongWithShortWeekDay = 5,// www, d mmmm yyyy
-    MonthAndYear = 6,// mmm yyyy
-    LongMonthAndYear = 7,// mmmm yyyy
-    WeekDay = 8,// www d
-    LongWeekDay = 9,// wwww d
-    DayAndMonth = 10,// d mmmm
-    ShortUS = 11,// mm/dd/yyyy
-    ShortISO8601 = 12
+interface DoneResult<T> {
+    isNew?: boolean;
+    data?: T;
+}
+interface ApiResponse {
+    success: boolean;
+    message: string;
+}
+interface ApiResult<T> extends ApiResponse {
+    value: T;
+}
+interface Folder extends INode {
+    teamId?: string;
+    parentId?: string;
+    position?: number;
+    isPrivate?: boolean;
+    itemsCount?: number;
+    subItemsCount?: number;
+}
+interface FolderTree extends Folder {
+    children?: Folder[];
+    path?: string;
+}
+interface File<T> {
+    ownerId?: T;
+    id?: number;
+    fileName: string;
+    fileData: unknown;
+}
+interface Validated {
+    isValid(): boolean;
+}
+declare class FileInfo implements Validated {
+    file: any;
+    valid: boolean;
+    isValid(): boolean;
+}
+interface ErrorInfo {
+    invalidateSession?: boolean;
+    title?: string;
+    message?: string;
+    errorStatus?: number;
+    service?: string;
+}
+interface NameValueItem<T> {
+    name: string;
+    value: T;
+    shortName?: string;
+    parentName?: string;
+    parentValue?: T;
+    header?: string;
+    bag?: any;
+    bagInfo?: string;
+    disabled?: boolean;
+    selected?: boolean;
+}
+interface Checkable {
+    checked?: boolean;
+    bag: unknown;
+    getId(): unknown;
+}
+declare class ValueModel<T> {
+    value: T;
+}
+declare class IDModel<T = number> {
+    id: T;
+}
+declare class GroupModel<T = number> {
+    ids: T[];
+}
+declare class DeleteModel<T = number> extends GroupModel<T> {
+    mode?: number;
+    parentId?: T;
+}
+interface DeleteResultModel<T> {
+    items?: T[];
+    deleted: number;
+    total: number;
+    log?: string;
+}
+declare class RelationModel<T = number> {
+    id: T;
+    parentId: T;
+}
+declare class UpdateRelationsModel<T = number> {
+    id: T;
+    relatedIds: T[];
+}
+declare class QueryModel {
+    any?: string;
+    sortBy?: string;
+    sortDescending?: boolean;
+    first?: number;
+    count?: number;
+}
+interface QueryResultModel<T> {
+    interval?: string;
+    items: T[];
+    total: number;
+}
+interface UpdateModel<T = number> {
+    parentId?: T;
+    ids: T[];
+}
+interface UpdateResultModel<T> {
+    items?: T[];
+    updated: number;
+    total: number;
+    log?: string;
+}
+interface AddModel<T> extends UpdateModel<T> {
+}
+interface AddResultModel<T> {
+    items?: T[];
+    added: number;
+    total: number;
+    log?: string;
+}
+declare class ImportModel {
+    origin: string;
+    dataFile: FileInfo;
+    jumpFirstLine?: boolean;
+    map?: unknown;
+}
+interface EnableDisableModel {
+    value: boolean;
+}
+interface SendToModel {
+    sendToRecipients?: string;
+    sendToSubject?: string;
+    sendToText?: string;
+}
+interface SearchBag {
+    name: string;
+}
+interface Searchable {
+    searchBag: SearchBag;
+}
+interface SearchFilterMetadata {
+    total: number;
+    count: number;
+}
+declare class DateInterval {
+    from?: Date;
+    to?: Date;
+    get fromAsDate(): Date | undefined;
+    get toAsDate(): Date | undefined;
+    constructor(from?: Date, to?: Date);
+    clear(): void;
+}
+interface LoginResult<T> extends ApiResult<boolean> {
+    context: T;
+    oauth?: number;
+    requiresMfa?: boolean;
 }
+
 /**
- * Key selector with IDE autocomplete and compile-time checking.
- *
- * Suggests the string keys of `T` in the editor and flags obvious typos when
- * `T` is known, while STILL accepting any plain string (the `string & {}`
- * branch), so existing callers that pass dynamic or untyped keys keep
- * compiling unchanged.
+ * Directive that listens to `keyup` events on a date input and debounces changes
+ * into a {@link DateInterval} model, converting shorthand strings (e.g. "d/m") to dates.
+ * Apply `[dateIntervalChange]="interval"` to the host `<input>` element.
  */
-type KeyOf<T> = Extract<keyof T, string> | (string & {});
-interface PasswordStrength {
-    score: number;
-    label?: string;
-    color?: string;
-    suggestions?: string[];
-    isValid: boolean;
-}
-declare class SystemUtils {
-    /** Shared collator for locale-aware, case-insensitive string comparison. */
-    private static readonly collator;
+declare class DateIntervalChangeDirective {
+    /** The date interval model to update when the input value changes. */
+    readonly dateIntervalChange: i0.InputSignal<DateInterval>;
+    /** When `true`, the directive updates the interval's end date; otherwise the start date. */
+    readonly end: i0.InputSignal<boolean>;
+    private readonly subject;
+    private readonly destroyRef;
+    constructor();
     /**
-     * Array find by key
-     * @param array     : the array to scan
-     * @param key       : key name
-     * @param value     : the value to search for
-     * @returns         : the property value or null
+     * Handles `keydown` events on the host element.
+     * The space key must be blocked HERE: by the time `keyup` fires the character
+     * has already been inserted into the input, so `preventDefault` on `keyup`
+     * cannot stop it.
+     * @param e - The keyboard event emitted by the host input.
      */
-    static arrayFindByKey<T>(array: T[] | undefined, key: KeyOf<T>, value: unknown): T | undefined;
+    onKeydown(e: KeyboardEvent): void;
     /**
-     * Array find index by key
-     * @param array   : the array to scan
-     * @param key     : the key name
-     * @param value   : the value to search for
-     * @returns       : the array index or -1 if not found
+     * Handles `keyup` events on the host element and forwards them to the debounce pipeline.
+     * @param e - The keyboard event emitted by the host input.
      */
-    static arrayFindIndexByKey<T>(array: T[] | undefined, key: KeyOf<T>, value: unknown): number;
+    onKeyup(e: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateIntervalChangeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateIntervalChangeDirective, "[dateIntervalChange]", never, { "dateIntervalChange": { "alias": "dateIntervalChange"; "required": false; "isSignal": true; }; "end": { "alias": "end"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that copies a string payload to the clipboard when the host element is clicked.
+ * Bind `[copyClipboard]="text"` to provide the content to copy and listen to `(copied)` for confirmation.
+ */
+declare class CopyClipboardDirective {
+    /** The text to copy to the clipboard. Bound via the `copyClipboard` attribute. */
+    readonly payload: i0.InputSignal<string>;
+    /** Emits the copied text after a successful copy operation. */
+    readonly copied: i0.OutputEmitterRef<string>;
     /**
-     * Get a value from and array made of name|value items
-     * @param array   : the array to scan
-     * @param value   : the value to search for
-     * @returns       : the property value or null if not found
+     * Handles click events on the host element and copies the payload to the clipboard.
+     * Emits `copied` with the copied text on success.
+     * @param e - The mouse click event.
      */
-    static arrayGetValue<T>(array: T[] | undefined, value: unknown): unknown;
+    onClick(e: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyClipboardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopyClipboardDirective, "[copyClipboard]", never, { "payload": { "alias": "copyClipboard"; "required": false; "isSignal": true; }; }, { "copied": "copied"; }, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a semicolon-separated list of email addresses.
+ * Apply `emails` to a text input containing one or more addresses separated by `;`.
+ */
+declare class EmailsValidatorDirective implements Validator {
     /**
-     * Convert items to nodes into a tree structure
-     * @param items   : list of nodes
-     * @param parent  : parent node
-     * @returns       : an array of INode objects
+     * Validates each address in a semicolon-separated email list.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
      */
-    static arrayToNodes(items: INode[], parent?: INode): INode[];
-    /**
-     * Comparator factory for sorting arrays of objects by a given property key.
-     * Pass the element type for compile-time key checking:
-     * `items.sort(SystemUtils.arraySortCompare<Employee>('lastName'))`.
-     * @param key   - Name of the property to sort by (autocompleted from `T` when provided).
-     * @param order - Sort direction: `'asc'` (default) or `'desc'`.
-     * @returns A comparator function that returns a negative, zero, or positive number.
-     */
-    static arraySortCompare<T extends object = Record<string, unknown>>(key: KeyOf<T>, order?: 'asc' | 'desc' | (string & {})): (a: T, b: T) => number;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmailsValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EmailsValidatorDirective, "[emails]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates that the host control's value equals the value of another control.
+ * Bind `[equals]="otherControl"`.
+ *
+ * The host control is re-validated whenever the OTHER control's value changes:
+ * without this, typing a new password AFTER the confirmation field was filled
+ * left the form incorrectly valid (the classic password/confirm bug).
+ */
+declare class EqualsValidatorDirective implements Validator {
+    /** The control whose value must match the host control's value. */
+    readonly equals: i0.InputSignal<AbstractControl<any, any, any>>;
+    /** Callback registered by Angular forms to re-run validation on the host control. */
+    private onValidatorChange?;
+    /** Subscription to the other control's valueChanges. */
+    private subscription?;
+    constructor();
     /**
-     * Format weight
-     * @param gr    : grams
-     * @returns     : the formatted string
+     * Registers the callback Angular invokes to re-run this validator.
+     * @param fn - The revalidation callback provided by the forms API.
      */
-    static formatWeight(gr: number): string;
+    registerOnValidatorChange(fn: () => void): void;
     /**
-     * Format file size
-     * @param bytes : number of bytes
-     * @returns     : the formatted string
+     * Validates that the host control value equals the bound control's value.
+     * Returns `null` (valid) when no control is bound.
+     * @param control - The form control to validate.
+     * @returns `null` when valid, `{ equals: ... }` otherwise.
      */
-    static formatFileSize(bytes: number): string;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EqualsValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EqualsValidatorDirective, "[equals]", never, { "equals": { "alias": "equals"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a file size against configurable minimum and maximum bounds.
+ * Bind `[fileSize]` together with `[size]="fileSizeInMb"`, `[maxSizeMb]`, and `[minSizeMb]`.
+ */
+declare class FileSizeValidatorDirective implements Validator {
+    /** Maximum allowed file size in megabytes. Defaults to 5. */
+    readonly maxSizeMb: i0.InputSignal<number>;
+    /** Minimum required file size in megabytes. Defaults to 0. */
+    readonly minSizeMb: i0.InputSignal<number>;
+    /** The actual file size in megabytes to validate against the bounds. */
+    readonly size: i0.InputSignal<number>;
     /**
-     * Compare two strings (case-insensitive, locale-aware, accent-insensitive).
-     * @param a   : string a
-     * @param b   : string b
-     * @returns   : 0 if equals, 1 if bigger, -1 if lower
+     * Validates that the bound file size falls within the configured min/max range.
+     * Returns `null` when no control value is present.
+     * @param control - The form control to validate.
      */
-    static compareString(a?: string, b?: string): number;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizeValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileSizeValidatorDirective, "[fileSize]", never, { "maxSizeMb": { "alias": "maxSizeMb"; "required": false; "isSignal": true; }; "minSizeMb": { "alias": "minSizeMb"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a control value as a GUID / UUID string.
+ * Apply `guid` to a text input that expects a valid UUID.
+ */
+declare class GuidValidatorDirective implements Validator {
     /**
-     * Capitalize a string
-     * @param s   : the string to capitalize
-     * @returns   : the capitalized string
+     * Validates that the control value is a well-formed GUID / UUID.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
      */
-    static capitalize(s?: string): string | undefined;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GuidValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GuidValidatorDirective, "[guid]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates that a control value does not exceed a maximum word count.
+ * Bind `[maxTerms]="10"` to allow at most 10 whitespace-separated terms.
+ */
+declare class MaxTermsValidatorDirective implements Validator {
+    /** The maximum number of whitespace-separated terms allowed. */
+    readonly maxTerms: i0.InputSignal<number>;
     /**
-     * Truncate a string at the last word boundary before `max`.
-     * @param s     : the string to truncate
-     * @param max   : the max number of chars
-     * @returns     : the truncated string
+     * Validates that the control value contains no more than the configured number of terms.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
      */
-    static truncate(s?: string, max?: number): string | undefined;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaxTermsValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MaxTermsValidatorDirective, "[maxTerms]", never, { "maxTerms": { "alias": "maxTerms"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates that a string control value is not blank (whitespace-only).
+ * Apply `notEmpty` to a text input where non-blank content is required.
+ */
+declare class NotEmptyValidatorDirective implements Validator {
     /**
-     * Join a list of strings
-     * @param items     : the list of strings
-     * @param sep       : the separator string
-     * @param max       : the maximum resulting string
-     * @returns         : the joined string
+     * Validates that the control value is a non-blank string.
+     * Returns `null` when the control is empty or not a string.
+     * @param control - The form control to validate.
      */
-    static join(items?: string[], sep?: string, max?: number): string | undefined;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotEmptyValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotEmptyValidatorDirective, "[notEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates that the host control's value is different from another control's value.
+ * Bind `[notEqual]="otherControl"`.
+ *
+ * The host control is re-validated whenever the OTHER control's value changes,
+ * so editing either field keeps both error states consistent.
+ */
+declare class NotEqualValidatorDirective implements Validator {
+    /** The control whose value must differ from the host control's value. */
+    readonly notEqual: i0.InputSignal<AbstractControl<any, any, any>>;
+    /** Callback registered by Angular forms to re-run validation on the host control. */
+    private onValidatorChange?;
+    /** Subscription to the other control's valueChanges. */
+    private subscription?;
+    constructor();
     /**
-     * Normalize a string by converting it to lowercase and removing extra spaces, with special handling for acronyms and camelCase.
-     * @param s  : the string to normalize
-     * @returns  : The normalized string, or `undefined` if the input is falsy.
+     * Registers the callback Angular invokes to re-run this validator.
+     * @param fn - The revalidation callback provided by the forms API.
      */
-    static normalizeDisplay(s?: string): string | undefined;
+    registerOnValidatorChange(fn: () => void): void;
     /**
-     * Wraps bare URLs in the given string with `<a>` anchor tags.
-     * @param s - The plain-text or HTML string to process.
-     * @returns The string with URLs replaced by clickable links, or `''` when `s` is falsy.
+     * Validates that the host control value is not equal to the bound control's value.
+     * Also clears the `notequal` error on the other control when the host becomes valid.
+     * Returns `null` (valid) when no control is bound.
+     * @param control - The form control to validate.
+     * @returns `null` when valid, `{ notequal: true }` otherwise.
      */
-    static replaceAsHtml(s?: string): string;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotEqualValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotEqualValidatorDirective, "[notEqual]", never, { "notEqual": { "alias": "notEqual"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates that a control value is not a future date.
+ * Apply `notFuture` to a text input that expects a date on or before today.
+ */
+declare class NotFutureValidatorDirective implements Validator {
     /**
-     * Convert markdown to html
-     * @param markdown : the markdown data
-     * @param escapeHtml : true to escape HTML. Default is false
-     * @returns the html
+     * Validates that the control value represents a date that is not in the future.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
      */
-    static markdownToHtml(markdown: string, escapeHtml?: boolean): string;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotFutureValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotFutureValidatorDirective, "[notFuture]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a control value as a sufficiently strong password.
+ * Apply `password` to a password input.
+ */
+declare class PasswordValidatorDirective implements Validator {
     /**
-     * Compare two names
-     * @param a   : name a
-     * @param b   : name b
-     * @returns   : true if a equals b
+     * Validates that the control value meets the minimum password-strength requirements.
+     * @param control - The form control to validate.
      */
-    static compareNames(a?: string, b?: string): boolean;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PasswordValidatorDirective, "[password]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that removes focus from the host element after it is clicked,
+ * preventing the browser from keeping a visible focus ring post-interaction.
+ * Apply `removeFocus` to any focusable element (e.g. a button).
+ */
+declare class RemoveFocusDirective {
+    private readonly elementRef;
     /**
-     * Obfuscate a text with a key-driven code point rotation.
-     *
-     * @deprecated This is OBFUSCATION, not cryptography: it hides values from
-     * casual inspection but offers no real security. Use {@link encrypt} /
-     * {@link decrypt} (AES-GCM via Web Crypto) for anything sensitive.
-     *
-     * The rotation operates on Unicode code points and skips the surrogate
-     * range, so the output is always a well-formed string: emoji and other
-     * astral characters round-trip correctly (the previous code-unit based
-     * version could emit lone surrogates and corrupt them).
-     *
-     * BREAKING CHANGE: values encoded with the previous code-unit algorithm
-     * cannot be decoded by this implementation.
-     *
-     * @param text    : the text to encode or decode
-     * @param key     : the key
-     * @param reverse : true to decode, false to encode
-     * @returns       : the obfuscated (or restored) text, or undefined when text/key are empty
+     * Handles click events on the host element and blurs it on the next event-loop tick
+     * so that the click action completes before focus is removed.
      */
-    static cipher(text: string, key: string, reverse?: boolean): string | undefined;
-    /** Payload format version, first byte of the binary envelope. */
-    private static readonly CIPHER_VERSION;
-    /** PBKDF2 salt length in bytes. */
-    private static readonly CIPHER_SALT_LENGTH;
-    /** AES-GCM IV length in bytes (96 bit, the recommended size for GCM). */
-    private static readonly CIPHER_IV_LENGTH;
-    /** PBKDF2-HMAC-SHA-256 iterations (OWASP recommendation). */
-    private static readonly CIPHER_ITERATIONS;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RemoveFocusDirective, "[removeFocus]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a control value as a parseable SQL-compatible date string.
+ * Apply `sqlDate` to a text input that expects a date after year 1750.
+ */
+declare class SqlDateValidatorDirective implements Validator {
     /**
-     * Derives an AES-GCM 256-bit key from a password using PBKDF2-HMAC-SHA-256.
-     * @param password : the user password / passphrase
-     * @param salt     : the random salt bound to this payload
-     * @returns        : a non-extractable AES-GCM CryptoKey
+     * Validates that the control value can be parsed as a date after 1750.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
      */
-    private static deriveKey;
-    /**
-     * Encodes bytes as URL-safe Base64 (no '+', '/' or trailing '=').
-     * @param bytes : the bytes to encode
-     * @returns     : the base64url string
-     */
-    private static toBase64Url;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SqlDateValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SqlDateValidatorDirective, "[sqlDate]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a time string against optional allowed time slot ranges.
+ * Bind `[time]` and optionally `[slots]="'08:00-12:00|14:00-18:00'"` (pipe-separated ranges).
+ */
+declare class TimeValidatorDirective implements Validator {
+    /** Optional pipe-separated list of allowed time ranges, e.g. `"08:00-12:00|14:00-18:00"`. */
+    readonly slots: i0.InputSignal<string>;
     /**
-     * Decodes a URL-safe Base64 string back to bytes.
-     * @param value : the base64url string
-     * @returns     : the decoded bytes
+     * Parses a `"HH:MM"` time string into a comparable integer (e.g. `"09:30"` -> `930`).
+     * Returns `-1` when the string is not a valid time.
+     * @param value - The time string to parse.
      */
-    private static fromBase64Url;
+    private getTime;
     /**
-     * Encrypts a text with a password using AES-GCM (256 bit) and a key derived
-     * via PBKDF2-HMAC-SHA-256 with a random per-message salt.
-     *
-     * The result is a self-contained, URL-safe Base64 payload:
-     * `version (1 byte) | salt (16 bytes) | iv (12 bytes) | ciphertext+tag`.
-     * GCM is authenticated: any tampering makes {@link decrypt} fail.
-     *
-     * Requires a secure context (HTTPS or localhost) for `crypto.subtle`.
-     *
-     * @param text     : the plain text to encrypt
-     * @param password : the password / passphrase
-     * @returns        : the base64url payload, or undefined when text/password are
-     *                   empty or the Web Crypto API is unavailable
+     * Validates that the control value is a valid time string and, when slots are configured,
+     * that it falls within at least one of the allowed ranges.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
      */
-    static encrypt(text: string, password: string): Promise<string | undefined>;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimeValidatorDirective, "[time]", never, { "slots": { "alias": "slots"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a control value as a well-formed URL.
+ * Apply `url` to a text input that expects a URL.
+ */
+declare class UrlValidatorDirective implements Validator {
     /**
-     * Decrypts a payload produced by {@link encrypt}.
-     * Returns undefined when the password is wrong, the payload was tampered
-     * with, the format is unknown, or the Web Crypto API is unavailable.
-     *
-     * @param payload  : the base64url payload returned by {@link encrypt}
-     * @param password : the password / passphrase used to encrypt
-     * @returns        : the original plain text, or undefined on any failure
+     * Validates that the control value is a well-formed URL.
+     * Returns `null` (valid) when the control is empty.
+     * @param control - The form control to validate.
      */
-    static decrypt(payload: string, password: string): Promise<string | undefined>;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UrlValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UrlValidatorDirective, "[url]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that validates a control using the host object's `isValid()` method
+ * or a boolean expression passed via `[validIf]`.
+ */
+declare class ValidIfDirective implements Validator {
+    /** When `true`, the control is considered valid regardless of the bound value. */
+    readonly validIf: i0.InputSignal<boolean>;
     /**
-     * Clone an object (deep copy).
-     * Uses native structuredClone: handles Date, Map, Set, typed arrays and circular references.
-     * @param obj : the object to clone
-     * @returns   : a new object
+     * Validates the control value against a boolean flag or the value's own `isValid()` method.
+     * @param control - The form control to validate.
      */
-    static clone<T>(obj: T): T;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidIfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ValidIfDirective, "[validIf]", never, { "validIf": { "alias": "validIf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that delegates validation to an externally provided validator function.
+ * Bind `[validator]="myFn"` where `myFn` is `(c: AbstractControl) => ValidationErrors | null`.
+ */
+declare class ValidatorDirective implements Validator {
+    /** The custom validator function to apply. */
+    readonly validator: i0.InputSignal<(control: AbstractControl) => ValidationErrors | null>;
     /**
-     * Creates a deep clone of an object.
-     * @param obj  - The source object to clone.
-     * @param dest - Optional pre-allocated destination object to merge the clone into.
-     * @returns A deep copy of `obj`.
+     * Invokes the provided validator function against the given control.
+     * Returns `null` (valid) when no function is bound.
+     * @param control - The form control to validate.
      */
-    static deepClone<T extends object>(obj: T, dest?: T): T;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ValidatorDirective, "[validator]", never, { "validator": { "alias": "validator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Pipe that converts plain-text newlines (`\r\n`, `\r`, `\n`) to HTML `<br>` tags
+ * and marks the result as trusted HTML so Angular does not escape it.
+ *
+ * Usage: `{{ text | formatHtml }}`
+ */
+declare class FormatHtmlPipe implements PipeTransform {
+    private readonly sanitizer;
     /**
-     * Returns `true` when `value` is a syntactically valid UUID string.
-     * @param value - The string to validate.
+     * Transforms a plain-text string into sanitized HTML by replacing newline characters
+     * with `<br>` tags.
+     * @param value - The input string to transform. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
      */
-    static parseUUID(value?: string): boolean;
+    transform(value?: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatHtmlPipe, "formatHtml", true>;
+}
+
+/**
+ * Pipe that converts a Markdown string to sanitized HTML using `SystemUtils.markdownToHtml`.
+ *
+ * Usage: `{{ text | formatMarkdown }}`
+ */
+declare class FormatMarkdownPipe implements PipeTransform {
+    private readonly sanitizer;
     /**
-     * Returns `true` when `value` is a valid, non-empty (non-zero) UUID.
-     * @param value - The string to validate.
+     * Transforms a Markdown string into sanitized HTML.
+     * @param value - The Markdown input to convert. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
      */
-    static parseUUIDNotEmpty(value?: string): boolean;
+    transform(value?: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatMarkdownPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatMarkdownPipe, "formatMarkdown", true>;
+}
+
+/**
+ * General-purpose formatting pipe that converts a raw value to a locale-aware string
+ * based on the specified format type.
+ *
+ * Supported types: `'date'` / `'D'`, `'currency'` / `'C'`, `'number'` / `'N'`,
+ * `'number0'` / `'N0'`, `'percentage'` / `'P'`.
+ *
+ * Usage: `{{ value | format:'currency' }}`
+ */
+declare class FormatPipe implements PipeTransform {
+    /** Shared formatters: building an `Intl.NumberFormat` per call is expensive. */
+    private static readonly currencyFormat;
+    private static readonly numberFormat;
+    private static readonly number0Format;
+    private static readonly percentFormat;
     /**
-     * Return an empty UUID
-     * @returns : the empty UUID
+     * Formats a value according to the specified type and optional pattern.
+     * Returns `undefined` when the value is `null` or `undefined`, or when the type is unrecognised.
+     * @param value   - The raw value to format.
+     * @param type    - The format type identifier (default: `'date'`).
+     * @param pattern - The date pattern used when `type` is `'date'` (default: `'dd/MM/yyyy'`).
+     * @returns A formatted string, or `undefined` when the value cannot be formatted.
      */
-    static emptyUUID(): string;
+    transform(value?: unknown, type?: string, pattern?: string): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormatPipe, "format", true>;
+}
+
+/**
+ * Pipe that applies a global regex replacement on a string and returns the result
+ * as sanitized HTML. When `regexValue` is `'\n'` and no `replaceValue` is given,
+ * newlines are replaced with `<br>` tags.
+ *
+ * Usage: `{{ text | replace:'\n':'' }}`
+ */
+declare class ReplacePipe implements PipeTransform {
+    private readonly sanitizer;
     /**
-     * Create a new UUID
-     * @returns : the string UUID
+     * Replaces all occurrences of `regexValue` in `value` with `replaceValue`.
+     * Returns `undefined` when `value` is empty or `undefined`.
+     * @param value        - The source string to process.
+     * @param regexValue   - The regex pattern string to match (applied with the global flag).
+     * @param replaceValue - The replacement string. Defaults to `'<br>'` when `regexValue` is `'\n'` and this is falsy.
+     * @returns A `SafeHtml` value with all matches replaced, or `undefined` when the input is empty.
      */
-    static generateUUID(): string;
+    transform(value: string | undefined, regexValue: string, replaceValue?: string): SafeHtml | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReplacePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReplacePipe, "replace", true>;
+}
+
+/**
+ * Pipe that marks an HTML string as trusted so Angular does not escape it when
+ * bound via `[innerHTML]`.
+ *
+ * Usage: `<div [innerHTML]="html | safeHtml"></div>`
+ */
+declare class SafeHtmlPipe implements PipeTransform {
+    private readonly sanitizer;
     /**
-     * Reconstruct a standard UUID (with dashes) from a 32-char hex string without dashes.
-     * @param value : 32-character hex string
-     * @returns     : the formatted UUID or the original string if it doesn't match the expected format
+     * Bypasses Angular's HTML sanitization and returns a `SafeHtml` instance.
+     * @param value - The raw HTML string to trust. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be bound to `[innerHTML]` without escaping.
      */
-    static inflateUUID(value: string): string;
-    /** Precompiled validation patterns. */
-    private static readonly emailRegex;
-    private static readonly urlRegex;
+    transform(value?: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+
+/**
+ * Pipe that marks a URL string as a trusted resource URL so Angular does not block it
+ * when bound to attributes such as `[src]` or `[href]` on iframes, objects, or embeds.
+ *
+ * Usage: `<iframe [src]="url | safeUrl"></iframe>`
+ */
+declare class SafeUrlPipe implements PipeTransform {
+    private readonly sanitizer;
     /**
-     * Parse a text and return true if it is a valid email (or empty)
-     * @param value : email
-     * @returns     : true if the email is valid or empty
+     * Bypasses Angular's resource-URL sanitization and returns a `SafeResourceUrl` instance.
+     * @param value - The URL string to trust. Treated as an empty string when `undefined`.
+     * @returns A `SafeResourceUrl` that can be bound to resource URL attributes without blocking.
      */
-    static parseEmail(value?: string): boolean;
+    transform(value?: string): SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeUrlPipe, "safeUrl", true>;
+}
+
+/**
+ * Impure pipe that filters an array using a caller-provided predicate function.
+ * Because the pipe is impure it re-evaluates on every change-detection cycle,
+ * which is necessary when the predicate's captured state changes.
+ *
+ * Usage: `*ngFor="let item of items | callback:myFilter"`
+ */
+declare class SearchCallbackPipe implements PipeTransform {
     /**
-     * Parse a text containing one or more email addresses separated by `;` or `,`
-     * and return true if all of them are valid (or the text is empty).
-     * Empty items caused by double or trailing separators are ignored.
-     * @param value : the email list to parse (e.g. "a@b.it; c@d.it")
-     * @returns     : true if all emails are valid or the value is empty
-     */
-    static parseEmails(value?: string): boolean;
-    /**
-     * Parse a text and return true if it is a valid url (or empty)
-     * @param value : the url to parse
-     * @returns     : true if the url is valid or empty
+     * Filters `items` by applying `callback` to each element.
+     * Returns the original array unchanged when either argument is falsy.
+     * @param items    - The source array to filter. May be `undefined`.
+     * @param callback - A predicate function that returns `true` for items to keep.
+     * @returns A new filtered array, the original array when no callback is provided,
+     *          or `undefined` when `items` is `undefined`.
      */
-    static parseUrl(value?: string): boolean;
+    transform<T>(items: T[] | undefined, callback: ((item: T) => boolean) | undefined): T[] | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchCallbackPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SearchCallbackPipe, "callback", true>;
+}
+
+/**
+ * Pure pipe that filters an array of searchable items against a text query.
+ * Note: being pure, it re-runs only when the array REFERENCE or the query
+ * changes; mutate-in-place updates of the array are not detected.
+ *
+ * Each item is matched either via its `searchBag.name` property (when present)
+ * or by converting the item itself to a lowercase string. The optional `metadata`
+ * argument is updated in-place with the total item count and the filtered count,
+ * making it usable in the template alongside `*ngFor`.
+ *
+ * Usage:
+ * ```html
+ * <div *ngFor="let item of items | search:filterText:meta">...</div>
+ * <div>Showing {{ meta.count }} of {{ meta.total }}</div>
+ * ```
+ */
+declare class SearchFilterPipe implements PipeTransform {
     /**
-     * Get date parts from a string value
-     * @param value   : the string to parse
-     * @returns       : an array of numbers with year, month, day
+     * Filters `items` by performing a case-insensitive substring match against `value`.
+     * When `items` or `value` is falsy the original array is returned unfiltered.
+     * @param items    - The source array to filter. May be `undefined`.
+     * @param value    - The search text to match against each item. May be `undefined`.
+     * @param metadata - Optional object that is updated with `total` and `count` after filtering.
+     * @returns The filtered array, the original array when no filter text is given,
+     *          or `undefined` when `items` is `undefined`.
      */
-    static getDateParts(value?: string): number[] | undefined;
+    transform(items?: any[], value?: string, metadata?: SearchFilterMetadata): any[] | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SearchFilterPipe, "search", true>;
+}
+
+declare enum DateFormat {
+    Short = 1,// dd/mm/yyyy
+    Long = 2,// d mmmm yyyy
+    LongWithShortMonth = 3,// d mmm yyyy
+    LongWithWeekDay = 4,// wwww, d mmmm yyyy
+    LongWithShortWeekDay = 5,// www, d mmmm yyyy
+    MonthAndYear = 6,// mmm yyyy
+    LongMonthAndYear = 7,// mmmm yyyy
+    WeekDay = 8,// www d
+    LongWeekDay = 9,// wwww d
+    DayAndMonth = 10,// d mmmm
+    ShortUS = 11,// mm/dd/yyyy
+    ShortISO8601 = 12
+}
+/**
+ * Key selector with IDE autocomplete and compile-time checking.
+ *
+ * Suggests the string keys of `T` in the editor and flags obvious typos when
+ * `T` is known, while STILL accepting any plain string (the `string & {}`
+ * branch), so existing callers that pass dynamic or untyped keys keep
+ * compiling unchanged.
+ */
+type KeyOf<T> = Extract<keyof T, string> | (string & {});
+interface PasswordStrength {
+    score: number;
+    label?: string;
+    color?: string;
+    suggestions?: string[];
+    isValid: boolean;
+}
+declare class SystemUtils {
+    /** Shared collator for locale-aware, case-insensitive string comparison. */
+    private static readonly collator;
     /**
-     * Checks whether a value is a valid Date instance.
-     * Note: do not use `date.getTime()` as a truthiness test, it is 0 (falsy)
-     * for the Unix epoch (1970-01-01T00:00:00Z) even though the date is valid.
-     * @param d : the value to check
-     * @returns : true when `d` is a Date representing a valid point in time
+     * Array find by key
+     * @param array     : the array to scan
+     * @param key       : key name
+     * @param value     : the value to search for
+     * @returns         : the property value or null
      */
-    static isValidDate(d: unknown): d is Date;
+    static arrayFindByKey<T>(array: T[] | undefined, key: KeyOf<T>, value: unknown): T | undefined;
     /**
-     * Parse a date
-     * @param value   : the value to check
-     * @param locale  : the locale to use
-     * @returns       : a valid Date object or undefined
+     * Array find index by key
+     * @param array   : the array to scan
+     * @param key     : the key name
+     * @param value   : the value to search for
+     * @returns       : the array index or -1 if not found
      */
-    static parseDate(value?: string | Date, locale?: Locale): Date | undefined;
+    static arrayFindIndexByKey<T>(array: T[] | undefined, key: KeyOf<T>, value: unknown): number;
     /**
-     * Format a date
-     * @param value     : the date or string to format
-     * @param fmt       : the DateFormat to use or the string pattern
-     * @param locale    : the locale to use (default is IT)
-     * @returns         : the formatted string
+     * Get a value from and array made of name|value items
+     * @param array   : the array to scan
+     * @param value   : the value to search for
+     * @returns       : the property value or null if not found
      */
-    static formatDate(value?: Date | string, fmt?: DateFormat | string, locale?: Locale): string;
+    static arrayGetValue<T>(array: T[] | undefined, value: unknown): unknown;
     /**
-     * Return an italian local date
-     * @param value  : the date
-     * @returns     : the new date
+     * Convert items to nodes into a tree structure
+     * @param items   : list of nodes
+     * @param parent  : parent node
+     * @returns       : an array of INode objects
      */
-    static toLocalDate(value?: Date | string): Date | undefined;
+    static arrayToNodes(items: INode[], parent?: INode): INode[];
     /**
-     * Update a DateInterval object according to a string
-     * @param value       : string value
-     * @param interval    : DateInterval value to update
-     * @param end         : true if must be updated the first or the end value
-     * @param copy        : copy the same value (works only if not end element)
+     * Comparator factory for sorting arrays of objects by a given property key.
+     * Pass the element type for compile-time key checking:
+     * `items.sort(SystemUtils.arraySortCompare<Employee>('lastName'))`.
+     * @param key   - Name of the property to sort by (autocompleted from `T` when provided).
+     * @param order - Sort direction: `'asc'` (default) or `'desc'`.
+     * @returns A comparator function that returns a negative, zero, or positive number.
      */
-    static changeDateInterval(value: string, interval: DateInterval, end?: boolean, copy?: boolean): void;
-    /** Cache of `Intl.NumberFormat` instances (their construction is expensive). */
-    private static readonly numberFormatCache;
+    static arraySortCompare<T extends object = Record<string, unknown>>(key: KeyOf<T>, order?: 'asc' | 'desc' | (string & {})): (a: T, b: T) => number;
     /**
-     * Returns a cached `Intl.NumberFormat` for the given options, creating it on first use.
-     * @param locale  - BCP 47 locale tag.
-     * @param options - The `Intl.NumberFormat` options.
-     * @returns A shared formatter instance.
+     * Format weight
+     * @param gr    : grams
+     * @returns     : the formatted string
      */
-    private static getNumberFormat;
+    static formatWeight(gr: number): string;
     /**
-     * Formats a number using a cached `Intl.NumberFormat`.
-     * @param value    - The number to format.
-     * @param decimals - Maximum decimal places (default: `2`).
-     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
-     * @returns The formatted number string.
+     * Format file size
+     * @param bytes : number of bytes
+     * @returns     : the formatted string
      */
-    static formatNumber(value: number, decimals?: number, locale?: string): string;
+    static formatFileSize(bytes: number): string;
     /**
-     * Formats a number as a currency string using a cached `Intl.NumberFormat`.
-     * @param value    - The number to format.
-     * @param currency - ISO 4217 currency code (default: `'EUR'`).
-     * @param decimals - Maximum decimal places (default: `2`).
-     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
-     * @returns The formatted currency string.
+     * Compare two strings (case-insensitive, locale-aware, accent-insensitive).
+     * @param a   : string a
+     * @param b   : string b
+     * @returns   : 0 if equals, 1 if bigger, -1 if lower
      */
-    static formatCurrency(value: number, currency?: string, decimals?: number, locale?: string): string;
+    static compareString(a?: string, b?: string): number;
     /**
-     * Percent-encodes a string for safe inclusion in a URL.
-     * @param value - The string to encode.
-     * @returns The encoded string, or `undefined` when `value` is empty.
+     * Capitalize a string
+     * @param s   : the string to capitalize
+     * @returns   : the capitalized string
      */
-    static urlEncode(value: string): string | undefined;
+    static capitalize(s?: string): string | undefined;
     /**
-     * Decodes a percent-encoded URL string, treating `+` as a space.
-     * @param value - The encoded string to decode.
-     * @returns The decoded string, or `undefined` when `value` is empty or absent.
+     * Truncate a string at the last word boundary before `max`.
+     * @param s     : the string to truncate
+     * @param max   : the max number of chars
+     * @returns     : the truncated string
      */
-    static urlDecode(value?: string): string | undefined;
+    static truncate(s?: string, max?: number): string | undefined;
     /**
-     * Reads a query string parameter value from the current page URL.
-     * @param name - The parameter name to look up.
-     * @returns The decoded parameter value, or `undefined` when absent or running server-side.
+     * Join a list of strings
+     * @param items     : the list of strings
+     * @param sep       : the separator string
+     * @param max       : the maximum resulting string
+     * @returns         : the joined string
      */
-    static getQueryStringValueByName(name: string): string | undefined;
+    static join(items?: string[], sep?: string, max?: number): string | undefined;
     /**
-     * Generate a password
-     * @returns : the password string
+     * Normalize a string by converting it to lowercase and removing extra spaces, with special handling for acronyms and camelCase.
+     * @param s  : the string to normalize
+     * @returns  : The normalized string, or `undefined` if the input is falsy.
      */
-    static generatePassword(length?: number): string;
+    static normalizeDisplay(s?: string): string | undefined;
     /**
-     * Calculate password strength
-     * @param password: the password to evaluate
-     * @returns the password strength info
+     * Wraps bare URLs in the given string with `<a>` anchor tags.
+     * @param s - The plain-text or HTML string to process.
+     * @returns The string with URLs replaced by clickable links, or `''` when `s` is falsy.
      */
-    static calculatePasswordStrength(password?: string): PasswordStrength;
+    static replaceAsHtml(s?: string): string;
     /**
-     * Check if current browser supports touch
-     * @returns : true if the display is touchable
+     * Convert markdown to html
+     * @param markdown : the markdown data
+     * @param escapeHtml : true to escape HTML. Default is false
+     * @returns the html
      */
-    static isTouchable(): boolean;
+    static markdownToHtml(markdown: string, escapeHtml?: boolean): string;
     /**
-     * This check will prevent 'window' logic to be executed
-     * while executing the server rendering
-     * @returns : true if using the browser
+     * Compare two names
+     * @param a   : name a
+     * @param b   : name b
+     * @returns   : true if a equals b
      */
-    static isBrowser(): boolean;
+    static compareNames(a?: string, b?: string): boolean;
     /**
-     * Convert folders in a tree of Node object.
-     * @param folders : the subfolders group or null to root
-     * @returns       : a node list
+     * Obfuscate a text with a key-driven code point rotation.
+     *
+     * @deprecated This is OBFUSCATION, not cryptography: it hides values from
+     * casual inspection but offers no real security. Use {@link encrypt} /
+     * {@link decrypt} (AES-GCM via Web Crypto) for anything sensitive.
+     *
+     * The rotation operates on Unicode code points and skips the surrogate
+     * range, so the output is always a well-formed string: emoji and other
+     * astral characters round-trip correctly (the previous code-unit based
+     * version could emit lone surrogates and corrupt them).
+     *
+     * BREAKING CHANGE: values encoded with the previous code-unit algorithm
+     * cannot be decoded by this implementation.
+     *
+     * @param text    : the text to encode or decode
+     * @param key     : the key
+     * @param reverse : true to decode, false to encode
+     * @returns       : the obfuscated (or restored) text, or undefined when text/key are empty
      */
-    static toNodes(folders: INode[]): INode[];
-    /**
-     * Convert folders in a tree of Node object.
-     * @param folders : the children group or null to root
-     * @param parent  : the parent node
-     * @returns       : a node list
-     */
-    private static _toNodes;
+    static cipher(text: string, key: string, reverse?: boolean): string | undefined;
+    /** Payload format version, first byte of the binary envelope. */
+    private static readonly CIPHER_VERSION;
+    /** PBKDF2 salt length in bytes. */
+    private static readonly CIPHER_SALT_LENGTH;
+    /** AES-GCM IV length in bytes (96 bit, the recommended size for GCM). */
+    private static readonly CIPHER_IV_LENGTH;
+    /** PBKDF2-HMAC-SHA-256 iterations (OWASP recommendation). */
+    private static readonly CIPHER_ITERATIONS;
     /**
-     * Returns an array of individual power-of-2 flag values that are set in `value`.
-     * @param value - The bitmask to decompose.
-     * @param max   - Upper-bound exponent: checks flags from `1` up to `1 << max` (default: `30`).
-     * @returns Array of set flag values, or an empty array when `value` is `0`.
+     * Derives an AES-GCM 256-bit key from a password using PBKDF2-HMAC-SHA-256.
+     * @param password : the user password / passphrase
+     * @param salt     : the random salt bound to this payload
+     * @returns        : a non-extractable AES-GCM CryptoKey
      */
-    static getFlags(value: number, max?: number): number[];
-    /** Cache for resolved color luminance results. */
-    private static readonly colorLightCache;
+    private static deriveKey;
     /**
-     * Check if a color is light or dark
-     * @param color : the color
-     * @param minimumLuminance : the lumimance to consider
-     * @returns true if the color is light
+     * Encodes bytes as URL-safe Base64 (no '+', '/' or trailing '=').
+     * @param bytes : the bytes to encode
+     * @returns     : the base64url string
      */
-    static isColorLight(color: string, minimumLuminance?: number): boolean;
-}
-
-interface DoneResult<T> {
-    isNew?: boolean;
-    data?: T;
-}
-interface ApiResponse {
-    success: boolean;
-    message: string;
-}
-interface ApiResult<T> extends ApiResponse {
-    value: T;
-}
-interface Folder extends INode {
-    teamId?: string;
-    parentId?: string;
-    position?: number;
-    isPrivate?: boolean;
-    itemsCount?: number;
-    subItemsCount?: number;
-}
-interface FolderTree extends Folder {
-    children?: Folder[];
-    path?: string;
-}
-interface File<T> {
-    ownerId?: T;
-    id?: number;
-    fileName: string;
-    fileData: unknown;
-}
-interface Validated {
-    isValid(): boolean;
-}
-declare class FileInfo implements Validated {
-    file: any;
-    valid: boolean;
-    isValid(): boolean;
-}
-interface ErrorInfo {
-    invalidateSession?: boolean;
-    title?: string;
-    message?: string;
-    errorStatus?: number;
-    service?: string;
-}
-interface NameValueItem<T> {
-    name: string;
-    value: T;
-    shortName?: string;
-    parentName?: string;
-    parentValue?: T;
-    header?: string;
-    bag?: any;
-    bagInfo?: string;
-    disabled?: boolean;
-    selected?: boolean;
-}
-interface Checkable {
-    checked?: boolean;
-    bag: unknown;
-    getId(): unknown;
-}
-declare class ValueModel<T> {
-    value: T;
-}
-declare class IDModel<T = number> {
-    id: T;
-}
-declare class GroupModel<T = number> {
-    ids: T[];
-}
-declare class DeleteModel<T = number> extends GroupModel<T> {
-    mode?: number;
-    parentId?: T;
-}
-interface DeleteResultModel<T> {
-    items?: T[];
-    deleted: number;
-    total: number;
-    log?: string;
-}
-declare class RelationModel<T = number> {
-    id: T;
-    parentId: T;
-}
-declare class UpdateRelationsModel<T = number> {
-    id: T;
-    relatedIds: T[];
-}
-declare class QueryModel {
-    any?: string;
-    sortBy?: string;
-    sortDescending?: boolean;
-    first?: number;
-    count?: number;
-}
-interface QueryResultModel<T> {
-    interval?: string;
-    items: T[];
-    total: number;
-}
-interface UpdateModel<T = number> {
-    parentId?: T;
-    ids: T[];
-}
-interface UpdateResultModel<T> {
-    items?: T[];
-    updated: number;
-    total: number;
-    log?: string;
-}
-interface AddModel<T> extends UpdateModel<T> {
-}
-interface AddResultModel<T> {
-    items?: T[];
-    added: number;
-    total: number;
-    log?: string;
-}
-declare class ImportModel {
-    origin: string;
-    dataFile: FileInfo;
-    jumpFirstLine?: boolean;
-    map?: unknown;
-}
-interface EnableDisableModel {
-    value: boolean;
-}
-interface SendToModel {
-    sendToRecipients?: string;
-    sendToSubject?: string;
-    sendToText?: string;
-}
-interface SearchBag {
-    name: string;
-}
-interface Searchable {
-    searchBag: SearchBag;
-}
-interface SearchFilterMetadata {
-    total: number;
-    count: number;
-}
-declare class DateInterval {
-    from?: Date;
-    to?: Date;
-    get fromAsDate(): Date | undefined;
-    get toAsDate(): Date | undefined;
-    constructor(from?: Date, to?: Date);
-    clear(): void;
-}
-interface LoginResult<T> extends ApiResult<boolean> {
-    context: T;
-    oauth?: number;
-    requiresMfa?: boolean;
-}
-
-/**
- * Directive that listens to `keyup` events on a date input and debounces changes
- * into a {@link DateInterval} model, converting shorthand strings (e.g. "d/m") to dates.
- * Apply `[dateIntervalChange]="interval"` to the host `<input>` element.
- */
-declare class DateIntervalChangeDirective {
-    /** The date interval model to update when the input value changes. */
-    readonly dateIntervalChange: i0.InputSignal<DateInterval>;
-    /** When `true`, the directive updates the interval's end date; otherwise the start date. */
-    readonly end: i0.InputSignal<boolean>;
-    private readonly subject;
-    private readonly destroyRef;
-    constructor();
+    private static toBase64Url;
     /**
-     * Handles `keydown` events on the host element.
-     * The space key must be blocked HERE: by the time `keyup` fires the character
-     * has already been inserted into the input, so `preventDefault` on `keyup`
-     * cannot stop it.
-     * @param e - The keyboard event emitted by the host input.
+     * Decodes a URL-safe Base64 string back to bytes.
+     * @param value : the base64url string
+     * @returns     : the decoded bytes
      */
-    onKeydown(e: KeyboardEvent): void;
+    private static fromBase64Url;
     /**
-     * Handles `keyup` events on the host element and forwards them to the debounce pipeline.
-     * @param e - The keyboard event emitted by the host input.
+     * Encrypts a text with a password using AES-GCM (256 bit) and a key derived
+     * via PBKDF2-HMAC-SHA-256 with a random per-message salt.
+     *
+     * The result is a self-contained, URL-safe Base64 payload:
+     * `version (1 byte) | salt (16 bytes) | iv (12 bytes) | ciphertext+tag`.
+     * GCM is authenticated: any tampering makes {@link decrypt} fail.
+     *
+     * Requires a secure context (HTTPS or localhost) for `crypto.subtle`.
+     *
+     * @param text     : the plain text to encrypt
+     * @param password : the password / passphrase
+     * @returns        : the base64url payload, or undefined when text/password are
+     *                   empty or the Web Crypto API is unavailable
      */
-    onKeyup(e: KeyboardEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DateIntervalChangeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DateIntervalChangeDirective, "[dateIntervalChange]", never, { "dateIntervalChange": { "alias": "dateIntervalChange"; "required": false; "isSignal": true; }; "end": { "alias": "end"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Directive that copies a string payload to the clipboard when the host element is clicked.
- * Bind `[copyClipboard]="text"` to provide the content to copy and listen to `(copied)` for confirmation.
- */
-declare class CopyClipboardDirective {
-    /** The text to copy to the clipboard. Bound via the `copyClipboard` attribute. */
-    readonly payload: i0.InputSignal<string>;
-    /** Emits the copied text after a successful copy operation. */
-    readonly copied: i0.OutputEmitterRef<string>;
+    static encrypt(text: string, password: string): Promise<string | undefined>;
     /**
-     * Handles click events on the host element and copies the payload to the clipboard.
-     * Emits `copied` with the copied text on success.
-     * @param e - The mouse click event.
+     * Decrypts a payload produced by {@link encrypt}.
+     * Returns undefined when the password is wrong, the payload was tampered
+     * with, the format is unknown, or the Web Crypto API is unavailable.
+     *
+     * @param payload  : the base64url payload returned by {@link encrypt}
+     * @param password : the password / passphrase used to encrypt
+     * @returns        : the original plain text, or undefined on any failure
      */
-    onClick(e: MouseEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CopyClipboardDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CopyClipboardDirective, "[copyClipboard]", never, { "payload": { "alias": "copyClipboard"; "required": false; "isSignal": true; }; }, { "copied": "copied"; }, never, never, true, never>;
-}
-
-/**
- * Directive that validates a semicolon-separated list of email addresses.
- * Apply `emails` to a text input containing one or more addresses separated by `;`.
- */
-declare class EmailsValidatorDirective implements Validator {
+    static decrypt(payload: string, password: string): Promise<string | undefined>;
     /**
-     * Validates each address in a semicolon-separated email list.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
+     * Clone an object (deep copy).
+     * Uses native structuredClone: handles Date, Map, Set, typed arrays and circular references.
+     * @param obj : the object to clone
+     * @returns   : a new object
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EmailsValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<EmailsValidatorDirective, "[emails]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates that the host control's value equals the value of another control.
- * Bind `[equals]="otherControl"`.
- *
- * The host control is re-validated whenever the OTHER control's value changes:
- * without this, typing a new password AFTER the confirmation field was filled
- * left the form incorrectly valid (the classic password/confirm bug).
- */
-declare class EqualsValidatorDirective implements Validator {
-    /** The control whose value must match the host control's value. */
-    readonly equals: i0.InputSignal<AbstractControl<any, any, any>>;
-    /** Callback registered by Angular forms to re-run validation on the host control. */
-    private onValidatorChange?;
-    /** Subscription to the other control's valueChanges. */
-    private subscription?;
-    constructor();
+    static clone<T>(obj: T): T;
+    /**
+     * Creates a deep clone of an object.
+     * @param obj  - The source object to clone.
+     * @param dest - Optional pre-allocated destination object to merge the clone into.
+     * @returns A deep copy of `obj`.
+     */
+    static deepClone<T extends object>(obj: T, dest?: T): T;
     /**
-     * Registers the callback Angular invokes to re-run this validator.
-     * @param fn - The revalidation callback provided by the forms API.
+     * Returns `true` when `value` is a syntactically valid UUID string.
+     * @param value - The string to validate.
      */
-    registerOnValidatorChange(fn: () => void): void;
+    static parseUUID(value?: string): boolean;
     /**
-     * Validates that the host control value equals the bound control's value.
-     * Returns `null` (valid) when no control is bound.
-     * @param control - The form control to validate.
-     * @returns `null` when valid, `{ equals: ... }` otherwise.
+     * Returns `true` when `value` is a valid, non-empty (non-zero) UUID.
+     * @param value - The string to validate.
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EqualsValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<EqualsValidatorDirective, "[equals]", never, { "equals": { "alias": "equals"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates a file size against configurable minimum and maximum bounds.
- * Bind `[fileSize]` together with `[size]="fileSizeInMb"`, `[maxSizeMb]`, and `[minSizeMb]`.
- */
-declare class FileSizeValidatorDirective implements Validator {
-    /** Maximum allowed file size in megabytes. Defaults to 5. */
-    readonly maxSizeMb: i0.InputSignal<number>;
-    /** Minimum required file size in megabytes. Defaults to 0. */
-    readonly minSizeMb: i0.InputSignal<number>;
-    /** The actual file size in megabytes to validate against the bounds. */
-    readonly size: i0.InputSignal<number>;
+    static parseUUIDNotEmpty(value?: string): boolean;
     /**
-     * Validates that the bound file size falls within the configured min/max range.
-     * Returns `null` when no control value is present.
-     * @param control - The form control to validate.
+     * Return an empty UUID
+     * @returns : the empty UUID
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizeValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FileSizeValidatorDirective, "[fileSize]", never, { "maxSizeMb": { "alias": "maxSizeMb"; "required": false; "isSignal": true; }; "minSizeMb": { "alias": "minSizeMb"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates a control value as a GUID / UUID string.
- * Apply `guid` to a text input that expects a valid UUID.
- */
-declare class GuidValidatorDirective implements Validator {
+    static emptyUUID(): string;
     /**
-     * Validates that the control value is a well-formed GUID / UUID.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
+     * Create a new UUID
+     * @returns : the string UUID
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GuidValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<GuidValidatorDirective, "[guid]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates that a control value does not exceed a maximum word count.
- * Bind `[maxTerms]="10"` to allow at most 10 whitespace-separated terms.
- */
-declare class MaxTermsValidatorDirective implements Validator {
-    /** The maximum number of whitespace-separated terms allowed. */
-    readonly maxTerms: i0.InputSignal<number>;
+    static generateUUID(): string;
     /**
-     * Validates that the control value contains no more than the configured number of terms.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
+     * Reconstruct a standard UUID (with dashes) from a 32-char hex string without dashes.
+     * @param value : 32-character hex string
+     * @returns     : the formatted UUID or the original string if it doesn't match the expected format
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MaxTermsValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MaxTermsValidatorDirective, "[maxTerms]", never, { "maxTerms": { "alias": "maxTerms"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates that a string control value is not blank (whitespace-only).
- * Apply `notEmpty` to a text input where non-blank content is required.
- */
-declare class NotEmptyValidatorDirective implements Validator {
+    static inflateUUID(value: string): string;
+    /** Precompiled validation patterns. */
+    private static readonly emailRegex;
+    private static readonly urlRegex;
     /**
-     * Validates that the control value is a non-blank string.
-     * Returns `null` when the control is empty or not a string.
-     * @param control - The form control to validate.
+     * Parse a text and return true if it is a valid email (or empty)
+     * @param value : email
+     * @returns     : true if the email is valid or empty
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotEmptyValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NotEmptyValidatorDirective, "[notEmpty]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates that the host control's value is different from another control's value.
- * Bind `[notEqual]="otherControl"`.
- *
- * The host control is re-validated whenever the OTHER control's value changes,
- * so editing either field keeps both error states consistent.
- */
-declare class NotEqualValidatorDirective implements Validator {
-    /** The control whose value must differ from the host control's value. */
-    readonly notEqual: i0.InputSignal<AbstractControl<any, any, any>>;
-    /** Callback registered by Angular forms to re-run validation on the host control. */
-    private onValidatorChange?;
-    /** Subscription to the other control's valueChanges. */
-    private subscription?;
-    constructor();
+    static parseEmail(value?: string): boolean;
     /**
-     * Registers the callback Angular invokes to re-run this validator.
-     * @param fn - The revalidation callback provided by the forms API.
+     * Parse a text containing one or more email addresses separated by `;` or `,`
+     * and return true if all of them are valid (or the text is empty).
+     * Empty items caused by double or trailing separators are ignored.
+     * @param value : the email list to parse (e.g. "a@b.it; c@d.it")
+     * @returns     : true if all emails are valid or the value is empty
      */
-    registerOnValidatorChange(fn: () => void): void;
+    static parseEmails(value?: string): boolean;
     /**
-     * Validates that the host control value is not equal to the bound control's value.
-     * Also clears the `notequal` error on the other control when the host becomes valid.
-     * Returns `null` (valid) when no control is bound.
-     * @param control - The form control to validate.
-     * @returns `null` when valid, `{ notequal: true }` otherwise.
+     * Parse a text and return true if it is a valid url (or empty)
+     * @param value : the url to parse
+     * @returns     : true if the url is valid or empty
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotEqualValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NotEqualValidatorDirective, "[notEqual]", never, { "notEqual": { "alias": "notEqual"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates that a control value is not a future date.
- * Apply `notFuture` to a text input that expects a date on or before today.
- */
-declare class NotFutureValidatorDirective implements Validator {
+    static parseUrl(value?: string): boolean;
     /**
-     * Validates that the control value represents a date that is not in the future.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
+     * Get date parts from a string value
+     * @param value   : the string to parse
+     * @returns       : an array of numbers with year, month, day
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotFutureValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NotFutureValidatorDirective, "[notFuture]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates a control value as a sufficiently strong password.
- * Apply `password` to a password input.
- */
-declare class PasswordValidatorDirective implements Validator {
+    static getDateParts(value?: string): number[] | undefined;
     /**
-     * Validates that the control value meets the minimum password-strength requirements.
-     * @param control - The form control to validate.
+     * Checks whether a value is a valid Date instance.
+     * Note: do not use `date.getTime()` as a truthiness test, it is 0 (falsy)
+     * for the Unix epoch (1970-01-01T00:00:00Z) even though the date is valid.
+     * @param d : the value to check
+     * @returns : true when `d` is a Date representing a valid point in time
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<PasswordValidatorDirective, "[password]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that removes focus from the host element after it is clicked,
- * preventing the browser from keeping a visible focus ring post-interaction.
- * Apply `removeFocus` to any focusable element (e.g. a button).
- */
-declare class RemoveFocusDirective {
-    private readonly elementRef;
+    static isValidDate(d: unknown): d is Date;
     /**
-     * Handles click events on the host element and blurs it on the next event-loop tick
-     * so that the click action completes before focus is removed.
+     * Parse a date
+     * @param value   : the value to check
+     * @param locale  : the locale to use
+     * @returns       : a valid Date object or undefined
      */
-    onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RemoveFocusDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RemoveFocusDirective, "[removeFocus]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates a control value as a parseable SQL-compatible date string.
- * Apply `sqlDate` to a text input that expects a date after year 1750.
- */
-declare class SqlDateValidatorDirective implements Validator {
+    static parseDate(value?: string | Date, locale?: Locale): Date | undefined;
     /**
-     * Validates that the control value can be parsed as a date after 1750.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
+     * Format a date
+     * @param value     : the date or string to format
+     * @param fmt       : the DateFormat to use or the string pattern
+     * @param locale    : the locale to use (default is IT)
+     * @returns         : the formatted string
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SqlDateValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SqlDateValidatorDirective, "[sqlDate]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates a time string against optional allowed time slot ranges.
- * Bind `[time]` and optionally `[slots]="'08:00-12:00|14:00-18:00'"` (pipe-separated ranges).
- */
-declare class TimeValidatorDirective implements Validator {
-    /** Optional pipe-separated list of allowed time ranges, e.g. `"08:00-12:00|14:00-18:00"`. */
-    readonly slots: i0.InputSignal<string>;
+    static formatDate(value?: Date | string, fmt?: DateFormat | string, locale?: Locale): string;
     /**
-     * Parses a `"HH:MM"` time string into a comparable integer (e.g. `"09:30"` -> `930`).
-     * Returns `-1` when the string is not a valid time.
-     * @param value - The time string to parse.
+     * Return an italian local date
+     * @param value  : the date
+     * @returns     : the new date
      */
-    private getTime;
+    static toLocalDate(value?: Date | string): Date | undefined;
     /**
-     * Validates that the control value is a valid time string and, when slots are configured,
-     * that it falls within at least one of the allowed ranges.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
+     * Update a DateInterval object according to a string
+     * @param value       : string value
+     * @param interval    : DateInterval value to update
+     * @param end         : true if must be updated the first or the end value
+     * @param copy        : copy the same value (works only if not end element)
+     */
+    static changeDateInterval(value: string, interval: DateInterval, end?: boolean, copy?: boolean): void;
+    /** Cache of `Intl.NumberFormat` instances (their construction is expensive). */
+    private static readonly numberFormatCache;
+    /**
+     * Returns a cached `Intl.NumberFormat` for the given options, creating it on first use.
+     * @param locale  - BCP 47 locale tag.
+     * @param options - The `Intl.NumberFormat` options.
+     * @returns A shared formatter instance.
+     */
+    private static getNumberFormat;
+    /**
+     * Formats a number using a cached `Intl.NumberFormat`.
+     * @param value    - The number to format.
+     * @param decimals - Maximum decimal places (default: `2`).
+     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
+     * @returns The formatted number string.
+     */
+    static formatNumber(value: number, decimals?: number, locale?: string): string;
+    /**
+     * Formats a number as a currency string using a cached `Intl.NumberFormat`.
+     * @param value    - The number to format.
+     * @param currency - ISO 4217 currency code (default: `'EUR'`).
+     * @param decimals - Maximum decimal places (default: `2`).
+     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
+     * @returns The formatted currency string.
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TimeValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TimeValidatorDirective, "[time]", never, { "slots": { "alias": "slots"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates a control value as a well-formed URL.
- * Apply `url` to a text input that expects a URL.
- */
-declare class UrlValidatorDirective implements Validator {
+    static formatCurrency(value: number, currency?: string, decimals?: number, locale?: string): string;
     /**
-     * Validates that the control value is a well-formed URL.
-     * Returns `null` (valid) when the control is empty.
-     * @param control - The form control to validate.
+     * Percent-encodes a string for safe inclusion in a URL.
+     * @param value - The string to encode.
+     * @returns The encoded string, or `undefined` when `value` is empty.
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<UrlValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<UrlValidatorDirective, "[url]", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Directive that validates a control using the host object's `isValid()` method
- * or a boolean expression passed via `[validIf]`.
- */
-declare class ValidIfDirective implements Validator {
-    /** When `true`, the control is considered valid regardless of the bound value. */
-    readonly validIf: i0.InputSignal<boolean>;
+    static urlEncode(value: string): string | undefined;
     /**
-     * Validates the control value against a boolean flag or the value's own `isValid()` method.
-     * @param control - The form control to validate.
+     * Decodes a percent-encoded URL string, treating `+` as a space.
+     * @param value - The encoded string to decode.
+     * @returns The decoded string, or `undefined` when `value` is empty or absent.
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ValidIfDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ValidIfDirective, "[validIf]", never, { "validIf": { "alias": "validIf"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Directive that delegates validation to an externally provided validator function.
- * Bind `[validator]="myFn"` where `myFn` is `(c: AbstractControl) => ValidationErrors | null`.
- */
-declare class ValidatorDirective implements Validator {
-    /** The custom validator function to apply. */
-    readonly validator: i0.InputSignal<(control: AbstractControl) => ValidationErrors | null>;
+    static urlDecode(value?: string): string | undefined;
     /**
-     * Invokes the provided validator function against the given control.
-     * Returns `null` (valid) when no function is bound.
-     * @param control - The form control to validate.
+     * Reads a query string parameter value from the current page URL.
+     * @param name - The parameter name to look up.
+     * @returns The decoded parameter value, or `undefined` when absent or running server-side.
      */
-    validate(control: AbstractControl): ValidationErrors | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ValidatorDirective, "[validator]", never, { "validator": { "alias": "validator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Pipe that converts plain-text newlines (`\r\n`, `\r`, `\n`) to HTML `<br>` tags
- * and marks the result as trusted HTML so Angular does not escape it.
- *
- * Usage: `{{ text | formatHtml }}`
- */
-declare class FormatHtmlPipe implements PipeTransform {
-    private readonly sanitizer;
+    static getQueryStringValueByName(name: string): string | undefined;
     /**
-     * Transforms a plain-text string into sanitized HTML by replacing newline characters
-     * with `<br>` tags.
-     * @param value - The input string to transform. Treated as an empty string when `undefined`.
-     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     * Generate a password
+     * @returns : the password string
      */
-    transform(value?: string): SafeHtml;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormatHtmlPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<FormatHtmlPipe, "formatHtml", true>;
-}
-
-/**
- * Pipe that converts a Markdown string to sanitized HTML using `SystemUtils.markdownToHtml`.
- *
- * Usage: `{{ text | formatMarkdown }}`
- */
-declare class FormatMarkdownPipe implements PipeTransform {
-    private readonly sanitizer;
+    static generatePassword(length?: number): string;
     /**
-     * Transforms a Markdown string into sanitized HTML.
-     * @param value - The Markdown input to convert. Treated as an empty string when `undefined`.
-     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     * Calculate password strength
+     * @param password: the password to evaluate
+     * @returns the password strength info
      */
-    transform(value?: string): SafeHtml;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormatMarkdownPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<FormatMarkdownPipe, "formatMarkdown", true>;
-}
-
-/**
- * General-purpose formatting pipe that converts a raw value to a locale-aware string
- * based on the specified format type.
- *
- * Supported types: `'date'` / `'D'`, `'currency'` / `'C'`, `'number'` / `'N'`,
- * `'number0'` / `'N0'`, `'percentage'` / `'P'`.
- *
- * Usage: `{{ value | format:'currency' }}`
- */
-declare class FormatPipe implements PipeTransform {
-    /** Shared formatters: building an `Intl.NumberFormat` per call is expensive. */
-    private static readonly currencyFormat;
-    private static readonly numberFormat;
-    private static readonly number0Format;
-    private static readonly percentFormat;
+    static calculatePasswordStrength(password?: string): PasswordStrength;
     /**
-     * Formats a value according to the specified type and optional pattern.
-     * Returns `undefined` when the value is `null` or `undefined`, or when the type is unrecognised.
-     * @param value   - The raw value to format.
-     * @param type    - The format type identifier (default: `'date'`).
-     * @param pattern - The date pattern used when `type` is `'date'` (default: `'dd/MM/yyyy'`).
-     * @returns A formatted string, or `undefined` when the value cannot be formatted.
+     * Check if current browser supports touch
+     * @returns : true if the display is touchable
      */
-    transform(value?: unknown, type?: string, pattern?: string): string | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormatPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<FormatPipe, "format", true>;
-}
-
-/**
- * Pipe that applies a global regex replacement on a string and returns the result
- * as sanitized HTML. When `regexValue` is `'\n'` and no `replaceValue` is given,
- * newlines are replaced with `<br>` tags.
- *
- * Usage: `{{ text | replace:'\n':'' }}`
- */
-declare class ReplacePipe implements PipeTransform {
-    private readonly sanitizer;
+    static isTouchable(): boolean;
     /**
-     * Replaces all occurrences of `regexValue` in `value` with `replaceValue`.
-     * Returns `undefined` when `value` is empty or `undefined`.
-     * @param value        - The source string to process.
-     * @param regexValue   - The regex pattern string to match (applied with the global flag).
-     * @param replaceValue - The replacement string. Defaults to `'<br>'` when `regexValue` is `'\n'` and this is falsy.
-     * @returns A `SafeHtml` value with all matches replaced, or `undefined` when the input is empty.
+     * This check will prevent 'window' logic to be executed
+     * while executing the server rendering
+     * @returns : true if using the browser
      */
-    transform(value: string | undefined, regexValue: string, replaceValue?: string): SafeHtml | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ReplacePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<ReplacePipe, "replace", true>;
-}
-
-/**
- * Pipe that marks an HTML string as trusted so Angular does not escape it when
- * bound via `[innerHTML]`.
- *
- * Usage: `<div [innerHTML]="html | safeHtml"></div>`
- */
-declare class SafeHtmlPipe implements PipeTransform {
-    private readonly sanitizer;
+    static isBrowser(): boolean;
     /**
-     * Bypasses Angular's HTML sanitization and returns a `SafeHtml` instance.
-     * @param value - The raw HTML string to trust. Treated as an empty string when `undefined`.
-     * @returns A `SafeHtml` value that can be bound to `[innerHTML]` without escaping.
+     * Convert folders in a tree of Node object.
+     * @param folders : the subfolders group or null to root
+     * @returns       : a node list
      */
-    transform(value?: string): SafeHtml;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
-}
-
-/**
- * Pipe that marks a URL string as a trusted resource URL so Angular does not block it
- * when bound to attributes such as `[src]` or `[href]` on iframes, objects, or embeds.
- *
- * Usage: `<iframe [src]="url | safeUrl"></iframe>`
- */
-declare class SafeUrlPipe implements PipeTransform {
-    private readonly sanitizer;
+    static toNodes(folders: INode[]): INode[];
     /**
-     * Bypasses Angular's resource-URL sanitization and returns a `SafeResourceUrl` instance.
-     * @param value - The URL string to trust. Treated as an empty string when `undefined`.
-     * @returns A `SafeResourceUrl` that can be bound to resource URL attributes without blocking.
+     * Convert folders in a tree of Node object.
+     * @param folders : the children group or null to root
+     * @param parent  : the parent node
+     * @returns       : a node list
      */
-    transform(value?: string): SafeResourceUrl;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SafeUrlPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<SafeUrlPipe, "safeUrl", true>;
-}
-
-/**
- * Impure pipe that filters an array using a caller-provided predicate function.
- * Because the pipe is impure it re-evaluates on every change-detection cycle,
- * which is necessary when the predicate's captured state changes.
- *
- * Usage: `*ngFor="let item of items | callback:myFilter"`
- */
-declare class SearchCallbackPipe implements PipeTransform {
+    private static _toNodes;
     /**
-     * Filters `items` by applying `callback` to each element.
-     * Returns the original array unchanged when either argument is falsy.
-     * @param items    - The source array to filter. May be `undefined`.
-     * @param callback - A predicate function that returns `true` for items to keep.
-     * @returns A new filtered array, the original array when no callback is provided,
-     *          or `undefined` when `items` is `undefined`.
+     * Returns an array of individual power-of-2 flag values that are set in `value`.
+     * @param value - The bitmask to decompose.
+     * @param max   - Upper-bound exponent: checks flags from `1` up to `1 << max` (default: `30`).
+     * @returns Array of set flag values, or an empty array when `value` is `0`.
      */
-    transform<T>(items: T[] | undefined, callback: ((item: T) => boolean) | undefined): T[] | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SearchCallbackPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<SearchCallbackPipe, "callback", true>;
-}
-
-/**
- * Pure pipe that filters an array of searchable items against a text query.
- * Note: being pure, it re-runs only when the array REFERENCE or the query
- * changes; mutate-in-place updates of the array are not detected.
- *
- * Each item is matched either via its `searchBag.name` property (when present)
- * or by converting the item itself to a lowercase string. The optional `metadata`
- * argument is updated in-place with the total item count and the filtered count,
- * making it usable in the template alongside `*ngFor`.
- *
- * Usage:
- * ```html
- * <div *ngFor="let item of items | search:filterText:meta">...</div>
- * <div>Showing {{ meta.count }} of {{ meta.total }}</div>
- * ```
- */
-declare class SearchFilterPipe implements PipeTransform {
+    static getFlags(value: number, max?: number): number[];
+    /** Cache for resolved color luminance results. */
+    private static readonly colorLightCache;
     /**
-     * Filters `items` by performing a case-insensitive substring match against `value`.
-     * When `items` or `value` is falsy the original array is returned unfiltered.
-     * @param items    - The source array to filter. May be `undefined`.
-     * @param value    - The search text to match against each item. May be `undefined`.
-     * @param metadata - Optional object that is updated with `total` and `count` after filtering.
-     * @returns The filtered array, the original array when no filter text is given,
-     *          or `undefined` when `items` is `undefined`.
+     * Check if a color is light or dark
+     * @param color : the color
+     * @param minimumLuminance : the lumimance to consider
+     * @returns true if the color is light
      */
-    transform(items?: any[], value?: string, metadata?: SearchFilterMetadata): any[] | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SearchFilterPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<SearchFilterPipe, "search", true>;
+    static isColorLight(color: string, minimumLuminance?: number): boolean;
 }
 
 declare const UtilsMessages: {
@@ -1481,7 +1481,7 @@ declare class BroadcastService implements OnDestroy {
     /**
      * Creates a new standalone `BroadcastChannelManager` instance bound to the shared ARS channel.
      * Useful when a caller needs direct channel access outside the service.
-     * @returns A new `BroadcastChannelManager` connected to `'D2693418-B18F-41BB-BAE9-41BB5407957A-CHANNEL'`.
+     * @returns A new `BroadcastChannelManager` connected to the shared channel.
      */
     static createChannel(): BroadcastChannelManager;
     ngOnDestroy(): void;