@ibragim-dev-org/ui-forge-library 1.0.8

package/types/ibragim-dev-org-ui-forge-library.d.ts

@@ -0,0 +1,927 @@
+import * as i0 from '@angular/core';
+import { InputSignal, ElementRef, OnInit, OnDestroy, EventEmitter, AfterViewInit, DestroyRef, Renderer2, OnChanges, DoCheck, AfterContentInit, AfterContentChecked, AfterViewChecked, SimpleChanges, PipeTransform, ModelSignal, WritableSignal, Signal, OutputEmitterRef, Injector, Type, TemplateRef } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { NavigationStart, NavigationEnd, NavigationCancel, NavigationError, RoutesRecognized, GuardsCheckStart, GuardsCheckEnd, RouteConfigLoadStart, RouteConfigLoadEnd, ChildActivationStart, ChildActivationEnd, ActivationStart, ActivationEnd, Scroll, ResolveStart, ResolveEnd, NavigationSkipped, Router } from '@angular/router';
+import { ComponentType, Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { ComponentType as ComponentType$1 } from '@angular/cdk/portal';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { WithOptionalField, ValidationError, FormValueControl, FormCheckboxControl } from '@angular/forms/signals';
+
+declare class DateUtils {
+    static parse(value: string, isUsaDateFormat?: boolean): Date | null;
+    static format(date: Date, isUsaDateFormat?: boolean): string;
+    static isUsaDateFormat(): boolean;
+    static setMonthSafe(date: Date, month: number): Date;
+}
+
+declare class AutoFocusDirective {
+    private el;
+    $shouldFocus: InputSignal<boolean>;
+    constructor(el: ElementRef<HTMLInputElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocusDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoFocusDirective, "[appAutoFocus]", never, { "$shouldFocus": { "alias": "$shouldFocus"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LazyImageService {
+    private observer?;
+    getObserver(): IntersectionObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyImageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LazyImageService>;
+}
+
+declare class LazyImgDirective implements OnInit, OnDestroy {
+    private readonly el;
+    private readonly lazyService;
+    lazySrc: string;
+    loadError: EventEmitter<void>;
+    private observer;
+    constructor(el: ElementRef<HTMLImageElement>, lazyService: LazyImageService);
+    private onError;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LazyImgDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LazyImgDirective, "img[lazySrc]", never, { "lazySrc": { "alias": "lazySrc"; "required": false; }; }, { "loadError": "loadError"; }, never, never, true, never>;
+}
+
+declare class MaskGradientDirective implements AfterViewInit {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly renderer;
+    private platformId;
+    id: InputSignal<string>;
+    constructor(elementRef: ElementRef<HTMLElement>, destroyRef: DestroyRef, renderer: Renderer2, platformId: object);
+    ngAfterViewInit(): void;
+    private setGradient;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaskGradientDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MaskGradientDirective, "[markGradientDirective]", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TrackLifecycleDirective implements OnInit, OnChanges, DoCheck, AfterContentInit, AfterContentChecked, AfterViewInit, AfterViewChecked, OnDestroy {
+    onConstructed: EventEmitter<void>;
+    onChanges: EventEmitter<SimpleChanges>;
+    onInit: EventEmitter<void>;
+    onDoCheck: EventEmitter<void>;
+    onAfterContentInit: EventEmitter<void>;
+    onAfterContentChecked: EventEmitter<void>;
+    onAfterViewInit: EventEmitter<void>;
+    onAfterViewChecked: EventEmitter<void>;
+    onDestroy: EventEmitter<void>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackLifecycleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TrackLifecycleDirective, "[trackLifecycle]", never, {}, { "onConstructed": "onConstructed"; "onChanges": "onChanges"; "onInit": "onInit"; "onDoCheck": "onDoCheck"; "onAfterContentInit": "onAfterContentInit"; "onAfterContentChecked": "onAfterContentChecked"; "onAfterViewInit": "onAfterViewInit"; "onAfterViewChecked": "onAfterViewChecked"; "onDestroy": "onDestroy"; }, never, never, true, never>;
+}
+
+declare class StickyObserverDirective implements AfterViewInit, OnDestroy {
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    protected readonly renderer: Renderer2;
+    private observer;
+    private sentinel;
+    constructor(elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StickyObserverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StickyObserverDirective, "[appStickyObserver]", never, {}, {}, never, never, true, never>;
+}
+
+declare class CenterEllipsisPipe implements PipeTransform {
+    transform(value: string, visibleStart?: number, visibleEnd?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CenterEllipsisPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CenterEllipsisPipe, "centerEllipsis", true>;
+}
+
+declare function getAspectRatioFit(maxWidth: number, maxHeight: number, srcWidth?: number | null, srcHeight?: number | null): {
+    width: number;
+    height: number;
+};
+
+declare function stringToHslColor(string: string, saturation?: number, lightness?: number): string;
+
+type AppIconName = string;
+declare type Nominal<T, Name extends string> = T & {
+    [Symbol.species]: Name;
+};
+type RawSVG = Nominal<string, 'RawSVG'>;
+interface AppIcon {
+    svgData: RawSVG;
+    name: AppIconName;
+}
+
+declare class AppIconsLibrary {
+    private icons;
+    addIcon(icon: RawSVG, name: AppIconName): void;
+    getIcon(name: AppIconName): AppIcon | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppIconsLibrary, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppIconsLibrary>;
+}
+
+declare class IconComponent {
+    elementRef: ElementRef<HTMLElement>;
+    private icons;
+    private renderer;
+    private sanitizer;
+    noScaling: string;
+    strokeDiff: string;
+    set icon(i: AppIconName | AppIcon | undefined);
+    private iconApp;
+    constructor(elementRef: ElementRef<HTMLElement>, icons: AppIconsLibrary, renderer: Renderer2, sanitizer: DomSanitizer, noScaling: string, strokeDiff: string);
+    private updateIcon;
+    private adjustStrokeWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, [null, null, null, null, { attribute: "no-scaling"; }, { attribute: "stroke-diff"; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "app-icon", never, { "icon": { "alias": "icon"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare const HAS_NUMBER: RegExp;
+declare const HAS_CAPITAL_CASE: RegExp;
+declare const HAS_SMALL_CASE: RegExp;
+declare const HAS_SPECIAL_CHARTERS: RegExp;
+declare const MIN_LENGTH: RegExp;
+declare const EMAIL: RegExp;
+
+interface CountryData {
+    code: string;
+    name: string;
+    iso: string;
+    phonePrefix: string;
+}
+declare const emptyCountry: CountryData;
+declare class CountryService {
+    private static readonly phoneUtil;
+    private static readonly flagOverrides;
+    private static readonly supportedRegions;
+    private static readonly regionNames;
+    private static readonly allCountries;
+    static readonly countries: CountryData[];
+    static formatPhoneNumber(raw: string, countryCode: string): string;
+    static getCountryByCode(code: string): CountryData | undefined;
+}
+
+/**
+ * ThemeService<T>
+ * A generic, type-safe service for managing and applying color themes.
+ *
+ * @template T - The shape of a theme object, typically defined by a shared interface.
+ */
+declare class ThemeService<T extends object, K extends string> {
+    private document;
+    private themes;
+    private activeTheme;
+    constructor(document: Document);
+    /**
+     * Initializes the theme system with a map of named themes and sets the active theme.
+     *
+     * @param themes - A record of theme names mapped to theme objects
+     * @param activeTheme - The name of the theme to activate initially
+     */
+    init(themes: Record<K, T>, activeTheme: K): void;
+    /**
+     * Returns the name of the currently active theme.
+     *
+     * @returns The active theme name
+     */
+    getActive(): K;
+    /**
+     * Sets a new active theme by name and applies its styles.
+     *
+     * @param name - The name of the theme to activate
+     */
+    set(name: K): void;
+    /**
+     * Applies the current theme's styles to the document body using CSS variables.
+     */
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService<any, any>>;
+}
+
+type NavigationEvent = NavigationStart | NavigationEnd | NavigationCancel | NavigationError | RoutesRecognized | GuardsCheckStart | GuardsCheckEnd | RouteConfigLoadStart | RouteConfigLoadEnd | ChildActivationStart | ChildActivationEnd | ActivationStart | ActivationEnd | Scroll | ResolveStart | ResolveEnd | NavigationSkipped;
+
+declare class UiAccordionComponent implements AfterViewInit {
+    private readonly destroyRef;
+    private readonly platformId;
+    readonly $isOpen: ModelSignal<boolean>;
+    readonly $durationMs: InputSignal<number>;
+    protected readonly $contentHeight: WritableSignal<string>;
+    protected readonly $transition: Signal<string>;
+    protected readonly $overflow: WritableSignal<'visible' | 'hidden'>;
+    private readonly $content;
+    private resizeDebounceTimer;
+    constructor(destroyRef: DestroyRef, platformId: object);
+    ngAfterViewInit(): void;
+    private setSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UiAccordionComponent, "app-ui-accordion", never, { "$isOpen": { "alias": "$isOpen"; "required": false; "isSignal": true; }; "$durationMs": { "alias": "$durationMs"; "required": false; "isSignal": true; }; }, { "$isOpen": "$isOpenChange"; }, never, ["[button]", "[content]"], true, never>;
+}
+
+declare enum AlertType {
+    SUCCESS = "success",
+    ERROR = "error",
+    INFO = "information",
+    WARNING = "warning",
+    CUSTOM = "custom"
+}
+declare class Alert {
+    id: string;
+    type: string;
+    title: string;
+    message: string;
+    icon: string;
+    component?: ComponentType<unknown>;
+    componentInputs?: {
+        [P in keyof ComponentType<unknown>]?: ComponentType<unknown>[P];
+    };
+    constructor(init?: Partial<Alert>);
+}
+interface AlertParams {
+    title?: string;
+    message: string;
+}
+
+declare class UiAlertMessagesService {
+    private readonly overlay;
+    private router;
+    readonly $alerts: WritableSignal<Alert[]>;
+    private overlayRef?;
+    private component;
+    constructor(overlay: Overlay, router: Router);
+    success(params: AlertParams): void;
+    error(params: AlertParams): void;
+    information(params: AlertParams): void;
+    warning(params: AlertParams): void;
+    remove(alert: Alert): void;
+    removeAll(): void;
+    init(component: ComponentType$1<unknown>): void;
+    protected open(alert: Alert): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiAlertMessagesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiAlertMessagesService>;
+}
+
+type AvatarStyles = 'small' | 'medium' | 'large' | 'rounded';
+declare abstract class UiAvatarDirective {
+    readonly $class: InputSignal<AvatarStyles[]>;
+    readonly $src: InputSignal<string>;
+    readonly $acronym: InputSignal<string>;
+    protected readonly $backgroundColor: WritableSignal<string>;
+    protected readonly $textColor: WritableSignal<string>;
+    protected readonly $text: WritableSignal<string>;
+    protected readonly $canShowAvatar: WritableSignal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiAvatarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiAvatarDirective, "app-ui-avatar", never, { "$class": { "alias": "$class"; "required": true; "isSignal": true; }; "$src": { "alias": "$src"; "required": true; "isSignal": true; }; "$acronym": { "alias": "$acronym"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface CalendarDay {
+    date: Date;
+    isSelected: boolean;
+    isStart?: boolean;
+    isEnd?: boolean;
+    inRange?: boolean;
+    inCurrentMonth: boolean;
+    inHoverRange: boolean;
+}
+interface CalendarMonthItem {
+    index: number;
+    name: string;
+    short: string;
+    date: Date;
+    isSelected: boolean;
+}
+interface CalendarYearItem {
+    year: number;
+    date: Date;
+    isSelected: boolean;
+}
+
+declare class UiDailyCalendarDirective {
+    private readonly weekDaysEuropean;
+    private readonly weekDaysUsa;
+    readonly $isRangeSelection: InputSignal<boolean>;
+    get weekDays(): string[];
+    readonly $dateStart: ModelSignal<Date | null>;
+    readonly $dateEnd: ModelSignal<Date | null>;
+    readonly $hoverDate: WritableSignal<Date | null>;
+    readonly $currentMonth: ModelSignal<number>;
+    readonly $currentYear: ModelSignal<number>;
+    readonly $onRangeSelect: OutputEmitterRef<{
+        start: Date | null;
+        end: Date | null;
+    }>;
+    readonly $onSelect: OutputEmitterRef<Date>;
+    protected readonly $calendarDays: Signal<CalendarDay[]>;
+    private generateCalendar;
+    private isSameDay;
+    private isBetween;
+    private getDayState;
+    protected onHover(date: Date | null, inHoverRange: boolean): void;
+    private isUsaDateFormat;
+    protected select(date: Date): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiDailyCalendarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiDailyCalendarDirective, "app-ui-daily-calendar", never, { "$isRangeSelection": { "alias": "$isRangeSelection"; "required": false; "isSignal": true; }; "$dateStart": { "alias": "$dateStart"; "required": false; "isSignal": true; }; "$dateEnd": { "alias": "$dateEnd"; "required": false; "isSignal": true; }; "$currentMonth": { "alias": "$currentMonth"; "required": true; "isSignal": true; }; "$currentYear": { "alias": "$currentYear"; "required": true; "isSignal": true; }; }, { "$dateStart": "$dateStartChange"; "$dateEnd": "$dateEndChange"; "$currentMonth": "$currentMonthChange"; "$currentYear": "$currentYearChange"; "$onRangeSelect": "$onRangeSelect"; "$onSelect": "$onSelect"; }, never, never, true, never>;
+}
+
+declare abstract class UiMonthlyCalendarDirective {
+    $date: ModelSignal<Date | null>;
+    $onSelect: OutputEmitterRef<Date>;
+    $currentYear: ModelSignal<number>;
+    protected $months: Signal<CalendarMonthItem[]>;
+    private generateMonths;
+    protected select(date: Date): void;
+    private isSelected;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiMonthlyCalendarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiMonthlyCalendarDirective, "app-ui-monthly-calendar", never, { "$date": { "alias": "$date"; "required": false; "isSignal": true; }; "$currentYear": { "alias": "$currentYear"; "required": true; "isSignal": true; }; }, { "$date": "$dateChange"; "$onSelect": "$onSelect"; "$currentYear": "$currentYearChange"; }, never, never, true, never>;
+}
+
+declare class UiYearlyCalendarDirective {
+    $date: ModelSignal<Date | null>;
+    $onSelect: OutputEmitterRef<Date>;
+    $currentYear: ModelSignal<number>;
+    protected $years: Signal<CalendarYearItem[]>;
+    private generateYears;
+    private createSafeDate;
+    protected select(date: Date): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiYearlyCalendarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiYearlyCalendarDirective, "app-ui-yearly-calendar", never, { "$date": { "alias": "$date"; "required": false; "isSignal": true; }; "$currentYear": { "alias": "$currentYear"; "required": true; "isSignal": true; }; }, { "$date": "$dateChange"; "$onSelect": "$onSelect"; "$currentYear": "$currentYearChange"; }, never, never, true, never>;
+}
+
+interface Highlighted {
+    string: string;
+    index: number;
+    css: string;
+}
+declare abstract class UiCodeDirective {
+    readonly $code: InputSignal<string>;
+    protected readonly $language: WritableSignal<string>;
+    protected readonly $highlightedArray: WritableSignal<Highlighted[]>;
+    constructor();
+    private highlightCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiCodeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiCodeDirective, "app-ui-code", never, { "$code": { "alias": "$code"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface UiPopupAnimation {
+    startOrigin: string;
+    endOrigin: string;
+    start: string;
+    end: string;
+    leftStart: string;
+    leftEnd: string;
+    topStart: string;
+    topEnd: string;
+}
+interface UiPopupParameters<TComponent> {
+    options: UiPopupOptions<TComponent>;
+}
+interface UiPopupOptions<TComponent> {
+    inputs?: {
+        [P in keyof TComponent]?: TComponent[P];
+    };
+}
+
+type DropdownPosition = 'top' | 'bottom' | 'left' | 'right' | 'center' | 'left-bottom' | 'left-top' | 'right-top' | 'right-bottom';
+interface DropdownParameters<TComponent> {
+    options: UiPopupOptions<TComponent>;
+    position: DropdownPosition;
+    hasBackdrop: boolean;
+    removePrevious: boolean;
+    hasAttachedWidth: boolean;
+}
+interface DropdownItem {
+    content: string;
+    icon?: AppIcon;
+    contentColor?: string;
+    iconColor?: string;
+    func?: () => void;
+}
+
+interface PopupAnimationOptions {
+    positionX: number;
+    positionY: number;
+    startTransition: string;
+    endTransition: string;
+}
+declare class UiPopupInstance {
+    private readonly overlayRef;
+    private readonly destroyRef;
+    id: string;
+    width: number;
+    readonly animationOrigin$: BehaviorSubject<string>;
+    readonly options: PopupAnimationOptions;
+    private readonly closed;
+    private readonly shouldClose;
+    constructor(overlayRef: OverlayRef, destroyRef: DestroyRef, options?: PopupAnimationOptions);
+    close(): void;
+    detach(): void;
+    onShouldClose(): Observable<void>;
+}
+
+interface PopupParameters {
+    animationOptions: PopupAnimationOptions;
+    isStaticBackdrop: boolean;
+    isClosePrevious: boolean;
+    width: number;
+}
+declare class UiPopupService {
+    protected overlay: Overlay;
+    protected injector: Injector;
+    protected destroyRef: DestroyRef;
+    protected router: Router;
+    popupInstances: UiPopupInstance[];
+    private backdropRef?;
+    private backdropPortal?;
+    private backdropPortalRef?;
+    protected readonly destroyDownloading$: Subject<void>;
+    protected readonly destroyOutsideClickSubscription$: Subject<void>;
+    constructor(overlay: Overlay, injector: Injector, destroyRef: DestroyRef, router: Router);
+    init<TComponent>(component: Type<TComponent>): void;
+    /**
+     * Opens a popup with the specified component and options.
+     *
+     * @param component - The component to be displayed in the popup.
+     * @param options - Configuration options for the popup, including inputs.
+     * @param id - A unique identifier for the popup instance.
+     * @param parameters - (Optional) Configuration options for the popup.
+     */
+    open<TComponent>(component: Type<TComponent>, options: UiPopupOptions<TComponent>, id: string, parameters: Partial<PopupParameters>): void;
+    /**
+     * Opens a popup that scales from the provided origin element to the centered popup size.
+     * Useful for image-preview transitions where the source element animates into the popup.
+     */
+    openScaledFromElement<TComponent>(component: Type<TComponent>, options: UiPopupOptions<TComponent>, id: string, originElement: HTMLElement, sourceWidth: number, sourceHeight: number, parameters?: Partial<PopupParameters>): void;
+    /**
+     * Closes the last opened popup.
+     */
+    close(): void;
+    private closePrevious;
+    /**
+     * Closes a popup by its index in the popupInstances array.
+     *
+     * @param index - The index of the popup to close.
+     */
+    closeByIndex(index: number): void;
+    /**
+     * Closes a popup by its unique identifier.
+     *
+     * @param id - The unique identifier of the popup to close.
+     */
+    closeById(id: string): void;
+    /**
+     * Closes all currently opened popups.
+     */
+    closeAll(): void;
+    /**
+     * Creates a popup instance with the specified component and options.
+     *
+     * @param overlayRef - The overlay reference for the popup.
+     * @param component - The component to be displayed in the popup.
+     * @param options - Configuration options for the popup, including inputs.
+     * @param id - A unique identifier for the popup instance.
+     * @param parameters - (Optional) Configuration options for the popup.
+     */
+    protected createPopup<TComponent>(overlayRef: OverlayRef, component: Type<TComponent>, options: UiPopupOptions<TComponent>, id: string, parameters: Partial<PopupParameters>): void;
+    /**
+     * Subscribes to outside events (e.g., scroll, router events) to close popups.
+     */
+    protected subscribeToOutsideEvents(): void;
+    protected destroy(): void;
+    protected showBackdrop(isStaticBackdrop?: boolean): void;
+    protected hideBackdrop(): void;
+    /**
+     * Fetches and normalizes popup parameters.
+     *
+     * @param parameters - Partial configuration options for the popup.
+     * @returns A complete set of popup parameters with default values applied.
+     */
+    private fetchPopupParameters;
+    private createScaleAnimationOptionsFromElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiPopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiPopupService>;
+}
+
+declare class UiDropdownService extends UiPopupService {
+    private tipContainerRef?;
+    private tipContainerPortal?;
+    containerSize$: BehaviorSubject<{
+        width: number;
+        height: number;
+    }>;
+    private connectedPositions;
+    init(component: Type<unknown>, tipComponent?: Type<unknown>): void;
+    /**
+     * Opens a tooltip (tip) component attached to a specific HTML element.
+     * The tooltip displays text content with customizable position and offset.
+     *
+     * @param text - The text content to display in the tooltip.
+     * @param attachedRef - The HTML element to which the tooltip is attached.
+     * @param id - A unique identifier for the tooltip instance.
+     * @param position - (Optional) The positioning of the tooltip relative to the attached element (default: 'top').
+     *                   Available positions: 'top', 'bottom', 'left', 'right', 'center',
+     *                   'left-top', 'left-bottom', 'right-top', 'right-bottom'.
+     * @param offsetY - (Optional) Vertical offset for tooltip positioning in pixels (default: 0).
+     * @param offsetX - (Optional) Horizontal offset for tooltip positioning in pixels (default: 0).
+     *
+     */
+    openTip(text: string, attachedRef: HTMLElement, id: string, position?: DropdownPosition, offsetY?: number, offsetX?: number): void;
+    /**
+     * Opens a dropdown attached to a specific HTML element.
+     *
+     * @param component - The component to be displayed in the dropdown.
+     * @param attachedRef - The HTML element to which the dropdown is attached.
+     * @param id - A unique identifier for the dropdown instance.
+     * @param parameters - (Optional) Configuration options for the dropdown.
+     * @param offsetY - (Optional) Vertical offset for dropdown positioning.
+     * @param offsetX - (Optional) Horizontal offset for dropdown positioning.
+     */
+    openAttached<TComponent>(component: Type<TComponent>, attachedRef: HTMLElement, id: string, parameters?: Partial<DropdownParameters<TComponent>>, offsetY?: number, offsetX?: number): void;
+    /**
+     * Opens a dropdown from the mouse position with intelligent border detection.
+     * The dropdown grows from the mouse cursor, adjusting position and animation origin
+     * based on available space near window boundaries.
+     *
+     * @param component - The component to be displayed in the dropdown.
+     * @param event - The MouseEvent containing the cursor position.
+     * @param id - A unique identifier for the dropdown instance.
+     * @param parameters - (Optional) Configuration options for the dropdown.
+     */
+    openAtMousePosition<TComponent>(component: Type<TComponent>, event: MouseEvent, id: string, parameters?: Partial<DropdownParameters<TComponent>>): void;
+    /**
+     * Calculates the animation origin based on mouse position relative to window boundaries.
+     *
+     * @param event - The MouseEvent containing the cursor position.
+     * @param containerSize - The size of the dropdown container.
+     * @returns The animation origin string (e.g., 'top left', 'bottom right').
+     */
+    private calculateMousePositionAnimationOrigin;
+    /**
+     * Calculates position adjustments for the dropdown when opened from mouse position.
+     * Ensures the dropdown stays within boundaries and positions intelligently.
+     *
+     * @param event - The MouseEvent containing the cursor position.
+     * @param containerSize - The size of the dropdown container.
+     * @returns An object with left and top position adjustments.
+     */
+    private calculateMousePositionAdjustment;
+    /**
+     * Creates a global position strategy for mouse-positioned dropdowns.
+     *
+     * @param event - The MouseEvent containing the cursor position.
+     * @returns The configured PositionStrategy for the overlay.
+     */
+    private createMousePositionStrategy;
+    protected subscribeToOutsideEvents(overlayRef?: OverlayRef): void;
+    /**
+     * Fetches and normalizes dropdown parameters.
+     *
+     * @param parameters - Partial configuration options for the dropdown.
+     * @returns A complete set of dropdown parameters with default values applied.
+     */
+    private fetchDropDownParameters;
+    /**
+     * Creates a position strategy for the dropdown overlay.
+     *
+     * @param attachedRef - The HTML element to which the dropdown is attached.
+     * @param parameters - The normalized dropdown parameters, including position and options.
+     * @param offsetX - Horizontal offset for dropdown positioning.
+     * @param offsetY - Vertical offset for dropdown positioning.
+     * @returns The configured PositionStrategy for the overlay.
+     */
+    private createPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiDropdownService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiDropdownService>;
+}
+
+declare abstract class UiPopupContainerDirective implements OnInit {
+    protected popupInstance: UiPopupInstance;
+    protected destroyRef: DestroyRef;
+    protected popupService: UiPopupService;
+    protected elementRef: ElementRef<HTMLElement>;
+    protected readonly $isShow: WritableSignal<boolean>;
+    protected readonly $pulseTrigger: WritableSignal<boolean>;
+    readonly $overflowHidden: InputSignal<boolean>;
+    readonly $shouldClose: ModelSignal<boolean>;
+    readonly $hasCloseButton: InputSignal<boolean>;
+    readonly $isEnableFadeAnimation: InputSignal<boolean>;
+    protected readonly $iconClose: ModelSignal<AppIcon | undefined>;
+    protected readonly $animationParams: WritableSignal<UiPopupAnimation>;
+    protected readonly destroyAnimationOrigin$: Subject<void>;
+    constructor(popupInstance: UiPopupInstance, destroyRef: DestroyRef, popupService: UiPopupService, elementRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    protected close(): void;
+    protected onAnimationDone(): void;
+    protected shouldClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiPopupContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiPopupContainerDirective, "app-ui-popup-container", never, { "$overflowHidden": { "alias": "$overflowHidden"; "required": false; "isSignal": true; }; "$shouldClose": { "alias": "$shouldClose"; "required": false; "isSignal": true; }; "$hasCloseButton": { "alias": "$hasCloseButton"; "required": false; "isSignal": true; }; "$isEnableFadeAnimation": { "alias": "$isEnableFadeAnimation"; "required": false; "isSignal": true; }; "$iconClose": { "alias": "$iconClose"; "required": false; "isSignal": true; }; }, { "$shouldClose": "$shouldCloseChange"; "$iconClose": "$iconCloseChange"; }, never, never, true, never>;
+}
+
+declare abstract class UiDropdownContainerDirective extends UiPopupContainerDirective implements AfterViewInit, OnInit {
+    private dropDownService;
+    private readonly renderer;
+    protected readonly $width: WritableSignal<string>;
+    private readonly $contentWrapper;
+    private readonly $swipeButton;
+    protected $animationParams: WritableSignal<UiPopupAnimation>;
+    constructor(dropDownService: UiDropdownService, popupInstance: UiPopupInstance, destroyRef: DestroyRef, elementRef: ElementRef<HTMLElement>, renderer: Renderer2);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private initTouchEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiDropdownContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiDropdownContainerDirective, "app-ui-drop-down-container", never, {}, {}, never, never, true, never>;
+}
+
+declare class HoverTipDirective implements AfterViewInit {
+    private readonly hostRef;
+    private readonly uiDropdownService;
+    private readonly destroyRef;
+    private static instanceCounter;
+    readonly $text: InputSignal<string>;
+    readonly $debounceTime: InputSignal<number>;
+    readonly $position: InputSignal<DropdownPosition>;
+    readonly $offsetX: InputSignal<number>;
+    readonly $offsetY: InputSignal<number>;
+    private readonly tipId;
+    private isOpen;
+    constructor(hostRef: ElementRef<HTMLElement>, uiDropdownService: UiDropdownService, destroyRef: DestroyRef);
+    ngAfterViewInit(): void;
+    private openTip;
+    private closeTip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HoverTipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HoverTipDirective, "[appHoverTip]", never, { "$text": { "alias": "appHoverTip"; "required": true; "isSignal": true; }; "$debounceTime": { "alias": "$debounceTime"; "required": false; "isSignal": true; }; "$position": { "alias": "appHoverTipPosition"; "required": false; "isSignal": true; }; "$offsetX": { "alias": "appHoverTipOffsetX"; "required": false; "isSignal": true; }; "$offsetY": { "alias": "appHoverTipOffsetY"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class UiImageDirective implements OnInit {
+    readonly $src: InputSignal<string>;
+    protected readonly $maxWidth: InputSignal<number>;
+    protected readonly $maxHeight: InputSignal<number>;
+    protected readonly $canShowImage: WritableSignal<boolean>;
+    protected readonly $imageWidth: WritableSignal<number>;
+    protected readonly $imageHeight: WritableSignal<number>;
+    ngOnInit(): void;
+    private setSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiImageDirective, "app-ui-image", never, { "$src": { "alias": "$src"; "required": true; "isSignal": true; }; "$maxWidth": { "alias": "$maxWidth"; "required": false; "isSignal": true; }; "$maxHeight": { "alias": "$maxHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class UiPaginationDirective {
+    readonly $hasNext: InputSignal<boolean>;
+    readonly $hasPrevious: InputSignal<boolean>;
+    readonly $nextClicked: OutputEmitterRef<void>;
+    readonly $previousClicked: OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiPaginationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiPaginationDirective, "app-ui-pagination", never, { "$hasNext": { "alias": "$hasNext"; "required": true; "isSignal": true; }; "$hasPrevious": { "alias": "$hasPrevious"; "required": true; "isSignal": true; }; }, { "$nextClicked": "$nextClicked"; "$previousClicked": "$previousClicked"; }, never, never, true, never>;
+}
+
+declare abstract class UiPopupImageDirective implements OnInit, AfterViewInit {
+    private destroyRef;
+    readonly src: string;
+    readonly width: number;
+    readonly height: number;
+    protected readonly $imageWidth: i0.WritableSignal<number>;
+    protected readonly $imageHeight: i0.WritableSignal<number>;
+    protected readonly $imageStyleTransform: i0.WritableSignal<string>;
+    protected readonly $container: i0.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected readonly $image: i0.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected readonly $cursor: i0.WritableSignal<string>;
+    private isDragging;
+    private isTouchDragging;
+    private isPinching;
+    private lastTouchX;
+    private lastTouchY;
+    private lastTouchDistance;
+    private size;
+    private speed;
+    private readonly pos;
+    private readonly target;
+    private readonly pointer;
+    private scale;
+    constructor(destroyRef: DestroyRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiPopupImageDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiPopupImageDirective, "app-ui-popup-image", never, { "src": { "alias": "src"; "required": true; }; "width": { "alias": "width"; "required": true; }; "height": { "alias": "height"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+type ButtonColor = 'primary' | 'secondary' | 'tertiary' | 'quaternary' | 'success' | 'warning' | 'info' | 'danger';
+type SizeBehavior = 'block' | 'padding';
+type ButtonSizes = 'medium' | 'small';
+declare abstract class UiButtonDirective {
+    protected readonly elementRef: ElementRef<HTMLButtonElement>;
+    protected readonly renderer: Renderer2;
+    readonly $color: InputSignal<ButtonColor>;
+    readonly $isOutlined: InputSignal<boolean>;
+    readonly $isRounded: InputSignal<boolean>;
+    readonly $sizeBehavior: InputSignal<SizeBehavior>;
+    readonly $size: InputSignal<ButtonSizes>;
+    readonly $isDisabled: InputSignal<boolean>;
+    readonly $isLoading: InputSignal<boolean>;
+    constructor(elementRef: ElementRef<HTMLButtonElement>, renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiButtonDirective, "app-ui-button", never, { "$color": { "alias": "$color"; "required": true; "isSignal": true; }; "$isOutlined": { "alias": "$isOutlined"; "required": false; "isSignal": true; }; "$isRounded": { "alias": "$isRounded"; "required": false; "isSignal": true; }; "$sizeBehavior": { "alias": "$sizeBehavior"; "required": false; "isSignal": true; }; "$size": { "alias": "$size"; "required": false; "isSignal": true; }; "$isDisabled": { "alias": "$isDisabled"; "required": false; "isSignal": true; }; "$isLoading": { "alias": "$isLoading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface UiSelectButton {
+    id: string;
+    label?: string;
+    iconLeft?: AppIcon;
+    iconRight?: AppIcon;
+}
+type UiSelectButtonAlignment = 'justified' | 'vertical' | 'left';
+type OverflowMode = 'scroll' | 'wrap';
+
+declare class UiSelectButtonsDirective implements OnInit, AfterViewInit {
+    private readonly renderer;
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    private readonly destroyRef;
+    private readonly platformId;
+    readonly $buttons: InputSignal<UiSelectButton[]>;
+    readonly $selectedButtonIndex: WritableSignal<number>;
+    readonly $alignment: InputSignal<'justified' | 'vertical' | 'left'>;
+    readonly $overflowMode: InputSignal<OverflowMode>;
+    readonly $buttonChanged: OutputEmitterRef<number>;
+    protected readonly $isScrollable: WritableSignal<boolean>;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>, destroyRef: DestroyRef, platformId: object);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    protected select(index: number): void;
+    private checkScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiSelectButtonsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiSelectButtonsDirective, "app-ui-select-buttons", never, { "$buttons": { "alias": "$buttons"; "required": true; "isSignal": true; }; "$alignment": { "alias": "$alignment"; "required": false; "isSignal": true; }; "$overflowMode": { "alias": "$overflowMode"; "required": false; "isSignal": true; }; }, { "$buttonChanged": "$buttonChanged"; }, never, never, true, never>;
+}
+
+declare abstract class UiCopyButtonDirective {
+    private readonly destroyRef;
+    readonly $text: InputSignal<string>;
+    protected readonly $isCopied: WritableSignal<boolean>;
+    private readonly destroyTimer$;
+    constructor(destroyRef: DestroyRef);
+    protected copy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiCopyButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiCopyButtonDirective, "app-ui-copy-button", never, { "$text": { "alias": "$text"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface UiTab extends UiSelectButton {
+    template?: TemplateRef<HTMLElement>;
+}
+type TabsAlignment = UiSelectButtonAlignment | 'right' | 'vertical-reverse';
+
+declare class UiTabsDirective implements OnInit {
+    protected readonly renderer: Renderer2;
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    readonly $tabs: ModelSignal<UiTab[]>;
+    readonly $alignment: InputSignal<TabsAlignment>;
+    readonly $selectedTabIndex: ModelSignal<number>;
+    protected readonly $templates: Signal<readonly TemplateRef<HTMLElement>[]>;
+    protected readonly $headContent: Signal<TemplateRef<HTMLElement> | undefined>;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiTabsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiTabsDirective, "[appUiTabs]", ["uiTabs"], { "$tabs": { "alias": "$tabs"; "required": true; "isSignal": true; }; "$alignment": { "alias": "$alignment"; "required": false; "isSignal": true; }; "$selectedTabIndex": { "alias": "$selectedTabIndex"; "required": false; "isSignal": true; }; }, { "$tabs": "$tabsChange"; "$selectedTabIndex": "$selectedTabIndexChange"; }, ["$templates", "$headContent"], never, true, never>;
+}
+
+type ValidationErrorsType = WithOptionalField<ValidationError>;
+declare abstract class UiValidationErrorsDirective {
+    readonly $isError: InputSignal<boolean>;
+    readonly $errors: InputSignal<readonly ValidationErrorsType[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiValidationErrorsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiValidationErrorsDirective, "app-ui-validation-errors", never, { "$isError": { "alias": "$isError"; "required": false; "isSignal": true; }; "$errors": { "alias": "$errors"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class UiFieldBaseDirective<T> implements FormValueControl<T | null>, OnInit {
+    readonly value: ModelSignal<T | null>;
+    readonly disabled: InputSignal<boolean>;
+    readonly invalid: InputSignal<boolean>;
+    readonly errors: InputSignal<readonly ValidationErrorsType[]>;
+    readonly touched: ModelSignal<boolean>;
+    readonly dirty: ModelSignal<boolean>;
+    private initialValue;
+    ngOnInit(): void;
+    protected onInput(value: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiFieldBaseDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiFieldBaseDirective<any>, "app-ui-field-base", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "invalid": "invalidChange"; "touched": "touchedChange"; "dirty": "dirtyChange"; }, never, never, true, never>;
+}
+
+type CheckboxStyles = 'primary' | 'success' | 'warning' | 'info' | 'danger';
+declare abstract class UiInputCheckboxDirective implements FormCheckboxControl {
+    readonly checked: ModelSignal<boolean>;
+    readonly invalid: InputSignal<boolean>;
+    readonly disabled: InputSignal<boolean>;
+    readonly $style: InputSignal<CheckboxStyles>;
+    readonly $label: InputSignal<string>;
+    readonly $hideValidatorErrors: InputSignal<boolean>;
+    readonly errors: InputSignal<readonly ValidationErrorsType[]>;
+    readonly touched: ModelSignal<boolean>;
+    readonly dirty: ModelSignal<boolean>;
+    protected readonly $isError: Signal<boolean>;
+    change(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiInputCheckboxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiInputCheckboxDirective, "app-ui-input", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "$style": { "alias": "$style"; "required": false; "isSignal": true; }; "$label": { "alias": "$label"; "required": false; "isSignal": true; }; "$hideValidatorErrors": { "alias": "$hideValidatorErrors"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "invalid": "invalidChange"; "touched": "touchedChange"; "dirty": "dirtyChange"; }, never, never, true, never>;
+}
+
+interface LayoutSize {
+    padding: string;
+    font: string;
+    borderRadius: string;
+}
+type Size = 'small' | 'medium';
+declare abstract class UiInputDirective extends UiFieldBaseDirective<string> {
+    readonly $size: InputSignal<Size>;
+    readonly $placeholder: InputSignal<string>;
+    readonly $label: InputSignal<string>;
+    readonly $shouldFocusedAfterViewInit: InputSignal<boolean>;
+    readonly $hideValidatorErrors: InputSignal<boolean>;
+    readonly $icon: InputSignal<AppIcon | null>;
+    protected readonly $layoutSize: Signal<LayoutSize>;
+    protected readonly $isError: Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiInputDirective, "app-ui-input", never, { "$size": { "alias": "$size"; "required": false; "isSignal": true; }; "$placeholder": { "alias": "$placeholder"; "required": false; "isSignal": true; }; "$label": { "alias": "$label"; "required": false; "isSignal": true; }; "$shouldFocusedAfterViewInit": { "alias": "$shouldFocusedAfterViewInit"; "required": false; "isSignal": true; }; "$hideValidatorErrors": { "alias": "$hideValidatorErrors"; "required": false; "isSignal": true; }; "$icon": { "alias": "$icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class UiInputCountryDirective extends UiInputDirective implements AfterViewInit {
+    protected $selectedCountry: WritableSignal<CountryData>;
+    protected $isOpen: WritableSignal<boolean>;
+    private $inputElement;
+    constructor();
+    ngAfterViewInit(): void;
+    protected onPaste(event: ClipboardEvent): void;
+    private searchCountry;
+    protected setCountry(country: CountryData): void;
+    protected autoSetCountry(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiInputCountryDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiInputCountryDirective, "app-ui-input-country", never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class UIInputDateDirective extends UiInputDirective {
+    protected readonly $isOpen: WritableSignal<boolean>;
+    readonly $isRangeSelection: InputSignal<boolean>;
+    private $inputElement;
+    protected setDate(date: Date): void;
+    private formatDate;
+    protected isUsaDateFormat(): boolean;
+    protected setRangeDates(dates: {
+        start: Date | null;
+        end: Date | null;
+    }): void;
+    onInput(value: string): void;
+    private maskDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UIInputDateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UIInputDateDirective, "app-ui-input-date", never, { "$isRangeSelection": { "alias": "$isRangeSelection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class UIPhoneNumberDirective extends UiInputDirective implements AfterViewInit {
+    protected $selectedCountry: WritableSignal<CountryData>;
+    protected $isOpen: WritableSignal<boolean>;
+    protected $countryCode: WritableSignal<string>;
+    private $inputElement;
+    constructor();
+    ngAfterViewInit(): void;
+    protected onInput(value: string): void;
+    protected onPaste(event: ClipboardEvent): void;
+    protected setCountry(country: CountryData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UIPhoneNumberDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UIPhoneNumberDirective, "app-ui-input-phone-number", never, {}, {}, never, never, true, never>;
+}
+
+interface InputSelectData {
+    value: string;
+    ico?: AppIcon;
+}
+declare abstract class UiInputSelectDirective extends UiInputDirective {
+    readonly $items: InputSignal<InputSelectData[]>;
+    protected readonly $isOpen: WritableSignal<boolean>;
+    protected readonly $selectedValue: WritableSignal<InputSelectData>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiInputSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiInputSelectDirective, "app-ui-select", never, { "$items": { "alias": "$items"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class UiInputSequenceDirective extends UiInputDirective {
+    $numberCells: InputSignal<number>;
+    protected $inputs: Signal<string[]>;
+    private inputRefs;
+    protected onInputSequence(event: Event, index: number): void;
+    protected onClick(event: MouseEvent | FocusEvent): void;
+    protected onKeyDown(event: KeyboardEvent, index: number): void;
+    private focusInput;
+    protected onPaste(event: ClipboardEvent, index: number): void;
+    private setValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiInputSequenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiInputSequenceDirective, "app-ui-sequence", never, { "$numberCells": { "alias": "$numberCells"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class UiInputTimeDirective extends UiInputDirective {
+    protected readonly times: string[];
+    private $inputElement;
+    protected readonly $isOpen: WritableSignal<boolean>;
+    onInput(value: string): void;
+    maskTime(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiInputTimeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<UiInputTimeDirective, "app-ui-input-time", never, {}, {}, never, never, true, never>;
+}
+
+export { Alert, AlertType, AppIconsLibrary, AutoFocusDirective, CenterEllipsisPipe, CountryService, DateUtils, EMAIL, HAS_CAPITAL_CASE, HAS_NUMBER, HAS_SMALL_CASE, HAS_SPECIAL_CHARTERS, HoverTipDirective, IconComponent, LazyImgDirective, MIN_LENGTH, MaskGradientDirective, StickyObserverDirective, ThemeService, TrackLifecycleDirective, UIInputDateDirective, UIPhoneNumberDirective, UiAccordionComponent, UiAlertMessagesService, UiAvatarDirective, UiButtonDirective, UiCodeDirective, UiCopyButtonDirective, UiDailyCalendarDirective, UiDropdownContainerDirective, UiDropdownService, UiFieldBaseDirective, UiImageDirective, UiInputCheckboxDirective, UiInputCountryDirective, UiInputDirective, UiInputSelectDirective, UiInputSequenceDirective, UiInputTimeDirective, UiMonthlyCalendarDirective, UiPaginationDirective, UiPopupContainerDirective, UiPopupImageDirective, UiPopupInstance, UiPopupService, UiSelectButtonsDirective, UiTabsDirective, UiValidationErrorsDirective, UiYearlyCalendarDirective, emptyCountry, getAspectRatioFit, stringToHslColor };
+export type { AlertParams, AppIcon, AppIconName, ButtonColor, CalendarDay, CalendarMonthItem, CalendarYearItem, CheckboxStyles, CountryData, DropdownItem, DropdownParameters, DropdownPosition, InputSelectData, NavigationEvent, OverflowMode, PopupAnimationOptions, RawSVG, TabsAlignment, UiPopupAnimation, UiPopupOptions, UiPopupParameters, UiSelectButton, UiSelectButtonAlignment, UiTab, ValidationErrorsType };