@tacdaed/fragments 1.0.0-beta.2 → 1.0.0-beta.20

package/index.d.ts

@@ -0,0 +1,4619 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, OnChanges, EventEmitter, QueryList, ElementRef, SimpleChanges, OnDestroy, Type, AfterViewInit, OnInit, PipeTransform } from '@angular/core';
+import { FormControl, AbstractControl, ControlValueAccessor, NgControl } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { ActivatedRoute } from '@angular/router';
+import { AnimationParams, TargetsParam, JSAnimation, AnimatableParams, AnimatableObject, DraggableParams, Draggable, DOMTargetSelector, AutoLayoutParams, AutoLayout, ScopeParams, Scope, TimelineParams, Timeline, TimerParams, Timer, TextSplitterParams, TextSplitter, Tickable } from 'animejs';
+
+type TBaseStyle = 'default' | 'primary' | 'secondary' | 'tertiary' | 'dark' | 'light' | 'info' | 'success' | 'warning' | 'danger' | 'outline-primary' | 'outline-secondary' | 'outline-tertiary' | 'outline-dark' | 'outline-light' | 'outline-info' | 'outline-success' | 'outline-warning' | 'outline-danger';
+type TBaseSize = 'small' | 'medium' | 'large';
+type TBasePosition = 'top' | 'left' | 'right' | 'bottom';
+
+type TAccordionStyle = TBaseStyle;
+type TAccordionSize = TBaseSize;
+interface AccordionItemContext<T = unknown> {
+    $implicit: AccordionItem<T>;
+    item: AccordionItem<T>;
+    index: number;
+    expanded: boolean;
+    toggle: () => void;
+}
+interface AccordionItem<T = unknown> {
+    /**
+     * Unique identifier for the accordion item.
+     * If not provided, it will be generated automatically.
+     */
+    id?: string;
+    /**
+     * Visible title inside the header.
+     */
+    title: string;
+    /**
+     * Optional subtitle rendered below the title in the default header.
+     */
+    subtitle?: string;
+    /**
+     * Prevents interaction when true.
+     */
+    disabled?: boolean;
+    /**
+     * Allows setting initial expansion per item.
+     */
+    expanded?: boolean;
+    /**
+     * Optional style override using the shared palette.
+     */
+    style?: TAccordionStyle;
+    /**
+     * Optional size override for the item header.
+     */
+    size?: TAccordionSize;
+    /**
+     * Optional icon rendered on the left of the header when no custom template is provided.
+     * Typically a CSS class (e.g., for an icon font) or plain text.
+     */
+    icon?: string;
+    /**
+     * Custom icon template for this item only.
+     */
+    iconTemplate?: TemplateRef<AccordionItemContext<T>>;
+    /**
+     * Custom toggle icon template for this item only (replaces the default chevron).
+     */
+    toggleIconTemplate?: TemplateRef<AccordionItemContext<T>>;
+    /**
+     * Arbitrary data that can be passed to templates for custom rendering.
+     */
+    data?: T;
+    /**
+     * Optional plain content for quick rendering when no template is provided.
+     */
+    content?: string;
+    /**
+     * Custom header template for this item only.
+     */
+    headerTemplate?: TemplateRef<AccordionItemContext<T>>;
+    /**
+     * Custom body template for this item only.
+     */
+    contentTemplate?: TemplateRef<AccordionItemContext<T>>;
+}
+interface AccordionToggleEvent<T = unknown> {
+    id: string;
+    index: number;
+    expanded: boolean;
+    item: AccordionItem<T>;
+    expandedIds: string[];
+}
+
+declare class AccordionComponent implements OnChanges {
+    items: AccordionItem[];
+    expandedIds: string[];
+    multi: boolean;
+    styleType: TAccordionStyle;
+    size: TAccordionSize;
+    toggleOnHeaderClick: boolean;
+    animated: boolean;
+    focusPanelOnOpen: boolean;
+    expandedIdsChange: EventEmitter<string[]>;
+    toggled: EventEmitter<AccordionToggleEvent<unknown>>;
+    opened: EventEmitter<AccordionToggleEvent<unknown>>;
+    closed: EventEmitter<AccordionToggleEvent<unknown>>;
+    headerTemplate?: TemplateRef<AccordionItemContext>;
+    contentTemplate?: TemplateRef<AccordionItemContext>;
+    iconTemplate?: TemplateRef<AccordionItemContext>;
+    toggleIconTemplate?: TemplateRef<AccordionItemContext>;
+    headerButtons: QueryList<ElementRef<HTMLButtonElement>>;
+    panelBodies: QueryList<ElementRef<HTMLElement>>;
+    viewItems: AccordionItem[];
+    private uidCounter;
+    ngOnChanges(changes: SimpleChanges): void;
+    isExpanded(id?: string): boolean;
+    headerId(id: string): string;
+    panelId(id: string): string;
+    onHeaderClick(index: number, event: Event): void;
+    onHeaderKeydown(event: KeyboardEvent, index: number): void;
+    toggleAt(index: number): void;
+    buildContext<T = unknown>(item: AccordionItem<T>, index: number): AccordionItemContext<T>;
+    private normalizeItems;
+    private generateId;
+    private expandSingle;
+    private collapseSingle;
+    private expandMulti;
+    private collapseMulti;
+    private setExpandedIds;
+    private focusPanel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AccordionComponent, "frg-accordion", never, { "items": { "alias": "items"; "required": false; }; "expandedIds": { "alias": "expandedIds"; "required": false; }; "multi": { "alias": "multi"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "size": { "alias": "size"; "required": false; }; "toggleOnHeaderClick": { "alias": "toggleOnHeaderClick"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; "focusPanelOnOpen": { "alias": "focusPanelOnOpen"; "required": false; }; }, { "expandedIdsChange": "expandedIdsChange"; "toggled": "toggled"; "opened": "opened"; "closed": "closed"; }, ["headerTemplate", "contentTemplate", "iconTemplate", "toggleIconTemplate"], never, true, never>;
+}
+
+type TButtonType = 'button' | 'reset' | 'submit';
+type TButtonStyle = TBaseStyle | 'ghost' | 'icon' | 'neutral';
+type TButtonSize = TBaseSize;
+type TButtonIconPosition = TBasePosition;
+type TButtonShape = 'default' | 'pill';
+
+/**
+ * Button component for displaying a button with various styles and behaviors
+ */
+declare class ButtonComponent {
+    /**
+     * Unique identifier for the button
+     */
+    id: string;
+    /**
+     * CSS classes applied to the button element
+     */
+    class: string;
+    /**
+     * CSS classes for the text span
+     */
+    textClass: string;
+    /**
+     * CSS classes for the icon element
+     */
+    iconClass: string;
+    /**
+     * Optional style token for icon color
+     */
+    iconStyleType: TBaseStyle | undefined;
+    /**
+     * Position of the icon relative to the text
+     * @see TButtonIconPosition
+     */
+    iconPosition: TButtonIconPosition;
+    /**
+     * Type of the button
+     * @see TButtonType
+     */
+    type: TButtonType;
+    /**
+     * Size of the button
+     * @see TButtonSize
+     */
+    size: TButtonSize;
+    /**
+     * Router link for navigation
+     */
+    buttonRouterLink: string | (string | number)[] | null | undefined;
+    /**
+     * CSS classes applied when the button is active
+     */
+    buttonRouterLinkActive: string | string[];
+    /**
+     * Determines whether the button is disabled
+     */
+    disabled: boolean | null;
+    /**
+     * Style type of the button
+     * @see TButtonStyle
+     */
+    styleType: TButtonStyle;
+    /**
+     * Shape of the button.
+     * @see TButtonShape
+     */
+    shape: TButtonShape;
+    /**
+     * Text content of the button
+     */
+    text: string;
+    /**
+     * Accessible label for icon-only buttons
+     */
+    ariaLabel: string;
+    /**
+     * Emits when the button is clicked
+     */
+    clickEvent: EventEmitter<void>;
+    /**
+     * CSS classes applied to the container element based on its position
+     * @see TButtonStyle
+     */
+    get containerNgClass(): {
+        'flex-column-reverse': boolean;
+        'flex-row-reverse': boolean;
+        'flex-row': boolean;
+        'flex-column': boolean;
+    };
+    /**
+     * CSS classes applied to the icon element based on its position
+     * @see TButtonIconPosition
+     */
+    get iconNgClass(): {
+        'mb-2': boolean;
+        'me-2': boolean;
+        'ms-2': boolean;
+        'mt-2': boolean;
+    };
+    /**
+     * Combined classes for icon color + spacing
+     */
+    get iconClassMap(): {
+        'mb-2'?: boolean | undefined;
+        'me-2'?: boolean | undefined;
+        'ms-2'?: boolean | undefined;
+        'mt-2'?: boolean | undefined;
+        'frg-btn__icon-primary': boolean;
+        'frg-btn__icon-secondary': boolean;
+        'frg-btn__icon-tertiary': boolean;
+        'frg-btn__icon-info': boolean;
+        'frg-btn__icon-success': boolean;
+        'frg-btn__icon-warning': boolean;
+        'frg-btn__icon-danger': boolean;
+        'frg-btn__icon-dark': boolean;
+        'frg-btn__icon-light': boolean;
+        'frg-btn__icon-pill': boolean;
+    };
+    /**
+     * Emits when the button is clicked
+     */
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "frg-button", never, { "id": { "alias": "id"; "required": false; }; "class": { "alias": "class"; "required": false; }; "textClass": { "alias": "textClass"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "iconStyleType": { "alias": "iconStyleType"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "buttonRouterLink": { "alias": "buttonRouterLink"; "required": false; }; "buttonRouterLinkActive": { "alias": "buttonRouterLinkActive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "text": { "alias": "text"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "clickEvent": "clickEvent"; }, never, never, true, never>;
+}
+
+type TCardStyle = TBaseStyle;
+
+declare class CardComponent {
+    styleType: TCardStyle;
+    hasCloseCard: boolean;
+    closeCard: EventEmitter<void>;
+    isClosed: boolean;
+    onCloseCard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "frg-card", never, { "styleType": { "alias": "styleType"; "required": false; }; "hasCloseCard": { "alias": "hasCloseCard"; "required": false; }; }, { "closeCard": "closeCard"; }, never, ["[frg-card-head]", "[frg-card-body]", "[frg-card-footer]"], true, never>;
+}
+
+type TModalSize = TBaseSize;
+type TModalCloseReason = 'backdrop' | 'close-button' | 'escape';
+interface ModalCloseEvent {
+    reason: TModalCloseReason;
+}
+
+declare class ModalComponent implements OnChanges, OnDestroy {
+    open: boolean;
+    size: TModalSize;
+    closeOnBackdrop: boolean;
+    closeOnEscape: boolean;
+    hasCloseButton: boolean;
+    hasHeader: boolean;
+    hasFooter: boolean;
+    lockBodyScroll: boolean;
+    ariaLabel: string;
+    ariaLabelledBy: string | null;
+    ariaDescribedBy: string | null;
+    closed: EventEmitter<ModalCloseEvent>;
+    get modalClassMap(): {
+        'frg-modal__size-small': boolean;
+        'frg-modal__size-medium': boolean;
+        'frg-modal__size-large': boolean;
+    };
+    get showHeader(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    protected onBackdropClick(): void;
+    protected onCloseClick(): void;
+    onKeydown(event: KeyboardEvent): void;
+    private requestClose;
+    private toggleBodyScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "frg-modal", never, { "open": { "alias": "open"; "required": false; }; "size": { "alias": "size"; "required": false; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; "hasCloseButton": { "alias": "hasCloseButton"; "required": false; }; "hasHeader": { "alias": "hasHeader"; "required": false; }; "hasFooter": { "alias": "hasFooter"; "required": false; }; "lockBodyScroll": { "alias": "lockBodyScroll"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; }; }, { "closed": "closed"; }, never, ["[frg-modal-head]", "[frg-modal-body]", "[frg-modal-footer]"], true, never>;
+}
+
+type TToastStyle = Exclude<TBaseStyle, 'outline-primary' | 'outline-secondary' | 'outline-tertiary' | 'outline-dark' | 'outline-light' | 'outline-info' | 'outline-success' | 'outline-warning' | 'outline-danger'>;
+type TToastPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+type TToastCloseReason = 'close-button' | 'timeout' | 'programmatic';
+type TToastSize = TBaseSize;
+interface ToastCloseEvent {
+    reason: TToastCloseReason;
+}
+interface ToastStackItem {
+    id: string;
+    title?: string;
+    message?: string;
+    styleType?: TToastStyle;
+    size?: TToastSize;
+    autoClose?: boolean;
+    duration?: number;
+    hasCloseButton?: boolean;
+    ariaLabel?: string;
+}
+interface ToastStackCloseEvent extends ToastCloseEvent {
+    id: string;
+}
+
+declare class ToastComponent implements OnChanges, OnDestroy {
+    open: boolean;
+    title: string;
+    message: string;
+    styleType: TToastStyle;
+    position: TToastPosition;
+    size: TToastSize;
+    autoClose: boolean;
+    duration: number;
+    hasCloseButton: boolean;
+    stacked: boolean;
+    closing: boolean;
+    motionDuration: number;
+    ariaLabel: string;
+    closed: EventEmitter<ToastCloseEvent>;
+    private closeTimerId;
+    private enterTimerId;
+    private leaveTimerId;
+    protected isRendered: boolean;
+    protected isEntering: boolean;
+    protected isClosing: boolean;
+    get statusIconClass(): string | null;
+    get toastClassMap(): {
+        'frg-toast--stacked': boolean;
+        'frg-toast--top-left': boolean;
+        'frg-toast--top-right': boolean;
+        'frg-toast--bottom-left': boolean;
+        'frg-toast--bottom-right': boolean;
+        'frg-toast--size-small': boolean;
+        'frg-toast--size-medium': boolean;
+        'frg-toast--size-large': boolean;
+        'frg-toast--enter': boolean;
+        'frg-toast--leave': boolean;
+        'frg-toast--primary': boolean;
+        'frg-toast--secondary': boolean;
+        'frg-toast--tertiary': boolean;
+        'frg-toast--dark': boolean;
+        'frg-toast--light': boolean;
+        'frg-toast--info': boolean;
+        'frg-toast--success': boolean;
+        'frg-toast--warning': boolean;
+        'frg-toast--danger': boolean;
+        'frg-toast--default': boolean;
+    };
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onCloseClick(): void;
+    private syncAutoClose;
+    private requestClose;
+    private clearCloseTimer;
+    private openToast;
+    private closeToast;
+    private startEnterAnimation;
+    private clearEnterTimer;
+    private clearLeaveTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastComponent, "frg-toast", never, { "open": { "alias": "open"; "required": false; }; "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "hasCloseButton": { "alias": "hasCloseButton"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "closing": { "alias": "closing"; "required": false; }; "motionDuration": { "alias": "motionDuration"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "closed": "closed"; }, never, ["[frg-toast-title]", "[frg-toast-body]", "*"], true, never>;
+}
+
+declare class ToastStackComponent implements OnChanges {
+    toasts: ToastStackItem[];
+    position: TToastPosition;
+    maxVisible: number;
+    motionDuration: number;
+    closed: EventEmitter<ToastStackCloseEvent>;
+    private closingIds;
+    get visibleToasts(): ToastStackItem[];
+    ngOnChanges(changes: SimpleChanges): void;
+    onToastClosed(id: string, event: ToastCloseEvent): void;
+    isClosing(id: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastStackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastStackComponent, "frg-toast-stack", never, { "toasts": { "alias": "toasts"; "required": false; }; "position": { "alias": "position"; "required": false; }; "maxVisible": { "alias": "maxVisible"; "required": false; }; "motionDuration": { "alias": "motionDuration"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+type TSnackbarStyle = Exclude<TBaseStyle, 'outline-primary' | 'outline-secondary' | 'outline-tertiary' | 'outline-dark' | 'outline-light' | 'outline-info' | 'outline-success' | 'outline-warning' | 'outline-danger'>;
+type TSnackbarSize = TBaseSize;
+type TSnackbarPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+type TSnackbarCloseReason = 'close-button' | 'timeout' | 'programmatic' | 'action';
+interface SnackbarCloseEvent {
+    reason: TSnackbarCloseReason;
+}
+
+declare class SnackbarComponent implements OnChanges, OnDestroy {
+    open: boolean;
+    message: string;
+    actionLabel: string;
+    styleType: TSnackbarStyle;
+    position: TSnackbarPosition;
+    size: TSnackbarSize;
+    autoClose: boolean;
+    duration: number;
+    hasCloseButton: boolean;
+    ariaLabel: string;
+    closed: EventEmitter<SnackbarCloseEvent>;
+    action: EventEmitter<void>;
+    private closeTimerId;
+    get statusIconClass(): string | null;
+    get snackbarClassMap(): {
+        'frg-snackbar--top-left': boolean;
+        'frg-snackbar--top-center': boolean;
+        'frg-snackbar--top-right': boolean;
+        'frg-snackbar--bottom-left': boolean;
+        'frg-snackbar--bottom-center': boolean;
+        'frg-snackbar--bottom-right': boolean;
+        'frg-snackbar--size-small': boolean;
+        'frg-snackbar--size-medium': boolean;
+        'frg-snackbar--size-large': boolean;
+        'frg-snackbar--primary': boolean;
+        'frg-snackbar--secondary': boolean;
+        'frg-snackbar--tertiary': boolean;
+        'frg-snackbar--dark': boolean;
+        'frg-snackbar--light': boolean;
+        'frg-snackbar--info': boolean;
+        'frg-snackbar--success': boolean;
+        'frg-snackbar--warning': boolean;
+        'frg-snackbar--danger': boolean;
+        'frg-snackbar--default': boolean;
+    };
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onCloseClick(): void;
+    onActionClick(): void;
+    private syncAutoClose;
+    private requestClose;
+    private clearCloseTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SnackbarComponent, "frg-snackbar", never, { "open": { "alias": "open"; "required": false; }; "message": { "alias": "message"; "required": false; }; "actionLabel": { "alias": "actionLabel"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "position": { "alias": "position"; "required": false; }; "size": { "alias": "size"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "hasCloseButton": { "alias": "hasCloseButton"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "closed": "closed"; "action": "action"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Represents a value that can be used in Angular's `ngClass` directive
+ * to determine whether a class should be applied.
+ * - `boolean`: apply class if true, remove if false
+ * - `number`: treated as truthy if non-zero, falsy if zero
+ * - `string`: directly represents a class name
+ * - `null` or `undefined`: no class applied
+ */
+type NgClassValue = boolean | number | string | null | undefined;
+/**
+ * Describes the different formats supported by a custom implementation
+ * of Angular's `ngClass`. It allows:
+ * - A single class name as a string
+ * - An array of class names
+ * - A Set of class names
+ * - An object map where keys are class names and values determine whether they should be applied
+ * - `null` or `undefined` to apply no classes
+ */
+type TCustomNgClass = string | string[] | Set<string> | {
+    [klass: string]: NgClassValue;
+} | null | undefined;
+/**
+ * Creates a type that removes the properties of `U` from `T`
+ * by marking them as optional and setting their type to `never`.
+ * Useful for constructing mutually exclusive types.
+ */
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+/**
+ * Constructs an exclusive OR (XOR) type between `T` and `U`.
+ * Ensures that either `T` or `U` is allowed, but not both at the same time.
+ * - If both are objects, it enforces mutual exclusivity at the property level.
+ * - If not objects, it falls back to a simple union (`T | U`).
+ */
+type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+/**
+ * Represents a generic function type that takes a single argument of any type
+ * and returns a value of type `T`.
+ *
+ * @template T The return type of the function.
+ */
+type GenericFunction<T> = (arg0: unknown) => T;
+/**
+ * Represents a mutually exclusive type between `T` and `K`.
+ * Only one of the two types can be used at a time.
+ *
+ * @template T The first type option.
+ * @template K The second type option.
+ */
+type TBehaviourAction<T, K> = XOR<T, K>;
+/**
+ * Represents an array that contains at least one element of type `T`.
+ * Ensures that the array is never empty by requiring an element at index 0.
+ *
+ * @template T The type of the elements in the array.
+ */
+type ArrayOneOrMore<T> = {
+    0: T;
+} & Array<T>;
+type DateFormat = "dd/MM/yyyy" | "MM/dd/yyyy" | "yyyy-MM-dd" | "dd-MM-yyyy" | "dd.MM.yyyy" | "yyyy/MM/dd" | "MMM dd, yyyy" | "MMMM dd, yyyy" | "dd MMM yyyy" | "dd MMMM yyyy" | "yyyyMMdd";
+type TimeFormat = "HH:mm:ss" | "HH:mm" | "hh:mm:ss a" | "hh:mm a";
+type DateTimeFormat = "dd/MM/yyyy HH:mm" | "dd/MM/yyyy HH:mm:ss" | "MM/dd/yyyy HH:mm" | "MM/dd/yyyy hh:mm a" | "yyyy-MM-dd'T'HH:mm" | "yyyy-MM-dd'T'HH:mm:ss" | "dd MMM yyyy HH:mm" | "dd MMM yyyy hh:mm a" | "MMMM dd, yyyy HH:mm" | "MMMM dd, yyyy hh:mm a" | "yyyyMMdd HH:mm" | "yyyyMMdd HH:mm:ss";
+type DeepRequired<T> = {
+    [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
+};
+
+type THLJSLanguage = 'html' | 'xml' | 'xhtml' | 'svg' | 'css' | 'scss' | 'less' | 'javascript' | 'typescript' | 'json' | 'markdown' | 'yaml' | 'yml' | 'php' | 'java' | 'python' | 'ruby' | 'c' | 'cpp' | 'csharp' | 'go' | 'rust' | 'kotlin' | 'perl' | 'swift' | 'dart' | 'scala' | 'haskell' | 'erlang' | 'bash' | 'shell' | 'powershell' | 'docker' | 'makefile' | 'git' | 'ini' | 'toml' | 'sql' | 'graphql' | 'json5' | 'text' | 'diff' | 'http' | 'nginx' | 'apache' | 'log' | 'env';
+type TextContent = {
+    type: 'text';
+    content: string;
+    language?: THLJSLanguage;
+    highlightLines?: string;
+    hasNumberLine?: boolean;
+};
+type ComponentContent<T = unknown, I extends Record<string, unknown> = Record<string, unknown>> = {
+    type: 'component';
+    component: Type<T>;
+    inputs?: I;
+};
+type CodeBlockBody<T = unknown, I extends Record<string, unknown> = Record<string, unknown>> = XOR<TextContent, ComponentContent<T, I>>;
+
+/**
+ * Configuration options for the code block component.
+ */
+interface CodeBlockConfig {
+    id?: string;
+    header?: CodeBlockHeader;
+    body?: CodeBlockBody;
+    footer?: CodeBlockFooter;
+}
+/**
+ * Configuration options for the code block header.
+ */
+interface CodeBlockHeader {
+    title?: string;
+    showCopy?: boolean;
+    copyLabel?: string;
+    copiedLabel?: string;
+}
+/**
+ * Configuration options for the code block footer.
+ */
+interface CodeBlockFooter {
+    text?: string;
+}
+
+declare class CodeBlockComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly cdr;
+    /**
+     * Configuration options for the code block.
+     */
+    config: CodeBlockConfig | undefined;
+    /**
+     * Emitted when the code block is closed.
+     */
+    closed: EventEmitter<void>;
+    protected copied: boolean;
+    private copyResetId;
+    /**
+     * Reference to the code element in the template.
+     */
+    codeElement?: ElementRef<HTMLElement>;
+    /**
+     * Reference to the container element in the template.
+     */
+    containerElement?: ElementRef<HTMLElement>;
+    /**
+     * Indicates if the code block has a footer.
+     */
+    protected get hasConfig(): boolean;
+    /**
+     * Returns the header configuration of the code block.
+     * This includes properties like title, minimize, fullscreen, and close options.
+     * @return {CodeBlockHeader | undefined} The header configuration or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get header(): CodeBlockHeader | undefined;
+    /**
+     * Returns the body of the code block, which can be either text or a component.
+     * @return {CodeBlockBody | undefined} The body configuration or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get title(): string | undefined;
+    /**
+     * Returns the body configuration of the code block.
+     * This includes properties like content and language.
+     * @return {CodeBlockBody | undefined} The body configuration or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get body(): CodeBlockBody | undefined;
+    /**
+     * Returns the type of content in the body of the code block.
+     * This can be either 'text' for plain text content or 'component' for a component.
+     * @return {'text' | 'component' | undefined} The type of content or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get type(): 'text' | 'component' | undefined;
+    /**
+     * Returns the component type in the body of the code block.
+     * @return {Type<T> | undefined} The component type or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get component(): Type<unknown> | undefined;
+    /**
+     * Returns the inputs for the component in the body of the code block.
+     * @return {Record<string, unknown> | undefined} The inputs or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get inputs(): Record<string, unknown> | undefined;
+    /**
+     * Returns the content for the code block.
+     * @return {string | undefined} The content or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get content(): string | undefined;
+    /**
+     * Returns the programming language for the code block.
+     * @return {THLJSLanguage | undefined} The language or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get language(): THLJSLanguage | undefined;
+    /**
+     * Returns the lines to highlight in the code block.
+     * @return {string | undefined} The highlight lines or undefined if not set.
+     * @memberof CodeBlockComponent
+     */
+    protected get highlightLines(): string | undefined;
+    protected get showCopyButton(): boolean;
+    protected get copyLabel(): string;
+    protected get copiedLabel(): string;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    protected copyToClipboard(): void;
+    /**
+     * Highlights the code in the code block.
+     * This method uses the highlight.js library to apply syntax highlighting.
+     */
+    private highlightCode;
+    private getCopyContent;
+    private fallbackCopy;
+    /**
+     * Dedents a given string by removing common leading whitespace.
+     * @param str The input string to dedent.
+     * @returns The dedented string.
+     */
+    private dedent;
+    private readonly addNumberLines;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeBlockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CodeBlockComponent, "frg-code-block", never, { "config": { "alias": "config"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    url?: string | (string | number)[];
+    iconClass?: string;
+    ariaLabel?: string;
+    isActive?: boolean;
+}
+
+declare class BreadcrumbComponent implements OnInit, OnDestroy {
+    private readonly router;
+    private readonly activatedRoute;
+    /**
+     * Breadcrumb items to render.
+     */
+    items: BreadcrumbItem[];
+    /**
+     * Build breadcrumbs automatically from the current route tree.
+     */
+    auto: boolean;
+    /**
+     * Separator displayed between breadcrumb items.
+     */
+    separator: string;
+    /**
+     * Color theme for breadcrumb text.
+     */
+    styleType: TBaseStyle;
+    protected autoItems: BreadcrumbItem[];
+    private readonly destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get breadcrumbItems(): BreadcrumbItem[];
+    private buildAutoItems;
+    private resolveLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "frg-breadcrumb", never, { "items": { "alias": "items"; "required": false; }; "auto": { "alias": "auto"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TContainerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+
+declare class ContainerComponent {
+    size: TContainerSize;
+    padded: boolean;
+    baseClass: boolean;
+    get isSmall(): boolean;
+    get isMedium(): boolean;
+    get isLarge(): boolean;
+    get isXLarge(): boolean;
+    get isFull(): boolean;
+    get isPadded(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContainerComponent, "frg-container", never, { "size": { "alias": "size"; "required": false; }; "padded": { "alias": "padded"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+type TDividerOrientation = 'horizontal' | 'vertical';
+type TDividerSpacing = 'sm' | 'md' | 'lg';
+
+declare class DividerComponent {
+    orientation: TDividerOrientation;
+    spacing: TDividerSpacing;
+    dashed: boolean;
+    baseClass: boolean;
+    get isHorizontal(): boolean;
+    get isVertical(): boolean;
+    get isSmall(): boolean;
+    get isMedium(): boolean;
+    get isLarge(): boolean;
+    get isDashed(): boolean;
+    role: string;
+    get ariaOrientation(): TDividerOrientation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DividerComponent, "frg-divider", never, { "orientation": { "alias": "orientation"; "required": false; }; "spacing": { "alias": "spacing"; "required": false; }; "dashed": { "alias": "dashed"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TSeparatorSize = 'sm' | 'md' | 'lg';
+
+declare class SeparatorComponent {
+    label?: string;
+    size: TSeparatorSize;
+    baseClass: boolean;
+    get isSmall(): boolean;
+    get isMedium(): boolean;
+    get isLarge(): boolean;
+    role: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SeparatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SeparatorComponent, "frg-separator", never, { "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TSectionSpacing = 'sm' | 'md' | 'lg';
+type TSectionHeading = 1 | 2 | 3 | 4 | 5 | 6;
+
+declare class SectionComponent {
+    title?: string;
+    description?: string;
+    spacing: TSectionSpacing;
+    divider: boolean;
+    headingLevel: TSectionHeading;
+    baseClass: boolean;
+    get isSmall(): boolean;
+    get isMedium(): boolean;
+    get isLarge(): boolean;
+    get hasDivider(): boolean;
+    get hasHeader(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionComponent, "frg-section", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "spacing": { "alias": "spacing"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; "headingLevel": { "alias": "headingLevel"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface IPaginationOutput<T> {
+    page: number;
+    pagedData: T[];
+}
+
+declare class SmallPaginationComponent<T> implements OnInit, OnChanges {
+    totalItems: number;
+    fullData: T[];
+    page: number;
+    pageSize: number;
+    hasElipsisPages: boolean;
+    styleType: TBaseStyle;
+    pageChange: EventEmitter<IPaginationOutput<T>>;
+    pagesArray: number[];
+    pagedData: T[];
+    totalPages: number;
+    showStartEllipsis: boolean;
+    showEndEllipsis: boolean;
+    maxVisiblePages: number;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private calculateTotalPages;
+    private generatePagesArray;
+    private buildSimplePages;
+    private buildEllipsisPages;
+    private getVisibleMiddleCount;
+    private getMiddleRange;
+    private uniquePages;
+    private resetEllipsis;
+    private clampPage;
+    changePage(newPage: number): void;
+    setCurrentPage(): void;
+    private isSimplePagination;
+    private range;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmallPaginationComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmallPaginationComponent<any>, "frg-small-pagination", never, { "totalItems": { "alias": "totalItems"; "required": false; }; "fullData": { "alias": "fullData"; "required": false; }; "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "hasElipsisPages": { "alias": "hasElipsisPages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+declare enum EnumDirectionSortTable {
+    asc = 0,
+    desc = 1
+}
+
+type TooltipPosition = 'top' | 'top-left' | 'top-right' | 'left' | 'right' | 'bottom' | 'bottom-left' | 'bottom-right';
+
+type TIconPosition = 'left' | 'right';
+type TInputType = 'text' | 'button' | 'checkbox' | 'color' | 'date' | 'datetime' | 'datetime-local' | 'email' | 'file' | 'number' | 'image' | 'url' | 'week';
+
+interface IConfigTable<T> {
+    tTitleBar?: ITTitleBar;
+    tCaption: ITCaption;
+    tSort?: ITSort;
+    tHead: ITHead;
+    tBody: ITBody<T>;
+    tPagination: ITPagination<T>;
+}
+interface ITTitleBar {
+    title: string;
+}
+interface ITTitleBarFilter {
+    id: string;
+    label: string;
+    placeholder: string;
+    type?: TInputType;
+    control: FormControl;
+}
+interface ITTitleBarSearch {
+    id: string;
+    label: string;
+    placeholder: string;
+    type?: TInputType;
+    control: FormControl<string | null>;
+}
+interface ITCaption {
+    srOnly: string;
+}
+interface ITSort {
+    defaultDirection: EnumDirectionSortTable;
+    defaultFieldOrder: string | string[];
+}
+interface ITPagination<T> {
+    page?: number;
+    pageSize?: number;
+    order?: string | string[];
+    direction?: EnumDirectionSortTable;
+    totalItems?: number;
+    fullData?: T[];
+    hasScrollTop?: boolean;
+    showPagination?: boolean;
+    hasElipsisPages?: boolean;
+}
+interface ITHead {
+    columns: ITHeadColumn[];
+    action?: ITHeadAction;
+}
+interface ITHeadColumn {
+    columnId: string;
+    fieldOrder?: string;
+    fieldLabel: string;
+    customClasses?: string | string[];
+}
+interface ITHeadAction {
+    label: string;
+    customClass?: string;
+}
+interface ITBody<T> {
+    uniqueField: string;
+    rowClick?: IActionElement;
+    action?: ITBodyAction;
+    columns: ITBodyColumn[];
+    data?: T[];
+}
+interface IActionElement extends IBaseAction {
+    iconClass?: GenericFunction<string>;
+}
+interface ILinkAction {
+    link: string;
+    customParamsLink?: any;
+}
+interface IEventAction {
+    clickEvent: GenericFunction<any>;
+}
+interface ITBodyAction {
+    customClasses?: string;
+    buttons: IActionElement[];
+}
+interface ITBodyColumn {
+    cells: ITBodyCell[] | ITBodyCell;
+    customClass?: string;
+}
+interface ITBodyCell {
+    fieldArrayPosition?: ArrayOneOrMore<string | Array<string>>;
+    icon?: ITBodyCellIcon;
+    fieldPipe?: IFieldPipe;
+    customClass?: GenericFunction<string>;
+    template?: TemplateRef<ITableCellTemplateContext<any>>;
+}
+interface ITableCellTemplateContext<T> {
+    $implicit: T;
+    item: T;
+    value: unknown;
+    cell: ITBodyCell;
+}
+interface ITBodyCellIcon {
+    iconClass: string;
+    position?: TIconPosition;
+    action: IBaseAction;
+}
+interface IBaseAction {
+    id: string;
+    title?: string;
+    tooltip?: ITooltipElement;
+    ariaLabel?: string;
+    behaviourAction: TBehaviourAction<ILinkAction, IEventAction>;
+    disabled?: GenericFunction<boolean>;
+    visible?: GenericFunction<boolean>;
+}
+interface IFieldPipe {
+    type: any;
+    args?: any[];
+}
+interface ITooltipElement {
+    apply: boolean;
+    text?: GenericFunction<string>;
+    textContent?: GenericFunction<string>;
+    position?: TooltipPosition;
+    gap?: number;
+}
+
+declare class TableComponent<T> implements OnInit {
+    private readonly cdr;
+    /**
+     * Configuration of the table
+     *
+     * @see IConfigTable
+     */
+    configTable: IConfigTable<T>;
+    /**
+     * Style type of the table
+     */
+    styleType: TBaseStyle;
+    /**
+     * Size of table rows
+     */
+    rowSize: TBaseSize;
+    /**
+     * Event emitted to reload the table data
+     *
+     * @see ITPagination
+     */
+    reloadTableEvent: EventEmitter<{
+        pagination: ITPagination<T>;
+        reload?: boolean;
+    }>;
+    /**
+     * Reference to the table header element
+     */
+    tableHead: ElementRef<HTMLElement>;
+    /**
+     * Enum for sorting direction
+     * @see EnumDirectionSortTable
+     */
+    EnumDirectionSortTable: typeof EnumDirectionSortTable;
+    /**
+     * ID of the first table row
+     */
+    idFirstTr: string;
+    /**
+     * Count of sorting actions performed
+     */
+    countSorting: number;
+    /**
+     * Cached full data of the table
+     */
+    fullDataCached: T[];
+    ngOnInit(): void;
+    /**
+     * Update the current page of the table
+     * @param event Pagination output event
+     * @see IPaginationOutput
+     */
+    updateCurrentPage(event: IPaginationOutput<T>): void;
+    /**
+     * Order the table by the specified field
+     * @param fieldOrder Field or fields to order by
+     */
+    orderBy(fieldOrder: string | string[]): void;
+    /**
+     * Handle the click event on a table row
+     * @param _event Click event
+     * @param item Data item associated with the clicked row
+     */
+    handleRowClick(_event: Event, item: T): void;
+    /**
+     * Handle the click event on a cell icon
+     * @param event Mouse event
+     * @param cell Table body cell configuration
+     * @param item Data item associated with the cell
+     * @see ITBodyCell
+     */
+    handleIconClick(cell: ITBodyCell, item: T): void;
+    getCellValue(item: T, cell: ITBodyCell): unknown;
+    private getNestedPropertyValueByPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "frg-table", never, { "configTable": { "alias": "configTable"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "rowSize": { "alias": "rowSize"; "required": false; }; }, { "reloadTableEvent": "reloadTableEvent"; }, never, never, true, never>;
+}
+
+/**
+ * Style variants supported by tabs.
+ */
+type TTabStyle = TBaseStyle;
+/**
+ * Size variants supported by tabs.
+ */
+type TTabSize = TBaseSize;
+/**
+ * Context passed into projected templates for tabs.
+ */
+interface TabItemContext<T = unknown> {
+    /**
+     * Implicit reference to the current tab item.
+     */
+    $implicit: TabItem<T>;
+    /**
+     * Named reference to the current tab item.
+     */
+    item: TabItem<T>;
+    /**
+     * Zero-based index of the tab.
+     */
+    index: number;
+    /**
+     * Whether this tab is currently active.
+     */
+    active: boolean;
+    /**
+     * Function to activate this tab.
+     */
+    select: () => void;
+}
+/**
+ * Definition for a single tab.
+ */
+interface TabItem<T = unknown> {
+    /** Unique identifier for the tab. Auto-generated when omitted. */
+    id?: string;
+    /** Visible label shown on the tab button. */
+    label: string;
+    /** Optional secondary label or helper text. */
+    description?: string;
+    /** Optional icon to render when no template is provided. */
+    icon?: string;
+    /** Disable interaction for this tab. */
+    disabled?: boolean;
+    /** Apply a style variant to this tab. */
+    style?: TTabStyle;
+    /** Adjust spacing and typography for this tab. */
+    size?: TTabSize;
+    /** Mark this tab as initially active when no activeId input is provided. */
+    active?: boolean;
+    /** Arbitrary data available to projected templates. */
+    data?: T;
+    /** Simple content rendering when no template is provided. */
+    content?: string;
+    /** Custom icon template for this tab only. */
+    iconTemplate?: TemplateRef<TabItemContext<T>>;
+    /** Custom label template for this tab only. */
+    labelTemplate?: TemplateRef<TabItemContext<T>>;
+    /** Custom body template for this tab only. */
+    contentTemplate?: TemplateRef<TabItemContext<T>>;
+}
+/**
+ * Payload emitted when the active tab changes.
+ */
+interface TabChangeEvent<T = unknown> {
+    /** Identifier of the active tab, or null when none available. */
+    id: string | null;
+    /** Index of the active tab in the view items. */
+    index: number;
+    /** The full tab item associated with the change. */
+    item?: TabItem<T>;
+}
+
+/**
+ * TabsComponent
+ *
+ * Accessible tabset that supports keyboard navigation, style variants,
+ * projected templates, and two-way active state management.
+ */
+declare class TabsComponent implements OnChanges {
+    /**
+     * Tab definitions rendered by the component.
+     */
+    items: TabItem[];
+    /**
+     * Identifier of the currently active tab. Auto-resolved when null.
+     */
+    activeId: string | null;
+    /**
+     * Visual style applied to tabs when no per-item style is provided.
+     */
+    styleType: TTabStyle;
+    /**
+     * Size variant applied to tabs when no per-item size is provided.
+     */
+    size: TTabSize;
+    /**
+     * Horizontal alignment of the tab list.
+     */
+    align: 'start' | 'center' | 'end' | 'stretch';
+    /**
+     * Enables panel fade/slide animations.
+     */
+    animated: boolean;
+    /**
+     * When true, moves focus to the active panel after selection.
+     */
+    focusPanelOnSelect: boolean;
+    /**
+     * Emits whenever the active tab changes (for two-way binding).
+     */
+    activeIdChange: EventEmitter<string | null>;
+    /**
+     * Detailed change event emitted on active tab updates.
+     */
+    changed: EventEmitter<TabChangeEvent<unknown>>;
+    /**
+     * Optional projected template for tab labels.
+     */
+    labelTemplate?: TemplateRef<TabItemContext>;
+    /**
+     * Optional projected template for tab panels.
+     */
+    contentTemplate?: TemplateRef<TabItemContext>;
+    /**
+     * Optional projected template for tab icons.
+     */
+    iconTemplate?: TemplateRef<TabItemContext>;
+    /**
+     * References to rendered tab buttons for keyboard focus.
+     */
+    tabButtons: QueryList<ElementRef<HTMLButtonElement>>;
+    /**
+     * References to rendered panel elements for focus management.
+     */
+    panelBodies: QueryList<ElementRef<HTMLElement>>;
+    /**
+     * Normalized copy of `items` with generated ids and active flags.
+     */
+    viewItems: TabItem[];
+    /**
+     * Internal counter used for deterministic id generation.
+     */
+    private uidCounter;
+    /**
+     * Syncs inputs into internal view state and resolves active tab.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Determines whether a given tab id matches the current active id.
+     */
+    isActive(id?: string | null): boolean;
+    /**
+     * Builds the DOM id for a tab element.
+     */
+    tabId(id: string): string;
+    /**
+     * Builds the DOM id for a panel element.
+     */
+    panelId(id: string): string;
+    /**
+     * Handles click selection for a tab at the given index.
+     */
+    onTabClick(index: number, event: Event): void;
+    /**
+     * Keyboard interaction handler to navigate and activate tabs.
+     */
+    onTabKeydown(event: KeyboardEvent, index: number): void;
+    /**
+     * Builds a template context for projected templates.
+     */
+    buildContext<T = unknown>(item: TabItem<T>, index: number): TabItemContext<T>;
+    /**
+     * Selects the tab at the given index if enabled and different.
+     */
+    private selectAt;
+    /**
+     * Ensures every tab has an id and returns a new items array.
+     */
+    private normalizeItems;
+    /**
+     * Generates a deterministic id for tabs lacking one.
+     */
+    private generateId;
+    /**
+     * Resolves the next active id based on provided preference and availability.
+     */
+    private resolveActiveId;
+    /**
+     * Applies the active id, updates view state, emits events, and manages focus.
+     */
+    private setActiveId;
+    /**
+     * Moves focus to the tab at the given index.
+     */
+    private focusTab;
+    /**
+     * Moves focus to the panel at the given index.
+     */
+    private focusPanel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "frg-tabs", never, { "items": { "alias": "items"; "required": false; }; "activeId": { "alias": "activeId"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "size": { "alias": "size"; "required": false; }; "align": { "alias": "align"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; "focusPanelOnSelect": { "alias": "focusPanelOnSelect"; "required": false; }; }, { "activeIdChange": "activeIdChange"; "changed": "changed"; }, ["labelTemplate", "contentTemplate", "iconTemplate"], never, true, never>;
+}
+
+declare class TitleBarComponent {
+    title: string;
+    styleType: TBaseStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TitleBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TitleBarComponent, "frg-title-bar", never, { "title": { "alias": "title"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TBaseSideNavStyle = 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger' | 'dark' | 'light';
+type TBaseSideNavSize = 'small' | 'medium' | 'large';
+type TSideNavLink = {
+    kind: "route";
+    value: string;
+    exact?: boolean;
+} | {
+    kind: "href";
+    value: string;
+    target?: "_blank" | "_self" | "_parent" | "_top";
+};
+interface ISideNavConfig {
+    title?: string;
+    sections?: Array<ISideNavSection>;
+}
+interface ISideNavSection {
+    id?: string;
+    title?: string;
+    icon?: string;
+    items?: Array<ISideNavItem>;
+    styleType?: TBaseSideNavStyle;
+    size?: TBaseSideNavSize;
+}
+interface ISideNavItem {
+    id?: string;
+    label: string;
+    link?: TSideNavLink;
+    icon?: string;
+    children?: Array<ISideNavItem>;
+    expanded?: boolean;
+}
+
+declare class SideNavComponent {
+    config: ISideNavConfig;
+    toggleItem(item: ISideNavItem): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SideNavComponent, "frg-side-nav", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TStepperOrientation = 'horizontal' | 'vertical';
+type TStepperMotion = 'next' | 'previous' | 'none';
+type TStepNavigationSource = 'click' | 'next' | 'previous' | 'programmatic';
+interface StepItemContext<T = unknown> {
+    $implicit: StepItem<T>;
+    item: StepItem<T>;
+    index: number;
+    active: boolean;
+    completed: boolean;
+    error: boolean;
+    select: () => void;
+    next: () => void;
+    previous: () => void;
+}
+interface StepValidationContext<T = unknown> {
+    step: StepItem<T>;
+    index: number;
+    formGroup?: AbstractControl | null;
+    source: TStepNavigationSource;
+}
+type StepValidator<T = unknown> = (context: StepValidationContext<T>) => boolean | Promise<boolean>;
+interface StepItem<T = unknown> {
+    id?: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+    optional?: boolean;
+    completed?: boolean;
+    error?: boolean;
+    icon?: string;
+    data?: T;
+    content?: string;
+    control?: AbstractControl | null;
+    validator?: StepValidator<T>;
+    labelTemplate?: TemplateRef<StepItemContext<T>>;
+    contentTemplate?: TemplateRef<StepItemContext<T>>;
+    indicatorTemplate?: TemplateRef<StepItemContext<T>>;
+}
+interface StepChangeEvent<T = unknown> {
+    id: string | null;
+    index: number;
+    direction: TStepperMotion;
+    item?: StepItem<T>;
+}
+interface StepValidationEvent<T = unknown> {
+    id: string | null;
+    index: number;
+    valid: boolean;
+    source: TStepNavigationSource;
+    item?: StepItem<T>;
+}
+
+interface StepViewItem<T = unknown> extends StepItem<T> {
+    id: string;
+    active?: boolean;
+}
+declare class StepperComponent implements OnChanges {
+    steps: StepItem[];
+    activeId: string | null;
+    linear: boolean;
+    animated: boolean;
+    orientation: TStepperOrientation;
+    focusPanelOnChange: boolean;
+    validateOnChange: boolean;
+    allowStepClick: boolean;
+    formGroup?: AbstractControl | null;
+    activeIdChange: EventEmitter<string | null>;
+    changed: EventEmitter<StepChangeEvent<unknown>>;
+    validationChange: EventEmitter<StepValidationEvent<unknown>>;
+    labelTemplate?: TemplateRef<StepItemContext>;
+    contentTemplate?: TemplateRef<StepItemContext>;
+    indicatorTemplate?: TemplateRef<StepItemContext>;
+    stepButtons: QueryList<ElementRef<HTMLButtonElement>>;
+    panelBodies: QueryList<ElementRef<HTMLElement>>;
+    viewSteps: StepViewItem[];
+    motion: TStepperMotion;
+    private uidCounter;
+    private readonly validationState;
+    ngOnChanges(changes: SimpleChanges): void;
+    get activeIndex(): number;
+    isActive(id?: string | null): boolean;
+    stepId(id: string): string;
+    panelId(id: string): string;
+    onStepClick(index: number, event: Event): void;
+    onStepKeydown(event: KeyboardEvent, index: number): void;
+    next(): void;
+    previous(): void;
+    buildContext<T = unknown>(step: StepItem<T>, index: number): StepItemContext<T>;
+    stepStatus(step: StepItem, index: number): 'completed' | 'active' | 'error' | 'default';
+    indicatorText(step: StepItem, index: number): string;
+    indicatorLabel(step: StepItem, index: number): string;
+    isStepDisabled(step: StepItem, index: number): boolean;
+    tabIndexFor(index: number): number;
+    private requestStepChange;
+    private normalizeSteps;
+    private generateId;
+    private resolveActiveId;
+    private setActiveId;
+    private getDirection;
+    isStepComplete<T>(step: StepItem<T>): boolean;
+    isStepError<T>(step: StepItem<T>): boolean;
+    private getValidationResult;
+    private isStepBlocked;
+    private validateStep;
+    private focusStep;
+    private focusPanel;
+    private getResolvedActiveIndex;
+    private findNextEnabledIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepperComponent, "frg-stepper", never, { "steps": { "alias": "steps"; "required": false; }; "activeId": { "alias": "activeId"; "required": false; }; "linear": { "alias": "linear"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "focusPanelOnChange": { "alias": "focusPanelOnChange"; "required": false; }; "validateOnChange": { "alias": "validateOnChange"; "required": false; }; "allowStepClick": { "alias": "allowStepClick"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, { "activeIdChange": "activeIdChange"; "changed": "changed"; "validationChange": "validationChange"; }, ["labelTemplate", "contentTemplate", "indicatorTemplate"], never, true, never>;
+}
+
+/**
+ * Base class for input components, providing common functionality for form controls.
+ * This class implements ControlValueAccessor to integrate with Angular forms.
+ * Subclasses must implement the abstract methods to update the view and disabled state.
+ * It also provides properties for label, placeholder, required state, and error handling.
+ * The errorMessages property can be customized to provide specific validation messages.
+ * The hasError getter can be used in templates to conditionally display error messages.
+ * Subclasses should call super.ngOnInit() if they override ngOnInit().
+ *
+ * @see ControlValueAccessor
+ */
+declare abstract class InputBase<T> implements ControlValueAccessor, OnInit {
+    /**
+     * Unique identifier for the input element.
+     */
+    id: string;
+    /**
+     * The current value of the input element.
+     */
+    value: T | null;
+    /**
+     * Indicates whether the input element is disabled.
+     */
+    disabled: boolean;
+    /**
+     * The label for the input element.
+     */
+    label: string;
+    /**
+     * The placeholder text for the input element.
+     */
+    placeholder: string;
+    /**
+     * Indicates whether the input element is required.
+     * If true, a visual indicator is shown next to the label.
+     */
+    required: boolean;
+    /**
+     * The FormControl associated with this input element.
+     */
+    control: FormControl | null;
+    /**
+     * Indicates whether to show validation messages.
+     * If false, validation messages will be hidden.
+     * Default is true.
+     */
+    showValidation: boolean;
+    /**
+     * The NgControl associated with this input element, if any.
+     * This is injected to link the component with Angular forms.
+     */
+    protected ngControl: NgControl | null;
+    /**
+     * Holds the registered callback function to notify when the value changes.
+     */
+    protected onChange: (value: T | null) => void;
+    /**
+     * Holds the registered callback function to notify when the input is touched.
+     */
+    protected onTouched: () => void;
+    constructor();
+    /**
+     * @inheritdoc
+     */
+    ngOnInit(): void;
+    /**
+     * @inheritdoc
+     */
+    writeValue(value: T): void;
+    /**
+     * @inheritdoc
+     */
+    registerOnChange(fn: (value: T | null) => void): void;
+    /**
+     * @inheritdoc
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * @inheritdoc
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Indicates whether the input has validation errors and has been touched.
+     * This is used to conditionally display error messages in the template.
+     * @return True if the input has errors and has been touched, false otherwise.
+     */
+    get hasError(): boolean;
+    /**
+     * Updates the view to reflect the current value.
+     * This method should be implemented by subclasses to update the specific input element.
+     * @param value The new value to set in the view.
+     */
+    protected abstract updateView(value: T | null): void;
+    /**
+     * Updates the disabled state of the input element in the view.
+     * This method should be implemented by subclasses to update the specific input element.
+     * @param isDisabled True if the input should be disabled, false otherwise.
+     */
+    protected abstract updateDisabledState(isDisabled: boolean): void;
+    /**
+     * Handles blur event.
+     * Subclasses can override to provide custom behavior.
+     * Default implementation does nothing.
+     */
+    protected onBlur(_: FocusEvent): void;
+    /**
+     * Handles focus event.
+     * Subclasses can override to provide custom behavior.
+     * Default implementation does nothing.
+     */
+    protected onFocus(_: FocusEvent): void;
+    /**
+     * Handles input event.
+     * Subclasses can override to provide custom behavior.
+     * Default implementation does nothing.
+     */
+    protected onInput(_: Event): void;
+    /**
+     * A mapping of validation error keys to user-friendly error messages.
+     * This can be customized to provide specific messages for different validation errors.
+     * By default, it uses the DEFAULT_ERROR_MESSAGES constant.
+     * If a specific error key is not found in this mapping, a generic message is used.
+     */
+    protected errorMessages: Record<string, string>;
+    /**
+     * A mapping of validation warnning keys to user-friendly warnning messages.
+     * This can be customized to provide specific messages for different validation warnnings.
+     * By default, it uses the DEFAULT_WARNING_MESSAGES constant.
+     * If a specific warnning key is not found in this mapping, a generic message is used.
+     */
+    protected warningMessages: Record<string, string>;
+    /**
+     * Returns the list of error messages for the input.
+     *
+     * This property should be implemented by subclasses to provide
+     * the current validation errors as an array of strings.
+     */
+    protected abstract get errorList(): string[];
+    /**
+     * Returns the list of error messages for the input.
+     *
+     * This property should be implemented by subclasses to provide
+     * the current validation errors as an array of strings.
+     */
+    protected abstract get warningList(): string[] | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputBase<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+type InputTextType = 'text' | 'email' | 'password' | 'tel' | 'url';
+type InputNumberType = 'number' | 'decimal';
+type InputDateType = 'date' | 'datetime-local';
+type InputTimeType = 'time';
+type InputTimePartial = 'hour' | 'minute' | 'second' | 'meridiem';
+type InputTimeMeridiem = 'AM' | 'PM';
+type InputToggleSwitchType = 'square' | 'circle';
+type InputSliderSize = 'small' | 'medium' | 'big';
+type InputBorderStyleType = 'primary' | 'secondary' | 'tertiary';
+type InputChoiceStyleType = 'primary' | 'secondary' | 'tertiary' | 'info' | 'success' | 'warning' | 'danger' | 'light' | 'dark';
+
+declare class InputTextComponent extends InputBase<string> implements OnInit {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    placeholder: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * The type of the input element.
+     * Can be 'text', 'password', 'email', 'tel', etc.
+     * Defaults to 'text'.
+     *
+     * @see InputTextType
+     */
+    type: InputTextType;
+    /**
+     * Enables strict mode for email validation.
+     * When set to true, the email validator will use a more stringent pattern.
+     * Defaults to false.
+     */
+    validatorStrictMode: boolean;
+    protected get errorList(): string[];
+    /**
+     * Handles the blur event on the input element.
+     * Marks the control as touched.
+     */
+    onBlur(): void;
+    /**
+     * Handles the input event on the input element.
+     * Updates the value and notifies the form control.
+     */
+    onInput(event: Event): void;
+    /**
+     * @inheritdoc
+     */
+    ngOnInit(): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: string | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * Indicates whether the password is visible or hidden.
+     *
+     * Used only when the input type is 'password'.
+     */
+    protected showPassword: boolean;
+    /**
+     * Determines the actual input type to be used in the template.
+     * If the type is 'password', it toggles between 'text' and 'password'
+     * based on the showPassword property.
+     *
+     * @returns The input type as a string.
+     */
+    get inputType(): string;
+    /**
+     * Returns warning messages. Consumers may pass arbitrary warnings via `warningMessages`.
+     * Falls back to DEFAULT_INPUT_TEXT_WARNINGS_MESSAGES or a generic message.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    /**
+     * Toggles the visibility of the password input field.
+     * This method switches the input type between 'text' and 'password'.
+     *
+     * Used only when the input type is 'password'.
+     */
+    protected toggleShowPassword(): void;
+    /**
+     * Adds email validator to the control if the type is 'email'.
+     * This ensures that the input value is a valid email address.
+     */
+    private validateEmail;
+    private validatePhoneNumber;
+    private validateUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputTextComponent, "frg-input-text", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "type": { "alias": "type"; "required": false; }; "validatorStrictMode": { "alias": "validatorStrictMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type InputTextareaResize = 'none' | 'vertical' | 'horizontal' | 'both';
+interface InputTextareaConfig {
+    rows?: number;
+    resize?: InputTextareaResize;
+    maxLength?: number | null;
+}
+
+declare class InputTextareaComponent extends InputBase<string> implements InputTextareaConfig {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    placeholder: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * Number of visible text rows.
+     */
+    rows: number;
+    /**
+     * CSS resize behavior for the textarea.
+     */
+    resize: InputTextareaResize;
+    /**
+     * Maximum allowed length for textarea content.
+     */
+    maxLength: number | null;
+    protected get errorList(): string[];
+    protected get warningList(): string[];
+    protected get hasWarning(): boolean;
+    onInput(event: Event): void;
+    onBlur(): void;
+    protected updateView(_value: string | null): void;
+    protected updateDisabledState(_isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputTextareaComponent, "frg-input-textarea", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "resize": { "alias": "resize"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type InputRichTextCommand = 'bold' | 'italic' | 'underline' | 'insertUnorderedList' | 'insertOrderedList';
+interface InputRichTextConfig {
+    minHeight?: string;
+    showToolbar?: boolean;
+}
+
+declare class InputRichTextComponent extends InputBase<string> implements AfterViewInit, InputRichTextConfig {
+    private editorRef?;
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    placeholder: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * Minimum editor height.
+     */
+    minHeight: string;
+    /**
+     * Show or hide toolbar actions.
+     */
+    showToolbar: boolean;
+    private readonly commandStates;
+    protected get errorList(): string[];
+    protected get warningList(): string[];
+    protected get hasWarning(): boolean;
+    ngAfterViewInit(): void;
+    onInput(): void;
+    onEditorKeyUp(): void;
+    onEditorSelectionChange(): void;
+    onEditorKeyDown(event: KeyboardEvent): void;
+    onBlur(): void;
+    execute(command: InputRichTextCommand): void;
+    setTextColor(event: Event): void;
+    isCommandActive(command: InputRichTextCommand): boolean;
+    preventToolbarMouseDown(event: MouseEvent): void;
+    protected updateView(value: string | null): void;
+    protected updateDisabledState(isDisabled: boolean): void;
+    private focusEditor;
+    private applyInlineFormat;
+    private applyColor;
+    private wrapRange;
+    private toggleList;
+    private unwrapList;
+    private convertListType;
+    private getCurrentListItem;
+    private indentListItem;
+    private outdentListItem;
+    private getCurrentRange;
+    private getSelectionAnchorElement;
+    private findClosestTag;
+    private syncCommandStates;
+    private hasAnyAncestorTag;
+    private placeCaretAtEnd;
+    private normalizeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputRichTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputRichTextComponent, "frg-input-rich-text", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputNumberComponent extends InputBase<number | null> implements OnInit {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    placeholder: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * The type of the input element.
+     * Can be 'number' or 'decimal'.
+     * Defaults to 'number'.
+     */
+    type: InputNumberType;
+    /**
+     * Minimum allowed value for the input.
+     */
+    min: number | null;
+    /**
+     * Maximum allowed value for the input.
+     */
+    max: number | null;
+    /**
+     * Increment/decrement step for the input value.
+     */
+    step: number | null;
+    /**
+     * Maximum number of decimal places allowed.
+     */
+    precision: number | null;
+    /**
+     * Enables strict mode for validation.
+     * Defaults to false.
+     */
+    validatorStrictMode: boolean;
+    /** Internal store for warnings */
+    private warnings;
+    /**
+     * @inheritdoc
+     */
+    ngOnInit(): void;
+    /**
+     * Returns the step value for the input based on type and precision.
+     */
+    get inputStep(): number;
+    /**
+     * Handles blur event:
+     * - Aligns value to step
+     * - Clamps to min/max/precision
+     * - Runs validation
+     */
+    protected onBlur(event: FocusEvent): void;
+    /**
+     * Handles input event:
+     * - Normalizes value
+     * - Runs validation
+     */
+    protected onInput(event: Event): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: number | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * Returns error messages, excluding warnings.
+     */
+    protected get errorList(): string[];
+    /**
+     * Returns dynamic warning messages, replacing {{limit}} with actual values.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    /**
+    * Increase value by step, respecting precision, step alignment and max.
+    */
+    protected increase(): void;
+    /**
+     * Decrease value by step, respecting precision, step alignment and min.
+     */
+    protected decrease(): void;
+    /**
+     * Clamps a value to respect precision, min, and max
+     * @param value Value to clamp
+     */
+    private applyClamping;
+    /**
+     * Validates a value against precision, min, max, and step
+     * @param value Value to validate
+     */
+    private validate;
+    /** Initializes placeholder based on type */
+    private initPlaceholder;
+    /**
+     * Adds a warning flag
+     * @param key Warning type
+     */
+    private addWarning;
+    /**
+     * Removes a warning flag
+     * @param key Warning type
+     */
+    private removeWarning;
+    /**
+     * Aligns a value to the nearest multiple of step
+     * @param value Value to align
+     * @param step Step size
+     */
+    private alignToStep;
+    /**
+     * Counts the number of decimals in a number
+     * @param num Number to check
+     */
+    private countDecimals;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputNumberComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputNumberComponent, "frg-input-number", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "type": { "alias": "type"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "validatorStrictMode": { "alias": "validatorStrictMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputDateComponent extends InputBase<Date | null> {
+    onDocumentClick(event: MouseEvent): void;
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    placeholder: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * The type of the input element.
+     * Can be 'text', 'password', 'email', 'tel', etc.
+     * Defaults to 'text'.
+     *
+     * @see InputTextType
+     */
+    type: InputDateType;
+    /**
+     * Minimum year selectable in the calendar
+     */
+    minDate: Date;
+    /**
+     * Maximum year selectable in the calendar
+     */
+    maxDate: Date;
+    /**
+     * The format of date
+     */
+    format: DateFormat;
+    /**
+     * Enables strict mode for email validation.
+     * When set to true, the email validator will use a more stringent pattern.
+     * Defaults to false.
+     */
+    validatorStrictMode: boolean;
+    /**
+     * Used for show calendar
+     */
+    showCalendar$: BehaviorSubject<boolean>;
+    /**
+     * Determines the actual input type to be used in the template.
+     * If the type is 'password', it toggles between 'text' and 'password'
+     * based on the showPassword property.
+     *
+     * @returns The input type as a string.
+     */
+    get inputType(): string;
+    /** Internal store for warnings */
+    private warnings;
+    /**
+     * @inheritdoc
+     */
+    ngOnInit(): void;
+    /**
+     * Handles the blur event on the input element.
+     * Validates and formats the input value.
+     * Marks the control as touched and updates the model value.
+     * @param event Focus event
+     */
+    onBlur(event: FocusEvent): void;
+    /**
+     * Handles the input event on the input element.
+     * Validates the input value.
+     * @param event Input event
+     */
+    onInput(event: Event): void;
+    /**
+     * Handles the blur event on the input element.
+     * Marks the control as touched.
+     */
+    onFocus(_event: FocusEvent): void;
+    /**
+     * Format value for input display
+     * @param value Date value
+     * @returns Formatted date string
+     */
+    protected formatDate(value: Date | null): string;
+    protected selectDate(date: Date): void;
+    protected toggleCalendar(): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: Date | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * @inheritdoc
+     */
+    protected get errorList(): string[];
+    /**
+     * Returns dynamic warning messages, replacing {{limit}} with actual values.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    /**
+     * Adds a warning flag
+     * @param key Warning key
+     */
+    private addWarning;
+    /**
+     * Clamp a date within min/max boundaries
+     * @param date Date to clamp
+     * @returns Clamped date and sets warnings if needed
+     */
+    private clampDate;
+    /**
+     * Initialize the placeholder based on the date format
+     */
+    private initPlaceholder;
+    /**
+     * Initialize validators based on inputs
+     */
+    private initValidators;
+    /**
+     * Validate the input value against the specified format
+     * @param value Input value
+     */
+    private validate;
+    /**
+     * Remove a warning flag
+     * @param key Warning key
+     */
+    private removeWarning;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateComponent, "frg-input-date", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "type": { "alias": "type"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "format": { "alias": "format"; "required": false; }; "validatorStrictMode": { "alias": "validatorStrictMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputCalendarComponent implements OnInit {
+    private readonly locale;
+    /**
+     * Current day
+     */
+    currentDay: number;
+    /**
+     * Month is 0 indexed in JavaScript Date, so we add 1 to make it 1 indexed
+     */
+    currentMonth: number;
+    /**
+     * Current year
+     */
+    currentYear: number;
+    /**
+     * Minimum date selectable in the calendar
+     * @default 0
+     */
+    minDate: Date;
+    /**
+     * Maximum date selectable in the calendar
+     * @default 9999-12-31
+     */
+    maxDate: Date;
+    /**
+     * The currently selected date
+     * @default null
+     */
+    selectedValue: Date | null;
+    /**
+     * Event emitted when a date is selected
+     * @type {EventEmitter<Date>}
+     */
+    selectDate: EventEmitter<Date>;
+    /**
+     * Event emitted when value is hi than max date
+     * @type {EventEmitter<Date>}
+     */
+    handleMaxDate: EventEmitter<Date>;
+    /**
+     * Event emitted when value is less than min date
+     * @type {EventEmitter<Date>}
+     */
+    handleMinDate: EventEmitter<Date>;
+    /**
+     * Used for show month selection
+     */
+    hasMonthSelectionOpen$: BehaviorSubject<boolean>;
+    /**
+     * Used for show year selection
+     */
+    hasYearSelectionOpen$: BehaviorSubject<boolean>;
+    /**
+     * Array of dates to display in the calendar
+     */
+    get calendarDays(): Date[];
+    /**
+     * Get the short names of the weekdays based on the current locale
+     */
+    get weekDays(): string[];
+    get years(): number[];
+    get months(): string[];
+    /**
+     * Get the current month in long format (e.g., January, February)
+     */
+    get month(): string;
+    /**
+     * Get the current year as a string
+     */
+    get year(): string;
+    ngOnInit(): void;
+    /**
+     * Check if a given day is today
+     * @param day - The date to check
+     * @returns True if the given day is today, false otherwise
+     */
+    protected isToday(day: Date): boolean;
+    /**
+     * Change the current month, adjusting the year if necessary
+     * @param month - The new month to set (1-12)
+     */
+    protected changeMonth(month: number): void;
+    /**
+     * Open or close the month selection dropdown
+     */
+    protected openYearSelection(): void;
+    /**
+     * Open or close the month selection dropdown
+     */
+    protected openMonthSelection(): void;
+    /**
+     * Handle the selection of a date and emit the selected date
+     * @param date - The date that was selected
+     */
+    protected onSelectDate(event: PointerEvent, date: Date): void;
+    /**
+     * Check if a date is disabled based on minDate and maxDate
+     * @param a - The date to check
+     * @returns True if the date is disabled, false otherwise
+     */
+    protected isDisabled(a: Date): boolean;
+    /**
+     * Check if a date is the currently selected date
+     * @param a - The date to check
+     * @param b - The currently selected date
+     * @returns True if the dates are the same, false otherwise
+     */
+    protected isSelected(a: Date, b: Date | null): boolean;
+    /**
+     * Check if a date is the currently selected date
+     * @param a - The date to check
+     * @param b - The currently selected date
+     * @returns True if the dates are the same, false otherwise
+     */
+    protected isSelectedYearOrMonth(a: number, b: number | null): boolean;
+    protected selectMonth(event: MouseEvent, month: number): void;
+    protected selectYear(event: MouseEvent, year: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCalendarComponent, "frg-input-calendar", never, { "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "selectedValue": { "alias": "selectedValue"; "required": false; }; }, { "selectDate": "selectDate"; "handleMaxDate": "handleMaxDate"; "handleMinDate": "handleMinDate"; }, never, never, true, never>;
+}
+
+declare class InputTimeComponent extends InputBase<string> {
+    /**
+   * @inheritdoc
+   */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    placeholder: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * The type of the input element.
+     * Can be 'text', 'password', 'email', 'tel', etc.
+     * Defaults to 'text'.
+     *
+     * @see InputTextType
+     */
+    type: InputTimeType;
+    /**
+     * Minimum year selectable in the calendar
+     */
+    minTime: string;
+    /**
+     * Maximum year selectable in the calendar
+     */
+    maxTime: string;
+    /**
+     * The format of time
+     */
+    format: TimeFormat;
+    /**
+     * Enables strict mode for email validation.
+     * When set to true, the email validator will use a more stringent pattern.
+     * Defaults to false.
+     */
+    validatorStrictMode: boolean;
+    /**
+     * Determines the actual input type to be used in the template.
+     * If the type is 'password', it toggles between 'text' and 'password'
+     * based on the showPassword property.
+     *
+     * @returns The input type as a string.
+     */
+    get inputType(): string;
+    /**
+     * Minimum hour based on minTime
+     */
+    get minHour(): number;
+    /**
+     * Maximum hour based on maxTime and format
+     */
+    get maxHour(): number;
+    /**
+     * Minimum minute allowed based on `minTime`
+     */
+    get minMinute(): number;
+    /**
+     * Maximum minute allowed based on `maxTime`
+     */
+    get maxMinute(): number;
+    /**
+     * Minimum second allowed based on `minTime`
+     */
+    get minSecond(): number;
+    /**
+     * Maximum second allowed based on `maxTime`
+     */
+    get maxSecond(): number;
+    /** Internal store for warnings */
+    private warnings;
+    /**
+     * @inheritdoc
+     */
+    ngOnInit(): void;
+    onKeydown(event: Event): void;
+    /**
+     * @inheritdoc
+     */
+    onBlur(event: FocusEvent): void;
+    /**
+     * @inheritdoc
+     */
+    onInput(event: Event): void;
+    /**
+     * Decrements a specific part of the time (hour, minute, or second)
+     * and updates the input value accordingly.
+     *
+     * @param partialTime - The time part to decrement: 'hour', 'minute', or 'second'.
+     */
+    protected decrease(partialTime: InputTimePartial): void;
+    /**
+     * Format value for input display
+     * @param value Date value
+     * @returns Formatted time string
+     */
+    protected formatTime(value: string | null, partialTime?: InputTimePartial): string;
+    /**
+     * Increments a specific part of the time (hour, minute, or second)
+     * and updates the input value accordingly.
+     *
+     * @param partialTime - The time part to increment: 'hour', 'minute', or 'second'.
+     */
+    protected increase(partialTime: InputTimePartial): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: string | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * @inheritdoc
+     */
+    protected get errorList(): string[];
+    /**
+     * Returns dynamic warning messages, replacing {{limit}} with actual values.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    /**
+     * Adds a warning flag
+     * @param key Warning key
+     */
+    private addWarning;
+    /**
+     * Builds a formatted time string from the given time parts.
+     * - Undefined numeric parts are represented as "undefined".
+     * - Meridiem is always included if the format includes 'a'.
+     *
+     * @param parts Object containing hour, minute, second, and optional meridiem
+     * @returns Formatted time string according to the current format
+     */
+    private formatPartsToTimeString;
+    /**
+     * Clamps a numeric value between a minimum and maximum.
+     * @param value The number to clamp.
+     * @param min Minimum allowed value.
+     * @param max Maximum allowed value.
+     * @returns The clamped number, or undefined if input was undefined.
+     */
+    private clamp;
+    /**
+     * Decrement hour based on format (12h or 24h)
+     * @param hour Current hour
+     * @returns Decremented hour
+     */
+    private decrementHour;
+    /**
+     * Decrement minute with wrapping
+     * @param minute Current minute
+     * @returns Decremented minute
+     */
+    private decrementMinute;
+    /**
+     * Decrement second with wrapping
+     * @param second Current second
+     * @returns Decremented second
+     */
+    private decrementSecond;
+    /**
+     * Returns the current time parts extracted from the component's value.
+     * Numeric parts are converted to numbers; meridiem defaults to 'AM' if format includes 'a'.
+     * @returns An object containing hour, minute, second, and meridiem (if applicable).
+     */
+    private getCurrentParts;
+    /**
+     * Initialize the placeholder based on the time format
+     */
+    private initPlaceholder;
+    /**
+     * Increment hour based on format (12h or 24h)
+     * @param hour Current hour
+     * @returns Incremented hour
+     */
+    private incrementHour;
+    /**
+     * Increment minute with wrapping
+     * @param minute Current minute
+     * @returns Incremented minute
+     */
+    private incrementMinute;
+    /**
+     * Increment second with wrapping
+     * @param second Current second
+     * @returns Incremented second
+     */
+    private incrementSecond;
+    /**
+     * Initialize validators based on inputs
+     */
+    private initValidators;
+    /**
+     * Merges a partial time input into the current value and returns the resulting full time string.
+     * @param partial The time part being updated ('hour', 'minute', 'second', 'meridiem').
+     * @param partialValue The new value for the specified part.
+     * @returns The merged full time string.
+     */
+    private mergePartialInput;
+    /**
+     * Converts a string to a number or returns undefined if the value is invalid.
+     * @param value The string to parse.
+     * @returns The number value, or undefined if input is null, 'undefined', or NaN.
+     */
+    private parseNumberOrUndefined;
+    /**
+     * Parse the current value to its components
+     * @returns An object containing hour, minute, second, and meridiem (if applicable)
+     */
+    private parseValueToParts;
+    /**
+     * Updates a specific part of a time parts object with a new partial value and clamps numeric values.
+     * @param parts The time parts object to update.
+     * @param partial The part to update ('hour', 'minute', 'second', 'meridiem').
+     * @param partialValue The new value for the part.
+     */
+    private setPartialValue;
+    /**
+     * Toggle the meridiem (AM/PM) in the current value
+     * This is used when incrementing hours in 12-hour format.
+     */
+    private toggleMeridiem;
+    /**
+     * Update individual input fields based on the current full time value
+     * This ensures that each part (hour, minute, second, meridiem) reflects the current value
+     * and is properly formatted.
+     */
+    private updateInputsFromValue;
+    /**
+      * Validate the input value against the specified format
+      * @param value Input value
+      */
+    private validate;
+    /**
+     * Remove a warning flag
+     * @param key Warning key
+     */
+    private removeWarning;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputTimeComponent, "frg-input-time", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "type": { "alias": "type"; "required": false; }; "minTime": { "alias": "minTime"; "required": false; }; "maxTime": { "alias": "maxTime"; "required": false; }; "format": { "alias": "format"; "required": false; }; "validatorStrictMode": { "alias": "validatorStrictMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputDateTimeComponent extends InputBase<Date | null> {
+    onDocumentClick(event: MouseEvent): void;
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    placeholder: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * Minimum year selectable in the calendar
+     */
+    minDateTime: Date;
+    /**
+     * Maximum year selectable in the calendar
+     */
+    maxDateTime: Date;
+    /**
+     * The format of date time
+     */
+    format: DateTimeFormat;
+    showDateTimePicker$: BehaviorSubject<boolean>;
+    get currentMeridiem(): InputTimeMeridiem;
+    /**
+    * Returns whether any warnings are active.
+    */
+    protected get hasWarning(): boolean;
+    /**
+     * Returns dynamic warning messages, replacing {{limit}} with actual values.
+     */
+    protected get warningList(): string[];
+    /** Internal store for warnings */
+    private readonly warnings;
+    /** Current meridiem passed to clock picker */
+    private meridiem;
+    /**
+     * Handles the blur event on the input element.
+     * Marks the control as touched.
+     */
+    onFocus(_event: FocusEvent): void;
+    /**
+     * Handles the blur event on the input element.
+     * Marks the control as touched.
+     */
+    onBlur(event: FocusEvent): void;
+    /**
+     * Format value for input display
+     * @param value Date value
+     * @returns Formatted date string
+     */
+    protected formatDate(value: Date | null): string;
+    protected updateView(_value: Date | null): void;
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * @inheritdoc
+     */
+    protected get errorList(): string[];
+    /**
+     * @inheritdoc
+     */
+    ngOnInit(): void;
+    clearValue(): void;
+    protected selectDate(date: Date): void;
+    /**
+     * Initialize the placeholder based on the date format
+     */
+    private initPlaceholder;
+    protected selectHour(hour: string): void;
+    protected selectMinute(minute: string): void;
+    protected selectMeridiem(meridiem: InputTimeMeridiem): void;
+    protected get timeFormat(): TimeFormat | null;
+    protected toggleDateTimePicker(): void;
+    /**
+     * Adds a warning flag
+     * @param key Warning key
+     */
+    private addWarning;
+    /**
+     * Clamp a date within min/max boundaries
+     * @param date Date to clamp
+     * @returns Clamped date and sets warnings if needed
+     */
+    private clampDate;
+    /**
+     * Remove a warning flag
+     * @param key Warning key
+     */
+    private removeWarning;
+    /**
+     * Validate the input value against the specified format
+     * @param value Input value
+     */
+    private validate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateTimeComponent, "frg-input-date-time", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "minDateTime": { "alias": "minDateTime"; "required": false; }; "maxDateTime": { "alias": "maxDateTime"; "required": false; }; "format": { "alias": "format"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputClockPickerComponent implements OnInit {
+    /**Selected hour in string format ("00".."23") */
+    selectedHour: string | null;
+    /** Selected minute in string format ("00".."55" step 5) */
+    selectedMinute: string | null;
+    /** Selected meridiem for 12-hour format */
+    selectedMeridiem: InputTimeMeridiem;
+    /** Time format configuration */
+    timeFormat: TimeFormat | null;
+    /** Emits the hour when user selects an hour */
+    selectHour: EventEmitter<string>;
+    /** Emits the minute when user selects a minute */
+    selectMinute: EventEmitter<string>;
+    /** Emits the meridiem when user toggles AM/PM */
+    selectMeridiem: EventEmitter<InputTimeMeridiem>;
+    /** Emits when the picker should be closed */
+    closePicker: EventEmitter<void>;
+    /** Reference to the minute hand element */
+    handMinutes: ElementRef<HTMLDivElement>;
+    /** Reference to the hour hand element */
+    handHours: ElementRef<HTMLDivElement>;
+    /** Whether the minutes picker is visible */
+    showMinutesPicker$: BehaviorSubject<boolean>;
+    /** Whether the hours picker is visible */
+    showHoursPicker$: BehaviorSubject<boolean>;
+    private currentHourDegree;
+    private currentMinuteDegree;
+    clockHours: Array<string>;
+    fullClockHours: Array<string>;
+    clockMinutes: Array<string>;
+    /** Returns the current time in HH:MM format */
+    get timeValue(): string;
+    /** Returns true if the time format is 12-hour */
+    protected get isMeridiemFormat(): boolean;
+    /**
+     * Initializes the hour and minute hands based on provided input values.
+     */
+    ngOnInit(): void;
+    /**
+     * Updates the hour hand to follow hover position.
+     * @param hour - The hour string being hovered ("00".."23").
+     */
+    protected onHourHover(hour: string): void;
+    /**
+     * Resets the hour hand to the currently selected hour when hover leaves.
+     */
+    protected onHourLeave(): void;
+    /**
+     * Handles user selection of an hour.
+     * @param event - The pointer event triggered by click.
+     * @param hour - The selected hour string ("00".."23").
+     */
+    protected onHourClick(event: PointerEvent, hour: string): void;
+    /**
+     * Handles AM/PM toggle for 12-hour format.
+     * @param event - The change event from the checkbox input.
+     */
+    protected onMeridiemChange(event: Event): void;
+    /**
+     * Updates the minute hand to follow hover position.
+     * @param minute - The minute string being hovered ("00".."55", step 5).
+     */
+    protected onMinuteHover(minute: string): void;
+    /**
+     * Resets the minute hand to the currently selected minute when hover leaves.
+     */
+    protected onMinuteLeave(): void;
+    /**
+     * Handles user selection of a minute.
+     * @param event - The pointer event triggered by click.
+     * @param minute - The selected minute string ("00".."55", step 5).
+     */
+    protected onMinuteClick(event: PointerEvent, minute: string): void;
+    protected showHours(): void;
+    protected showMinutes(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputClockPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputClockPickerComponent, "frg-input-clock-picker", never, { "selectedHour": { "alias": "selectedHour"; "required": false; }; "selectedMinute": { "alias": "selectedMinute"; "required": false; }; "selectedMeridiem": { "alias": "selectedMeridiem"; "required": false; }; "timeFormat": { "alias": "timeFormat"; "required": false; }; }, { "selectHour": "selectHour"; "selectMinute": "selectMinute"; "selectMeridiem": "selectMeridiem"; "closePicker": "closePicker"; }, never, never, true, never>;
+}
+
+declare class InputValidationComponent {
+    errorList: string[];
+    warningList: string[];
+    isFormInvalid: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputValidationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputValidationComponent, "frg-input-validation", never, { "errorList": { "alias": "errorList"; "required": false; }; "warningList": { "alias": "warningList"; "required": false; }; "isFormInvalid": { "alias": "isFormInvalid"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputToggleSwitchComponent extends InputBase<boolean> {
+    /**
+    * @inheritdoc
+    */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+   * @inheritdoc
+   */
+    disabled: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    warningMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * Accent color style for checked/focus state.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * The toggle switch type
+     * @default 'square'
+     */
+    type: InputToggleSwitchType;
+    /**
+     * Toggles the switch value
+     */
+    toggle(): void;
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: boolean | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * @inheritdoc
+     */
+    protected get errorList(): string[];
+    /**
+     * Returns warning messages. Consumers may pass arbitrary warnings via `warningMessages`.
+     * Falls back to DEFAULT_INPUT_TOGGLE_SWITCH_WARNINGS_MESSAGES or a generic message.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputToggleSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputToggleSwitchComponent, "frg-input-toggle-switch", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "warningMessages": { "alias": "warningMessages"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InputCheckboxComponent extends InputBase<boolean> {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    disabled: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    warningMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * Sets the visual style of the checkbox.
+     */
+    styleType: InputChoiceStyleType;
+    /**
+     * Toggles the checkbox value.
+     */
+    onToggle(event: Event): void;
+    /**
+     * @inheritdoc
+     */
+    onBlur(): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: boolean | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * @inheritdoc
+     */
+    protected get errorList(): string[];
+    /**
+     * Returns warning messages. Consumers may pass arbitrary warnings via `warningMessages`.
+     * Falls back to DEFAULT_INPUT_CHECKBOX_WARNINGS_MESSAGES or a generic message.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCheckboxComponent, "frg-input-checkbox", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "warningMessages": { "alias": "warningMessages"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface InputCheckboxGroupItem<T> {
+    id: string;
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+declare class InputCheckboxGroupComponent<T> extends InputBase<Array<T>> {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    disabled: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    warningMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * Sets the visual style of the checkbox group.
+     */
+    styleType: InputChoiceStyleType;
+    items: Array<InputCheckboxGroupItem<T>>;
+    compareWith: (a: T, b: T) => boolean;
+    /**
+     * Toggles a checkbox item value.
+     */
+    toggleItem(item: InputCheckboxGroupItem<T>, event: Event): void;
+    /**
+     * Checks if the item is selected.
+     */
+    isSelected(item: InputCheckboxGroupItem<T>): boolean;
+    /**
+     * @inheritdoc
+     */
+    onBlur(): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: Array<T> | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * @inheritdoc
+     */
+    protected get errorList(): string[];
+    /**
+     * Returns warning messages. Consumers may pass arbitrary warnings via `warningMessages`.
+     * Falls back to DEFAULT_INPUT_CHECKBOX_GROUP_WARNINGS_MESSAGES or a generic message.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputCheckboxGroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputCheckboxGroupComponent<any>, "frg-input-checkbox-group", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "warningMessages": { "alias": "warningMessages"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "items": { "alias": "items"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface InputRadioGroupItem<T> {
+    id: string;
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+declare class InputRadioGroupComponent<T> extends InputBase<T> {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    disabled: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    warningMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * Sets the visual style of the radio group.
+     */
+    styleType: InputChoiceStyleType;
+    items: Array<InputRadioGroupItem<T>>;
+    compareWith: (a: T, b: T) => boolean;
+    /**
+     * Selects a radio item value.
+     */
+    selectItem(item: InputRadioGroupItem<T>, event: Event): void;
+    /**
+     * Checks if the item is selected.
+     */
+    isSelected(item: InputRadioGroupItem<T>): boolean;
+    /**
+     * @inheritdoc
+     */
+    onBlur(): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateView(_value: T | null): void;
+    /**
+     * @inheritdoc
+     */
+    protected updateDisabledState(_isDisabled: boolean): void;
+    /**
+     * @inheritdoc
+     */
+    protected get errorList(): string[];
+    /**
+     * Returns warning messages. Consumers may pass arbitrary warnings via `warningMessages`.
+     * Falls back to DEFAULT_INPUT_RADIO_GROUP_WARNINGS_MESSAGES or a generic message.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputRadioGroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputRadioGroupComponent<any>, "frg-input-radio-group", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "warningMessages": { "alias": "warningMessages"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "items": { "alias": "items"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type InputSliderValue = number | [number, number];
+type SliderHandle = 'single' | 'min' | 'max';
+declare class InputSliderComponent extends InputBase<InputSliderValue> implements OnInit {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * @inheritdoc
+     */
+    warningMessages: Record<string, string>;
+    /**
+     * Minimum slider value.
+     */
+    min: number;
+    /**
+     * Maximum slider value.
+     */
+    max: number;
+    /**
+     * Step interval for the slider.
+     */
+    step: number;
+    /**
+     * Enable dual-handle range mode.
+     */
+    range: boolean;
+    /**
+     * Show tick marks along the track.
+     */
+    showTicks: boolean;
+    /**
+     * Optional tick interval (defaults to step).
+     */
+    tickStep: number | null;
+    /**
+     * Maximum number of ticks to render.
+     */
+    maxTicks: number;
+    /**
+     * Show tooltip on hover/drag.
+     */
+    showTooltip: boolean;
+    /**
+     * Show numeric value(s) above the slider.
+     */
+    showValue: boolean;
+    /**
+     * Slider size.
+     */
+    size: InputSliderSize;
+    /**
+     * Slider color style.
+     */
+    styleType: InputChoiceStyleType;
+    private track;
+    private currentValue;
+    private currentRange;
+    private dragging;
+    private activeHandle;
+    private activePointerId;
+    /** Internal store for warnings */
+    private warnings;
+    ngOnInit(): void;
+    protected updateView(_value: InputSliderValue | null): void;
+    protected updateDisabledState(_isDisabled: boolean): void;
+    protected get errorList(): string[];
+    protected get warningList(): string[];
+    protected get hasWarning(): boolean;
+    protected get displayValue(): string;
+    protected get displayRangeMin(): string;
+    protected get displayRangeMax(): string;
+    protected get rangeMinValue(): number;
+    protected get rangeMaxValue(): number;
+    protected get singleValue(): number;
+    protected get minPercent(): number;
+    protected get maxPercent(): number;
+    protected get singlePercent(): number;
+    protected get rangeWidth(): number;
+    protected get showRange(): boolean;
+    protected get ticks(): number[];
+    protected get sliderClasses(): Record<string, boolean>;
+    protected isHandleActive(handle: SliderHandle): boolean;
+    protected onTrackPointerDown(event: PointerEvent): void;
+    protected onHandlePointerDown(event: PointerEvent, handle: SliderHandle): void;
+    protected onHandleKeydown(event: KeyboardEvent, handle: SliderHandle): void;
+    protected onDocumentPointerMove(event: PointerEvent): void;
+    protected onDocumentPointerUp(event: PointerEvent): void;
+    private syncFromValue;
+    private normalizeSingleValue;
+    private normalizeRangeValue;
+    private setSingleValue;
+    private setRangeValue;
+    private startDragging;
+    private valueFromPointer;
+    protected valueToPercent(value: number): number;
+    private snapValue;
+    private roundToPrecision;
+    private formatValue;
+    private get safeStep();
+    private get stepPrecision();
+    private getHandleValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputSliderComponent, "frg-input-slider", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "warningMessages": { "alias": "warningMessages"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "range": { "alias": "range"; "required": false; }; "showTicks": { "alias": "showTicks"; "required": false; }; "tickStep": { "alias": "tickStep"; "required": false; }; "maxTicks": { "alias": "maxTicks"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "showValue": { "alias": "showValue"; "required": false; }; "size": { "alias": "size"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type InputFileUploadValue = File | File[] | null;
+declare class InputFileUploadComponent extends InputBase<InputFileUploadValue> implements OnInit {
+    /**
+     * @inheritdoc
+     */
+    label: string;
+    /**
+     * @inheritdoc
+     */
+    required: boolean;
+    /**
+     * @inheritdoc
+     */
+    showValidation: boolean;
+    /**
+     * @inheritdoc
+     */
+    errorMessages: Record<string, string>;
+    /**
+     * Accent color style for border/focus.
+     */
+    styleType: InputBorderStyleType;
+    /**
+     * Accepted file types (e.g. ".pdf,.png" or "image/*").
+     */
+    accept: string;
+    /**
+     * Allow multiple file selection.
+     */
+    multiple: boolean;
+    /**
+     * Maximum number of files allowed.
+     */
+    maxFiles: number | null;
+    /**
+     * Maximum size per file in bytes.
+     */
+    maxFileSize: number | null;
+    /**
+     * Maximum total size in bytes.
+     */
+    maxTotalSize: number | null;
+    /**
+     * Button label for opening the file dialog.
+     */
+    buttonLabel: string;
+    /**
+     * Placeholder text when no file is selected.
+     */
+    noFileText: string;
+    /**
+     * Show a clear button when files are selected.
+     */
+    showClearButton: boolean;
+    /**
+     * Show individual file list.
+     */
+    showFileList: boolean;
+    /**
+     * Show file size in the list.
+     */
+    showFileSize: boolean;
+    private readonly fileInput;
+    files: File[];
+    isDragOver: boolean;
+    private readonly ownedErrors;
+    ngOnInit(): void;
+    protected updateView(value: InputFileUploadValue | null): void;
+    protected updateDisabledState(_isDisabled: boolean): void;
+    protected get errorList(): string[];
+    protected get warningList(): string[];
+    get fileSummary(): string;
+    get hasFiles(): boolean;
+    triggerFileDialog(): void;
+    onFileChange(event: Event): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onBlur(_event: FocusEvent): void;
+    clearFiles(): void;
+    removeFile(index: number): void;
+    trackFile(_index: number, file: File): string;
+    formatBytes(bytes: number): string;
+    private syncFromValue;
+    private resetNativeInput;
+    private handleSelectedFiles;
+    private updateErrors;
+    private validateFiles;
+    private mergeErrors;
+    private totalSize;
+    private isAccepted;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputFileUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputFileUploadComponent, "frg-input-file-upload", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "errorMessages": { "alias": "errorMessages"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "maxFiles": { "alias": "maxFiles"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "maxTotalSize": { "alias": "maxTotalSize"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "noFileText": { "alias": "noFileText"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "showFileList": { "alias": "showFileList"; "required": false; }; "showFileSize": { "alias": "showFileSize"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TBaseLoaderStyle = 'primary' | 'secondary' | 'tertiary' | 'dark' | 'light';
+
+type TSpinnerSize = TBaseSize | 'extra-small' | 'extra-large';
+type TSpinnerType = TBaseLoaderStyle;
+
+declare class SpinnerComponent implements OnChanges, OnDestroy {
+    size: TSpinnerSize;
+    isCentered: boolean;
+    isOverlay: boolean;
+    isOverlayItem: boolean;
+    label: string;
+    styleType: TSpinnerType;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private toggleBodyScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "frg-spinner", never, { "size": { "alias": "size"; "required": false; }; "isCentered": { "alias": "isCentered"; "required": false; }; "isOverlay": { "alias": "isOverlay"; "required": false; }; "isOverlayItem": { "alias": "isOverlayItem"; "required": false; }; "label": { "alias": "label"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TProgressBarSize = TBaseSize;
+type TProgressBarType = TBaseLoaderStyle;
+type TProgressBarAnimation = 'fill' | 'slide' | 'pulse' | 'rotate';
+
+declare class ProgressBarComponent implements OnChanges {
+    progress: number;
+    styleType: TProgressBarType;
+    size: TProgressBarSize;
+    showPercentage: boolean;
+    segments: number;
+    animation: TProgressBarAnimation;
+    protected safeProgress: number;
+    segmentsList: Array<number>;
+    filledSegments: number;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "frg-progress-bar", never, { "progress": { "alias": "progress"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showPercentage": { "alias": "showPercentage"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TPulseLoaderSize = TBaseSize;
+type TPulseLoaderType = TBaseLoaderStyle;
+
+/**
+ * Component representing a pulse loader with customizable size, style, and progress display.
+ * Usage example:
+ * ```html
+ * <frg-pulse-loader [progress]="progressValue" [styleType]="'primary'" [size]="'medium'" [showPercentage]="true"></frg-pulse-loader>
+ * ```
+ */
+declare class PulseLoaderComponent implements OnChanges, OnDestroy {
+    /**
+     * ARIA label for accessibility purposes.
+     * Default is 'Loading...'.
+     */
+    ariaLabel: string;
+    isOverlay: boolean;
+    isOverlayItem: boolean;
+    /**
+     * The current progress value (0-100) to be displayed by the loader.
+     */
+    progress: number;
+    /**
+     * The style type of the loader, affecting its color scheme.
+     * Options: 'primary', 'secondary', 'tertiary', 'success', 'warning', 'danger', 'info', 'light', 'dark'
+     */
+    styleType: TPulseLoaderType;
+    /**
+     * The size of the loader.
+     * Options: 'small', 'medium', 'large'
+     */
+    size: TPulseLoaderSize;
+    /**
+     * Whether to display the percentage text inside the loader.
+     * Default is false.
+     */
+    showPercentage: boolean;
+    /**
+     * Gets the CSS classes for the loader based on its size and style type.
+     */
+    get classes(): {
+        [x: string]: boolean;
+        'frg-pulse-loader': boolean;
+        'frg-pulse-loader--overlay': boolean;
+        'frg-pulse-loader--overlay-item': boolean;
+    };
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private toggleBodyScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PulseLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PulseLoaderComponent, "frg-pulse-loader", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "isOverlay": { "alias": "isOverlay"; "required": false; }; "isOverlayItem": { "alias": "isOverlayItem"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showPercentage": { "alias": "showPercentage"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TSkeletonLoaderSize = TBaseSize | 'full';
+type TSkeletonLoaderType = TBaseLoaderStyle | 'default';
+
+declare class SkeletonLoaderComponent {
+    /** Enables shimmer animation */
+    animated: boolean;
+    /** Rectangle height for a single row */
+    height?: string;
+    /** Number of skeleton rows (for multi-line placeholders) */
+    rows: number;
+    /** Shape of the skeleton: rectangle or circle */
+    shape: 'rect' | 'circle';
+    /** Circle size (sets both width & height) */
+    size?: string;
+    /** Style type (color scheme) */
+    styleType: TSkeletonLoaderType;
+    /** Rectangle width (ignored for circle unless explicitly given) */
+    width?: string;
+    get hostClasses(): string;
+    get rowArray(): unknown[];
+    get isMultiRow(): boolean;
+    get isCircle(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonLoaderComponent, "frg-skeleton-loader", never, { "animated": { "alias": "animated"; "required": false; }; "height": { "alias": "height"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "size": { "alias": "size"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ContentBlurComponent implements OnChanges {
+    progress: number;
+    safeProgress: number;
+    ngOnChanges(): void;
+    get blurPx(): number;
+    get blurOpacity(): number;
+    get showProgress(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentBlurComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContentBlurComponent, "frg-content-blur", never, { "progress": { "alias": "progress"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+type SelectionListPosition = 'top' | 'down';
+
+/**
+ * Base class for input components, providing common functionality for form controls.
+ * This class implements ControlValueAccessor to integrate with Angular forms.
+ * Subclasses must implement the abstract methods to update the view and disabled state.
+ * It also provides properties for label, placeholder, required state, and error handling.
+ * The errorMessages property can be customized to provide specific validation messages.
+ * The hasError getter can be used in templates to conditionally display error messages.
+ * Subclasses should call super.ngOnInit() if they override ngOnInit().
+ *
+ * @see ControlValueAccessor
+ */
+declare abstract class SelectionListBase<T> extends InputBase<T> implements ControlValueAccessor, OnInit, OnDestroy {
+    protected readonly dropdownGap = 4;
+    protected readonly dropdownMaxHeight = 240;
+    protected isOpen: boolean;
+    protected dropdownStyles: Record<string, string>;
+    private readonly onViewportChange;
+    /**
+     * Direction of selection list when it opens.
+     */
+    protected openDirection: SelectionListPosition;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onWindowResize(): void;
+    /**
+     * Clear the value of input
+     */
+    protected abstract clearValue(event: Event): void;
+    protected abstract getDropdownAnchorElement(): HTMLElement | null;
+    protected updateDropdownPosition(): void;
+    /**
+     * Handles selection change event.
+     * Subclasses can override to provide custom behavior.
+     * Default implementation does nothing.
+     */
+    protected onSelectionChange(_: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionListBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectionListBase<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+interface SelectionListItem<T> {
+    id: string;
+    label: string;
+    value: T | null;
+    selected: boolean;
+    disabled?: boolean;
+}
+
+declare class SelectionListComponent<T> extends SelectionListBase<T> implements OnChanges {
+    private readonly elementRef;
+    required: boolean;
+    label: string;
+    placeholder: string;
+    showValidation: boolean;
+    items: Array<SelectionListItem<T>>;
+    optionTemplate?: TemplateRef<unknown>;
+    hasSearch: boolean;
+    optionButtons: QueryList<ElementRef<HTMLButtonElement>>;
+    searchInput?: ElementRef<HTMLInputElement>;
+    protected searchTerm: string;
+    protected selectedId: string;
+    private focusedIndex;
+    closeDropdown(event: MouseEvent): void;
+    get filteredItems(): Array<SelectionListItem<T>>;
+    get selectedItem(): SelectionListItem<T> | null;
+    protected get errorList(): string[];
+    /**
+     * Returns warning messages. Consumers may pass arbitrary warnings via `warningMessages`.
+     * Falls back to DEFAULT_INPUT_SELECTION_LIST_WARNINGS_MESSAGES or a generic message.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    toggleDropdown(event: Event): void;
+    selectItem(item: SelectionListItem<T>, event: Event): void;
+    protected clearValue(event: MouseEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onOptionKeyDown(event: KeyboardEvent, item: SelectionListItem<T>, index: number): void;
+    protected onBlur(event: FocusEvent): void;
+    protected onFocus(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected onSearch(event: Event): void;
+    protected onSearchKeyDown(event: KeyboardEvent): void;
+    protected updateDisabledState(_isDisabled: boolean): void;
+    protected updateView(value: T | null): void;
+    protected getDropdownAnchorElement(): HTMLElement | null;
+    private focusFirstItem;
+    private focusNextItem;
+    private focusPreviousItem;
+    private getEnabledButtons;
+    private findItemByValue;
+    private extractComparableId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionListComponent<any>, "frg-selection-list", never, { "required": { "alias": "required"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "items": { "alias": "items"; "required": false; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; }; "hasSearch": { "alias": "hasSearch"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * TBaseStatusStyle
+ *
+ * Represents the allowed visual styles for status-based UI components.
+ * Typically maps to the design system color palette for components like
+ * tags, badges, or chips.
+ *
+ * Available options:
+ * - 'primary'
+ * - 'secondary'
+ * - 'tertiary'
+ * - 'info'
+ * - 'success'
+ * - 'warning'
+ * - 'danger'
+ * - 'dark'
+ * - 'light'
+ */
+type TBaseStatusStyle = 'primary' | 'secondary' | 'tertiary' | 'info' | 'warning' | 'danger' | 'success' | 'dark' | 'light';
+/**
+ * TBaseStatusSize
+ *
+ * Represents the allowed sizes for status-based UI components.
+ * Used to adjust the dimensions and spacing of elements like tags, badges,
+ * or chips.
+ *
+ * Available options:
+ * - 'sm' (small)
+ * - 'md' (medium, default)
+ * - 'lg' (large)
+ */
+type TBaseStatusSize = 'sm' | 'md' | 'lg';
+/**
+ * TBaseStatusIconPosition
+ *
+ * Represents the allowed positions for an icon inside a status-based UI component
+ * such as a tag, badge, or chip.
+ *
+ * Determines whether the icon appears before (start) or after (end) the label.
+ *
+ * Available options:
+ * - 'start' (default) — icon appears before the label
+ * - 'end' — icon appears after the label
+ */
+type TBaseStatusIconPosition = 'start' | 'end';
+
+/**
+ * StatusIndicator
+ *
+ * Base interface for all UI components that represent a status or state.
+ * Provides standardized properties for label, visual style, size, icon, and
+ * interaction state. This interface is intended to be extended by components
+ * such as Tag, Badge, Chip, etc.
+ */
+interface StatusIndicator {
+    /**
+     * Unique identifier for the status element.
+     * Used for tracking, removal, or other programmatic operations.
+     */
+    id: string;
+    /**
+     * Text label displayed within the UI element.
+     */
+    label?: string;
+    /**
+     * Visual style of the element.
+     * Corresponds to the design system status colors.
+     * Example: 'primary', 'secondary', 'success', 'warning', etc.
+     *
+     * @see TBaseStatusStyle
+     */
+    style: TBaseStatusStyle;
+    /**
+     * Optional size of the element.
+     * Should conform to design-system sizing tokens.
+     * Example: 'sm', 'md', 'lg'.
+     *
+     * @see TBaseStatusSize
+     */
+    size?: TBaseStatusSize;
+    /**
+     * Optional icon class displayed before the label.
+     * Example: 'frg-icon-info', 'frg-icon-alert'.
+     */
+    icon?: string;
+    /**
+     * Determines the position of the icon relative to the label in a status-based component
+     * such as a tag, badge, or chip.
+     *
+     * Available options:
+     * - 'start' — icon appears before the label (default)
+     * - 'end' — icon appears after the label
+     *
+     * @see TBaseStatusIconPosition
+     */
+    iconPosition?: TBaseStatusIconPosition;
+    /**
+     * If true, the element is disabled and user interactions are blocked.
+     */
+    disabled?: boolean;
+}
+
+/**
+ * ChipType
+ *
+ * Alias for `TBaseStatusStyle`.
+ * Represents the visual style of a chip according to the design system.
+ * Example: 'primary', 'secondary', 'success', etc.
+ */
+type TChipType = TBaseStatusStyle;
+/**
+ * ChipSize
+ *
+ * Alias for `TBaseStatusSize`.
+ * Defines the size of the chip. Options: 'sm', 'md', 'lg'.
+ */
+type TChipSize = TBaseStatusSize;
+/**
+ * ChipIconPosition
+ *
+ * Alias for `TBaseStatusIconPosition`.
+ * Defines the icon position of the icon in the chip. Options: 'start' or 'end'.
+ */
+type TChipIconPosition = TBaseStatusIconPosition;
+/**
+ * chip
+ *
+ * A UI element that extends the shared `StatusIndicator` interface.
+ * Represents a labeled status, optionally removable.
+ *
+ * @extends StatusIndicator
+ */
+interface Chip extends StatusIndicator {
+    /**
+     * If true, the tag can be removed by the user.
+     * Triggers the `removed` event in the component.
+     */
+    removable?: boolean;
+}
+
+declare class MultiSelectComponent<T> extends SelectionListBase<Array<T>> implements OnChanges {
+    private readonly elementRef;
+    required: boolean;
+    label: string;
+    placeholder: string;
+    showValidation: boolean;
+    items: Array<SelectionListItem<T>>;
+    hasSearch: boolean;
+    optionTemplate?: TemplateRef<unknown>;
+    valuesTemplate?: TemplateRef<unknown>;
+    showChips: boolean;
+    chipsStyle: TChipType;
+    optionButtons: QueryList<ElementRef<HTMLButtonElement>>;
+    searchInput?: ElementRef<HTMLInputElement>;
+    protected searchTerm: string;
+    protected selectedIds: Array<string>;
+    private focusedIndex;
+    closeDropdown(event: MouseEvent): void;
+    get filteredItems(): Array<SelectionListItem<T>>;
+    get selectedLabels(): string;
+    get selectedItems(): Array<SelectionListItem<T>>;
+    protected get errorList(): string[];
+    toggleDropdown(event: Event): void;
+    selectItem(item: SelectionListItem<T>, event: Event): void;
+    protected removeItem(item: SelectionListItem<T>, event: MouseEvent): void;
+    protected removeItemById(id: string): void;
+    protected clearValue(event: MouseEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onOptionKeyDown(event: KeyboardEvent, item: SelectionListItem<T>, index: number): void;
+    protected onBlur(event: FocusEvent): void;
+    protected onFocus(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected onSearch(event: Event): void;
+    protected onSearchKeyDown(event: KeyboardEvent): void;
+    protected updateDisabledState(_isDisabled: boolean): void;
+    protected updateSelection(item: SelectionListItem<T>, isAlreadySelected: boolean): void;
+    protected updateView(value: Array<T> | null): void;
+    protected getDropdownAnchorElement(): HTMLElement | null;
+    private focusFirstItem;
+    private focusNextItem;
+    private focusPreviousItem;
+    private getEnabledButtons;
+    private findItemByValue;
+    private extractComparableId;
+    /**
+     * Returns warning messages. Consumers may pass arbitrary warnings via `warningMessages`.
+     * Falls back to DEFAULT_INPUT_MULTI_SELECT_WARNINGS_MESSAGES or a generic message.
+     */
+    protected get warningList(): string[];
+    /**
+     * Returns whether any warnings are active.
+     */
+    protected get hasWarning(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiSelectComponent<any>, "frg-multi-select", never, { "required": { "alias": "required"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "showValidation": { "alias": "showValidation"; "required": false; }; "items": { "alias": "items"; "required": false; }; "hasSearch": { "alias": "hasSearch"; "required": false; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; }; "valuesTemplate": { "alias": "valuesTemplate"; "required": false; }; "showChips": { "alias": "showChips"; "required": false; }; "chipsStyle": { "alias": "chipsStyle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * TagType
+ *
+ * Alias for `TBaseStatusStyle`.
+ * Represents the visual style of a tag according to the design system.
+ * Example: 'primary', 'secondary', 'success', etc.
+ */
+type TTagType = TBaseStatusStyle;
+/**
+ * TagSize
+ *
+ * Alias for `TBaseStatusSize`.
+ * Defines the size of the tag. Options: 'sm', 'md', 'lg'.
+ */
+type TTagSize = TBaseStatusSize;
+/**
+ * TagIconPosition
+ *
+ * Alias for `TBaseStatusIconPosition`.
+ * Defines the icon position of the icon in the tag. Options: 'start' or 'end'.
+ */
+type TTagIconPosition = TBaseStatusIconPosition;
+/**
+ * Tag
+ *
+ * A UI element that extends the shared `StatusIndicator` interface.
+ * Represents a labeled status, optionally removable.
+ *
+ * @extends StatusIndicator
+ */
+interface Tag extends StatusIndicator {
+    /**
+     * If true, the tag can be removed by the user.
+     * Triggers the `removed` event in the component.
+     */
+    removable?: boolean;
+}
+
+/**
+ * TagComponent
+ *
+ * A small UI element used to display labeled statuses, metadata, or categories.
+ * Supports icons, removable behavior, disabled state, and standardized design-
+ * system styles and sizes. Implements the shared `Tag` interface to ensure
+ * consistency across all status-driven UI components (Tag, Badge, Chip, etc.).
+ */
+declare class TagComponent implements Tag {
+    /**
+     * Unique identifier for the tag.
+     * Automatically generated if not provided by the parent.
+     * Used primarily for tracking and removal events.
+     */
+    id: string;
+    /**
+     * Text content displayed inside the tag.
+     */
+    label?: string;
+    /**
+     * Visual style of the tag.
+     * Corresponds to design-system status color tokens.
+     * Example: 'primary', 'secondary', 'success', 'warning', etc.
+     */
+    style: TTagType;
+    /**
+     * Size variant of the tag.
+     * Options follow the standardized sizing tokens: 'sm', 'md', or 'lg'.
+     */
+    size: TTagSize;
+    /**
+     * Optional icon class displayed before the label.
+     * Example: 'frg-icon-info', 'frg-icon-alert'.
+     */
+    icon: string | undefined;
+    /**
+     *  Position of the icon
+     */
+    iconPosition: TTagIconPosition;
+    /**
+     * Whether the tag is disabled.
+     * Disables interactions and applies the disabled visual style.
+     */
+    disabled: boolean;
+    /**
+     * If true, displays a remove button allowing the tag to be dismissed.
+     */
+    removable: boolean;
+    /**
+     * Emits the ID of the tag when it is removed.
+     */
+    removed: EventEmitter<string>;
+    /**
+     * Emits the `removed` event when the remove button is clicked,
+     * provided the tag is not disabled and removal is allowed.
+     */
+    onRemove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagComponent, "frg-tag", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "style": { "alias": "style"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; }, { "removed": "removed"; }, never, never, true, never>;
+}
+
+/**
+ * TagComponent
+ *
+ * A small UI element used to display labeled statuses, metadata, or categories.
+ * Supports icons, removable behavior, disabled state, and standardized design-
+ * system styles and sizes. Implements the shared `Tag` interface to ensure
+ * consistency across all status-driven UI components (Tag, Badge, Chip, etc.).
+ */
+declare class ChipComponent implements Chip {
+    /**
+     * Unique identifier for the chip.
+     * Automatically generated if not provided by the parent.
+     * Used primarily for tracking and removal events.
+     */
+    id: string;
+    /**
+     * Text content displayed inside the chip.
+     */
+    label?: string;
+    /**
+     * Visual style of the chip.
+     * Corresponds to design-system status color tokens.
+     * Example: 'primary', 'secondary', 'success', 'warning', etc.
+     */
+    style: TChipType;
+    /**
+     * Size variant of the chip.
+     * Options follow the standardized sizing tokens: 'sm', 'md', or 'lg'.
+     */
+    size: TChipSize;
+    /**
+     * Optional icon class displayed before the label.
+     * Example: 'frg-icon-info', 'frg-icon-alert'.
+     */
+    icon: string | undefined;
+    /**
+     *  Position of the icon
+     */
+    iconPosition: TChipIconPosition;
+    /**
+     * Whether the chip is disabled.
+     * Disables interactions and applies the disabled visual style.
+     */
+    disabled: boolean;
+    /**
+     * If true, displays a remove button allowing the chip to be dismissed.
+     */
+    removable: boolean;
+    /**
+     * Emits the ID of the chip when it is removed.
+     */
+    removed: EventEmitter<string>;
+    /**
+     * Emits the `removed` event when the remove button is clicked,
+     * provided the chip is not disabled and removal is allowed.
+     */
+    onRemove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChipComponent, "frg-chip", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "style": { "alias": "style"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; }, { "removed": "removed"; }, never, never, true, never>;
+}
+
+/**
+ * TagType
+ *
+ * Alias for `TBaseStatusStyle`.
+ * Represents the visual style of a tag according to the design system.
+ * Example: 'primary', 'secondary', 'success', etc.
+ */
+type TPillType = TBaseStatusStyle;
+/**
+ * PillSize
+ *
+ * Alias for `TBaseStatusSize`.
+ * Defines the size of the pill. Options: 'sm', 'md', 'lg'.
+ */
+type TPillSize = TBaseStatusSize;
+/**
+ * PillIconPosition
+ *
+ * Alias for `TBaseStatusIconPosition`.
+ * Defines the icon position of the icon in the pill. Options: 'start' or 'end'.
+ */
+type TPillIconPosition = TBaseStatusIconPosition;
+/**
+ * Pill
+ *
+ * A UI element that extends the shared `StatusIndicator` interface.
+ * Represents a labeled status, optionally removable.
+ *
+ * @extends StatusIndicator
+ */
+interface Pill extends StatusIndicator {
+    /**
+     * If true, the pill can be removed by the user.
+     * Triggers the `removed` event in the component.
+     */
+    removable?: boolean;
+}
+
+/**
+ * TagComponent
+ *
+ * A small UI element used to display labeled statuses, metadata, or categories.
+ * Supports icons, removable behavior, disabled state, and standardized design-
+ * system styles and sizes. Implements the shared `Tag` interface to ensure
+ * consistency across all status-driven UI components (Tag, Badge, Chip, etc.).
+ */
+declare class PillComponent implements Pill {
+    /**
+     * Unique identifier for the tag.
+     * Automatically generated if not provided by the parent.
+     * Used primarily for tracking and removal events.
+     */
+    id: string;
+    /**
+     * Text content displayed inside the tag.
+     */
+    label?: string;
+    /**
+     * Visual style of the pill.
+     * Corresponds to design-system status color tokens.
+     * Example: 'primary', 'secondary', 'success', 'warning', etc.
+     */
+    style: TPillType;
+    /**
+     * Size variant of the pill.
+     * Options follow the standardized sizing tokens: 'sm', 'md', or 'lg'.
+     */
+    size: TPillSize;
+    /**
+     * Optional icon class displayed before the label.
+     * Example: 'frg-icon-info', 'frg-icon-alert'.
+     */
+    icon: string | undefined;
+    /**
+     *  Position of the icon
+     */
+    iconPosition: TPillIconPosition;
+    /**
+     * Whether the pill is disabled.
+     * Disables interactions and applies the disabled visual style.
+     */
+    disabled: boolean;
+    /**
+     * If true, displays a remove button allowing the pill to be dismissed.
+     */
+    removable: boolean;
+    /**
+     * Emits the ID of the pill when it is removed.
+     */
+    removed: EventEmitter<string>;
+    /**
+     * Emits the `removed` event when the remove button is clicked,
+     * provided the tag is not disabled and removal is allowed.
+     */
+    onRemove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PillComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PillComponent, "frg-pill", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "style": { "alias": "style"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; }, { "removed": "removed"; }, never, never, true, never>;
+}
+
+interface GalaxyConfig {
+    arms?: number;
+    starsPerArm?: number;
+    radius?: number;
+    rotationSpeed?: number;
+    coreRadius?: number;
+    colors?: {
+        star?: string;
+        corePrimary?: string;
+        coreSecondary?: string;
+    };
+    starsSize?: {
+        min?: number;
+        max?: number;
+    };
+    animations?: {
+        pulseIntensity?: number;
+        turbulenceIntensity?: number;
+        flickerSpeed?: number;
+        hasPulse?: boolean;
+        hasStaggerDelay?: boolean;
+    };
+}
+interface Star {
+    x: number;
+    y: number;
+    s: number;
+    o: number;
+    color: string;
+}
+
+declare const DEFAULT_CONFIG: DeepRequired<GalaxyConfig>;
+declare class GalaxyComponent implements AfterViewInit, OnDestroy {
+    imageUrl: i0.InputSignal<string | null>;
+    config: i0.InputSignal<GalaxyConfig>;
+    readonly c: i0.Signal<DeepRequired<GalaxyConfig>>;
+    readonly galaxyId: string;
+    private readonly animations;
+    spiralGroup: i0.Signal<ElementRef<SVGGElement> | undefined>;
+    coreElement: i0.Signal<ElementRef<SVGGElement> | undefined>;
+    coreTurbFilter: i0.Signal<ElementRef<SVGFETurbulenceElement> | undefined>;
+    stars: i0.Signal<Star[]>;
+    ngAfterViewInit(): void;
+    private startAnimations;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GalaxyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GalaxyComponent, "frg-galaxy", never, { "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type TNebulaBlendMode = 'screen' | 'multiply' | 'overlay' | 'color-dodge' | 'soft-light';
+
+interface NebulaColors {
+    palette?: string[];
+    background?: string;
+}
+interface NebulaCoreConfig {
+    radius?: number;
+    opacity?: number;
+    maskOffsetStart?: string;
+    maskOffsetEnd?: string;
+}
+interface NebulaAnimations {
+    speed?: number;
+    nebulaOpacity?: Array<number>;
+    turbulenceIntensity?: number;
+    coreTurbulenceIntensity?: number;
+    driftRange?: number;
+    hasAnimation?: boolean;
+}
+interface NebulaBlob {
+    x: number;
+    y: number;
+    r: number;
+    color: string;
+}
+interface NebulaConfig {
+    density?: number;
+    blurIntensity?: number;
+    radius?: number;
+    blendMode?: TNebulaBlendMode;
+    colors?: NebulaColors;
+    core?: NebulaCoreConfig;
+    animations?: NebulaAnimations;
+}
+
+declare const NEBULA_DEFAULT_CONFIG: DeepRequired<NebulaConfig>;
+declare class NebulaComponent implements AfterViewInit, OnDestroy {
+    imageUrl: i0.InputSignal<string | null>;
+    config: i0.InputSignal<NebulaConfig>;
+    readonly nebulaId: string;
+    private readonly animations;
+    blobGroup: i0.Signal<ElementRef<SVGGElement> | undefined>;
+    turbFilter: i0.Signal<ElementRef<SVGFETurbulenceElement> | undefined>;
+    coreTurbFilter: i0.Signal<ElementRef<SVGFETurbulenceElement> | undefined>;
+    maskCircle: i0.Signal<ElementRef<SVGCircleElement> | undefined>;
+    readonly c: i0.Signal<DeepRequired<NebulaConfig>>;
+    blobs: i0.Signal<NebulaBlob[]>;
+    ngAfterViewInit(): void;
+    private startAnimations;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NebulaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NebulaComponent, "frg-nebula", never, { "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare abstract class MorphBase {
+    protected imageUrl: string | null;
+    protected fillColor: string | null;
+    protected pathStart: string;
+    protected pathEnd: string;
+    protected duration: number;
+    protected abstract generateRandomPath(points: number, radius: number, variability: number): string;
+}
+
+declare class BlobMorphComponent extends MorphBase implements AfterViewInit {
+    private readonly fragnimateService;
+    imageUrl: string | null;
+    fillColor: string | null;
+    pathStart: string;
+    pathEnd: string;
+    duration: number;
+    loadEvent: EventEmitter<void>;
+    morphPathRef: ElementRef<SVGPathElement>;
+    clipId: string;
+    protected isLoaded: boolean;
+    ngAfterViewInit(): void;
+    protected generateRandomPath(points?: number, radius?: number, variability?: number): string;
+    onLoadEvent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlobMorphComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlobMorphComponent, "frg-blob-morph", never, { "imageUrl": { "alias": "imageUrl"; "required": false; }; "fillColor": { "alias": "fillColor"; "required": false; }; "pathStart": { "alias": "pathStart"; "required": false; }; "pathEnd": { "alias": "pathEnd"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; }, { "loadEvent": "loadEvent"; }, never, never, true, never>;
+}
+
+type SizeValue = number | string | null;
+interface ISparkleConfiguration {
+    x: number;
+    y: number;
+    size: number;
+    delay: number;
+    duration: number;
+    driftX: number;
+    driftY: number;
+}
+
+declare class SparkleSectionComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
+    private readonly fragnimateService;
+    width: SizeValue;
+    height: SizeValue;
+    count: number;
+    minSize: number;
+    maxSize: number;
+    drift: number;
+    minDuration: number;
+    maxDuration: number;
+    loop: boolean;
+    color: string | null;
+    intensity: number;
+    sparkles: ISparkleConfiguration[];
+    sparkleRefs: QueryList<ElementRef<HTMLSpanElement>>;
+    private animations;
+    private changesSub;
+    get hostWidth(): string | null;
+    get hostHeight(): string | null;
+    get sparkleColorVar(): string | null;
+    get sparkleIntensityVar(): string;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private buildSparkles;
+    private restartAnimation;
+    private rand;
+    private formatSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SparkleSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SparkleSectionComponent, "frg-sparkle-section", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "count": { "alias": "count"; "required": false; }; "minSize": { "alias": "minSize"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "drift": { "alias": "drift"; "required": false; }; "minDuration": { "alias": "minDuration"; "required": false; }; "maxDuration": { "alias": "maxDuration"; "required": false; }; "loop": { "alias": "loop"; "required": false; }; "color": { "alias": "color"; "required": false; }; "intensity": { "alias": "intensity"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface ITooltipLinkAction {
+    link: string;
+    target: '_self' | '_blank' | '_parent' | '_top';
+}
+interface ITooltipEventAction<T = any> {
+    clickEvent: GenericFunction<T>;
+}
+interface IConfigTooltip {
+    text: string;
+    textContent?: string;
+    apply?: boolean;
+    hideIndicator?: boolean;
+    position?: TooltipPosition;
+    gap?: number;
+}
+interface IConfigTooltipPopover extends IConfigTooltip {
+    buttonConfig: IConfigTooltipButtton;
+}
+interface IConfigTooltipButtton {
+    text: string;
+    action: TBehaviourAction<ITooltipLinkAction, ITooltipEventAction>;
+}
+
+declare class FragmentsTooltipDirective implements OnDestroy {
+    private readonly elemRef;
+    private readonly renderer;
+    tooltipConfig: IConfigTooltip;
+    tooltip: HTMLElement | undefined;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    ngOnDestroy(): void;
+    private show;
+    private hide;
+    private initTooltip;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FragmentsTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FragmentsTooltipDirective, "[frgTooltip]", never, { "tooltipConfig": { "alias": "tooltipConfig"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FragmentsPopoverDirective implements OnDestroy {
+    private readonly elemRef;
+    private readonly renderer;
+    popoverConfig: IConfigTooltipPopover;
+    popover: HTMLElement | undefined;
+    onClick(event: MouseEvent): void;
+    onDocumentClick(): void;
+    onEscape(): void;
+    ngOnDestroy(): void;
+    private close;
+    private show;
+    private hide;
+    private initPopover;
+    private handleAction;
+    private setPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FragmentsPopoverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FragmentsPopoverDirective, "[frgPopover]", never, { "popoverConfig": { "alias": "popoverConfig"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface Badge extends Partial<StatusIndicator> {
+    /**
+     * Badge numeric or string value.
+     * If null or undefined and `dot` is false → badge is hidden.
+     */
+    value?: string | number | null;
+    /**
+     * Dot mode: shows only a small circular indicator.
+     */
+    dot?: boolean;
+    /**
+     * Determines whether the badge is hidden.
+     */
+    hidden?: boolean;
+}
+
+declare class FrgBadgeDirective implements OnChanges, OnDestroy {
+    private readonly host;
+    private readonly renderer;
+    /**
+     * Badge configuration object.
+     */
+    badge: Badge;
+    /**
+     * Reference to the badge HTML element.
+     */
+    private badgeEl?;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Cleans up the badge element when the directive is destroyed.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Updates the badge element based on the current badge configuration.
+     * Creates, updates, or removes the badge as necessary.
+     */
+    private updateBadge;
+    /**
+     * Creates the badge HTML element and appends it to the host element.
+     * Initializes the badge with the base class.
+     */
+    private createBadge;
+    /**
+     * Updates the content of the badge element based on the badge configuration.
+     * Handles dot mode, icon placement, and value display.
+     */
+    private updateBadgeContent;
+    /**
+     * Creates the icon element with all classes
+     */
+    private createIconElement;
+    /**
+     * Append value first, then icon
+     */
+    private appendValueThenIcon;
+    /**
+     * Append icon first, then value
+     */
+    private appendIconThenValue;
+    /**
+     * Updates the CSS classes of the badge element based on the badge configuration.
+     * Applies size, style, and dot mode classes.
+     */
+    private updateBadgeClasses;
+    /**
+     * Removes the badge element from the host element and clears the reference.
+     * Used when the badge should be hidden.
+     */
+    private removeBadge;
+    /**
+     * Determines whether the badge should be hidden based on its configuration.
+     * Returns true if the badge is marked as hidden or has no value in non-dot mode.
+     */
+    private shouldHide;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FrgBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FrgBadgeDirective, "[frgBadge]", never, { "badge": { "alias": "badge"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function sortTable<T>(fullData: T[], direction: EnumDirectionSortTable, fieldOrder: string | string[]): T[];
+
+declare class FieldArrayPositionPipe implements PipeTransform {
+    transform(value: any, args: any[] | any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldArrayPositionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FieldArrayPositionPipe, "fieldArrayPosition", true>;
+}
+declare class TypeOfArrayPipe implements PipeTransform {
+    transform(value: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TypeOfArrayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TypeOfArrayPipe, "typeOfArray", true>;
+}
+declare class DynamicPipe implements PipeTransform {
+    private readonly injector;
+    transform(value: any, pipeToken: any, pipeArgs?: any[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DynamicPipe, "dynamicPipe", true>;
+}
+
+declare class SanitizeHtmlPipe implements PipeTransform {
+    _sanitizer: DomSanitizer;
+    transform(v: string | number | null | undefined): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SanitizeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SanitizeHtmlPipe, "sanitizeHtml", true>;
+}
+
+declare class SafeHtmlPipe implements PipeTransform {
+    private readonly sanitizer;
+    transform(value: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+
+declare class ChunkPipe implements PipeTransform {
+    transform<T>(array: T[], size: number): T[][];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChunkPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ChunkPipe, "chunk", true>;
+}
+
+type TypeForm<T> = {
+    [K in keyof T]: FormControl<T[K]>;
+};
+
+type direction = 'asc' | 'desc';
+declare function generateId(value?: string): string;
+declare function generateNumberId(): number;
+declare function isObjectEmpty(obj: any): boolean;
+declare function paginationList<T>(lista: Array<T>, pageSize: number, page: number): T[];
+declare function orderList<T>(lista: Array<T>, orderFields: any, direction: direction): T[];
+declare function getActivatedRouteChild(activatedRoute: ActivatedRoute): ActivatedRoute;
+/**
+ * Performs a deep merge of two objects.
+ * It recursively merges nested objects but overwrites arrays and primitive values.
+ * @param target - The base object with default values.
+ * @param source - The source object with overrides.
+ * @returns A new object containing the merged properties.
+ */
+declare function deepMerge<T extends object>(target: T, source: Partial<T> | any): T;
+
+/**
+ * Normalizes the value of an <input type="number">.
+ *
+ * - Returns a valid number if the input contains a numeric value
+ * - Returns null if the input is empty or not a valid number
+ *
+ * This helper ensures consistency between the raw input value
+ * and the form control value, preventing unintended NaN values.
+ *
+ * @param input The HTML input element of type "number"
+ * @returns number | null
+ */
+declare function normalizeNumber(input: HTMLInputElement): number | null;
+
+/**
+ * Generates a RFC4122 version 4 UUID string.
+ * Uses the 'uuid' library for guaranteed uniqueness.
+ * @returns {string} A UUID v4 string.
+ */
+declare function generateUUID(): string;
+/**
+ * Returns the current timestamp in ISO 8601 format.
+ * Useful for logging or time-stamping events in a standardized way.
+ * @returns {string} Current date-time as ISO string.
+ */
+declare function getTimestampISO(): string;
+/**
+ * Returns the current timestamp in milliseconds since Unix epoch.
+ * Useful for performance measurements or relative time calculations.
+ * @returns {number} Current timestamp in milliseconds.
+ */
+declare function getTimestampMillis(): number;
+/**
+ * Generates a simple unique ID string with an optional prefix.
+ * Uses random alphanumeric characters and current time for uniqueness.
+ * Good for quick IDs that don't require strict UUID format.
+ * @param {string} prefix Optional string prefix (default: 'id').
+ * @returns {string} Unique ID string with prefix.
+ */
+declare function generateUniqueId(prefix?: string): string;
+
+type TextSplitterSelector = HTMLElement | NodeList | string | Array<HTMLElement>;
+type AnimationTrigger = 'immediate' | 'enter';
+type TextAnimationType = 'chars' | 'words' | 'lines';
+
+interface FragnimateBaseAnimation {
+    animate(targets: TargetsParam, parameters: AnimationParams): JSAnimation;
+    createAnimatable(targets: TargetsParam, params: AnimatableParams): AnimatableObject;
+    createDraggable(targets: TargetsParam, params?: DraggableParams): Draggable;
+    createLayout(root: DOMTargetSelector, params?: AutoLayoutParams): AutoLayout;
+    createScope(params?: ScopeParams): Scope;
+    createTimeline(params?: TimelineParams): Timeline;
+    createTimer(params?: TimerParams): Timer;
+    splitText(targets: TextSplitterSelector, params: TextSplitterParams): TextSplitter;
+}
+interface FragnimateParams {
+    animation?: AnimationParams;
+    trigger?: AnimationTrigger;
+    disabled?: boolean;
+    repeat?: boolean;
+    treshold?: number;
+}
+interface FragnimateHoverParams {
+    hoverAnimation?: AnimationParams;
+    hoverOutAnimation?: AnimationParams;
+    disabled?: boolean;
+}
+interface FragnimateComponentParams {
+    enterAnimation?: AnimationParams;
+    hoverAnimation?: AnimationParams;
+    hoverOutAnimation?: AnimationParams;
+    trigger?: AnimationTrigger;
+    disabled?: boolean;
+    repeat?: boolean;
+    treshold?: number;
+}
+interface FragnimateStaggerParams extends FragnimateParams {
+    stagger?: number;
+}
+interface FragnimateTextParams extends FragnimateStaggerParams {
+    type?: TextAnimationType;
+    splitterParams?: TextSplitterParams;
+}
+interface FragnimateTimelineParams extends FragnimateParams {
+    animations?: Array<AnimationParams>;
+    timelineParams?: TimelineParams;
+    stagger?: number;
+}
+
+declare class FragmentsAnimateService implements FragnimateBaseAnimation {
+    /**
+     * Animates the given targets with the specified parameters.
+     * @param targets The targets to animate.
+     * @param params The animation parameters.
+     * @returns The created JSAnimation instance.
+     *
+     * @see TargetsParam https://animejs.com/documentation/#targets
+     * @see AnimationParams https://animejs.com/documentation/#animationParameters
+     * @see JSAnimation https://animejs.com/documentation/#jsAnimation
+     */
+    animate(targets: TargetsParam, params: AnimationParams): JSAnimation;
+    createAnimatable(targets: TargetsParam, params: AnimatableParams): AnimatableObject;
+    createDraggable(targets: TargetsParam, params?: DraggableParams): Draggable;
+    createLayout(root: DOMTargetSelector, params?: AutoLayoutParams): AutoLayout;
+    createScope(params?: ScopeParams): Scope;
+    createTimeline(params?: TimelineParams): Timeline;
+    createTimer(params?: TimerParams): Timer;
+    splitText(targets: TextSplitterSelector, params: TextSplitterParams): TextSplitter;
+    addEffect(textSplitter: TextSplitter, effect: (...args: any[]) => Tickable | (() => void)): void | TextSplitter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FragmentsAnimateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FragmentsAnimateService>;
+}
+
+/**
+ * Core directive to animate DOM elements with Anime.js.
+ *
+ * Supports:
+ * - immediate trigger
+ * - enter viewport trigger
+ * - repeatable animation on re-entry
+ * - disabled state
+ *
+ * Example usage:
+ * ```html
+ * <div
+ *   frgAnimate
+ *   [params]="fadeUp"
+ * ></div>
+ * ```
+ */
+declare class AnimateDirective implements OnDestroy {
+    /**
+     * Anime.js animation parameters and options
+     */
+    params: i0.InputSignal<FragnimateParams | null>;
+    /** Reference to the host DOM element */
+    private readonly elementRef;
+    /** Service wrapper for Anime.js */
+    private readonly animator;
+    /** Reference to the current animation instance */
+    private animationRef?;
+    /** IntersectionObserver for enter trigger */
+    private observer?;
+    /** Tracks whether the animation has started */
+    private readonly started;
+    /**
+     * Reactive effect to handle animation triggering
+     */
+    constructor();
+    /**
+     * Cleanup on directive destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Starts the animation on the host element
+     *
+     * @param params Anime.js animation parameters
+     */
+    private start;
+    /**
+     * Sets up IntersectionObserver to trigger animation when element enters viewport
+     */
+    private observeEnter;
+    /**
+     * Handles the element entering the viewport
+     */
+    private onEnter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AnimateDirective, "[frgAnimate]", never, { "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive to animate an element on hover (mouseenter / mouseleave).
+ *
+ * Example usage:
+ * ```html
+ * <div
+ *   frgHoverAnimate
+ *   [params]="hoverParams"
+ * ></div>
+ * ```
+ *
+ * Inputs:
+ * - `params` → `FragnimateHoverParams` object containing hoverAnimation, hoverOutAnimation, and disabled properties
+ */
+declare class HoverAnimateDirective implements OnDestroy {
+    /** Animation parameters applied on mouse enter */
+    params: i0.InputSignal<FragnimateHoverParams | null>;
+    /** Signal to track hover state */
+    isHovered: i0.WritableSignal<boolean>;
+    /** Reference to the host element */
+    private readonly elementRef;
+    /** Service wrapper for Anime.js animations */
+    private readonly animator;
+    /** Store active animations to allow pausing */
+    private readonly animations;
+    /**
+     * Sets up event listeners and reactive effect for hover animations.
+     * Automatically pauses previous animations before starting a new one.
+     */
+    constructor();
+    /**
+     * Lifecycle hook: pause all active animations when the directive is destroyed
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HoverAnimateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HoverAnimateDirective, "[frgHoverAnimate]", never, { "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that animates child elements sequentially using Anime.js stagger.
+ *
+ * Supports:
+ * - immediate trigger
+ * - enter / leave viewport trigger
+ * - animation revert on exit
+ * - repeatable animations
+ */
+declare class StaggerAnimateDirective implements OnDestroy {
+    /**
+     * Stagger animation params
+     */
+    params: i0.InputSignal<FragnimateStaggerParams | null>;
+    /**
+     * Reference to the host DOM element
+     */
+    private readonly elementRef;
+    /**
+     * Service wrapper around Anime.js
+     */
+    private readonly animator;
+    /**
+     * Active Anime.js animation instances
+     */
+    private readonly animations;
+    /**
+     * IntersectionObserver used for enter / leave detection
+     */
+    private observer?;
+    /**
+     * Tracks whether the element is currently animated (visible state)
+     */
+    private readonly started;
+    /**
+     * Reactive effect that handles animation triggering logic
+     */
+    constructor();
+    /**
+     * Cleanup on directive destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Starts staggered animations on all direct children
+     *
+     * @param params Anime.js animation parameters
+     */
+    private startStagger;
+    /**
+     * Reverts all animations and resets internal state
+     */
+    private resetAnimations;
+    /**
+     * Sets up IntersectionObserver to trigger animations
+     * on enter and revert them on leave
+     */
+    private observeEnter;
+    /**
+     * Handles element entering the viewport
+     *
+     * @param repeat Whether the animation should repeat
+     */
+    private onEnter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StaggerAnimateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StaggerAnimateDirective, "[frgStaggerAnimate]", never, { "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive to animate a component or DOM subtree with enter and hover animations.
+ *
+ * Supports:
+ * - Immediate or enter-triggered animation
+ * - Hover in/out animations
+ * - Optional repeat for enter-triggered animation
+ */
+declare class ComponentAnimateDirective implements OnDestroy {
+    /**
+     * Anime.js parameters for enter animation
+     */
+    params: i0.InputSignal<FragnimateComponentParams | null>;
+    /**
+     * Reference to the host DOM element
+     */
+    private readonly elementRef;
+    /**
+     * Service wrapper around Anime.js
+     */
+    private readonly animator;
+    /**
+     * Active Anime.js animation instances
+     */
+    private readonly animations;
+    /**
+     * IntersectionObserver for enter-triggered animation
+     */
+    private observer?;
+    /**
+     * Track hover state
+     */
+    private readonly isHovered;
+    /**
+     * Track enter animation started state
+     */
+    private readonly started;
+    /**
+     * Initialize directive: run enter animation effect and attach hover listeners
+     */
+    constructor();
+    /**
+     * Cleanup on directive destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Start the enter animation if available and not already started
+     */
+    private startEnter;
+    /**
+     * Attach hover enter/leave listeners to host element
+     */
+    private setupHover;
+    /**
+     * Observe the host element entering the viewport and trigger enter animation
+     * Handles elements already in viewport on load
+     */
+    private observeEnter;
+    /**
+     * Handles element entering the viewport
+     * @param repeat Whether the animation should repeat
+     */
+    private onEnter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentAnimateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComponentAnimateDirective, "[frgComponentAnimate]", never, { "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive to orchestrate multiple child animations sequentially using Anime.js timeline.
+ *
+ * Supports:
+ * - Immediate or enter-triggered animation
+ * - Optional repeat on viewport re-entry
+ * - Stagger timing between children
+ * - Respecting existing `delay` in each AnimationParams (number or function)
+ *
+ * Example usage:
+ * ```html
+ * <div
+ *   frgTimelineAnimate
+ *   [animations]="timelineAnimations"
+ *   [stagger]="100"
+ *   trigger="enter"
+ *   [repeat]="true"
+ * ></div>
+ * ```
+ */
+declare class TimelineAnimateDirective implements OnDestroy {
+    /** Array of animations applied to each child element */
+    params: i0.InputSignal<FragnimateTimelineParams | null>;
+    /** Host element reference */
+    private readonly elementRef;
+    /** Anime.js wrapper service */
+    private readonly animator;
+    /** Current Anime.js Timeline */
+    private timeline?;
+    /** IntersectionObserver for enter trigger */
+    private observer?;
+    /** Tracks if timeline has started */
+    private readonly started;
+    constructor();
+    ngOnDestroy(): void;
+    /** Create timeline and add staggered animations to each child */
+    private startTimeline;
+    /** Observe host element entering viewport and trigger timeline */
+    private observeEnter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineAnimateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TimelineAnimateDirective, "[frgTimelineAnimate]", never, { "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Animate text content using Anime.js splitText.
+ *
+ * Supports chars, words, or lines animation with stagger,
+ * preserving layout, font size, spacing and inline styles.
+ */
+declare class TextAnimateDirective implements OnDestroy {
+    /** Anime.js animation parameters */
+    params: i0.InputSignal<FragnimateTextParams | null>;
+    private readonly elementRef;
+    private readonly animator;
+    private splitter?;
+    private animationInstance?;
+    private observer?;
+    private readonly started;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Build proper Anime.js splitText params
+     */
+    private buildSplitParams;
+    /**
+     * Starts the text animation
+     */
+    private start;
+    /**
+     * Resets animation and DOM
+     */
+    private reset;
+    /**
+     * Observe viewport entry
+     */
+    private observeEnter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextAnimateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TextAnimateDirective, "[frgTextAnimate]", never, { "params": { "alias": "params"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AccordionComponent, AnimateDirective, BlobMorphComponent, BreadcrumbComponent, ButtonComponent, CardComponent, ChipComponent, ChunkPipe, CodeBlockComponent, ComponentAnimateDirective, ContainerComponent, ContentBlurComponent, DEFAULT_CONFIG, DividerComponent, DynamicPipe, EnumDirectionSortTable, FieldArrayPositionPipe, FragmentsAnimateService, FragmentsPopoverDirective, FragmentsTooltipDirective, FrgBadgeDirective, GalaxyComponent, HoverAnimateDirective, InputCalendarComponent, InputCheckboxComponent, InputCheckboxGroupComponent, InputClockPickerComponent, InputDateComponent, InputDateTimeComponent, InputFileUploadComponent, InputNumberComponent, InputRadioGroupComponent, InputRichTextComponent, InputSliderComponent, InputTextComponent, InputTextareaComponent, InputTimeComponent, InputToggleSwitchComponent, InputValidationComponent, ModalComponent, MultiSelectComponent, NEBULA_DEFAULT_CONFIG, NebulaComponent, PillComponent, ProgressBarComponent, PulseLoaderComponent, SafeHtmlPipe, SanitizeHtmlPipe, SectionComponent, SelectionListComponent, SeparatorComponent, SideNavComponent, SkeletonLoaderComponent, SmallPaginationComponent, SnackbarComponent, SparkleSectionComponent, SpinnerComponent, StaggerAnimateDirective, StepperComponent, TableComponent, TabsComponent, TagComponent, TextAnimateDirective, TimelineAnimateDirective, TitleBarComponent, ToastComponent, ToastStackComponent, TypeOfArrayPipe, deepMerge, generateId, generateNumberId, generateUUID, generateUniqueId, getActivatedRouteChild, getTimestampISO, getTimestampMillis, isObjectEmpty, normalizeNumber, orderList, paginationList, sortTable };
+export type { AccordionItem, AccordionItemContext, AccordionToggleEvent, ArrayOneOrMore, Badge, BreadcrumbItem, Chip, CodeBlockBody, CodeBlockConfig, CodeBlockFooter, CodeBlockHeader, DateFormat, DateTimeFormat, DeepRequired, FragnimateBaseAnimation, FragnimateComponentParams, FragnimateHoverParams, FragnimateParams, FragnimateStaggerParams, FragnimateTextParams, FragnimateTimelineParams, GalaxyConfig, GenericFunction, IActionElement, IBaseAction, IConfigTable, IConfigTooltip, IConfigTooltipButtton, IConfigTooltipPopover, IEventAction, IFieldPipe, ILinkAction, IPaginationOutput, ISideNavConfig, ISideNavItem, ISideNavSection, ITBody, ITBodyAction, ITBodyCell, ITBodyCellIcon, ITBodyColumn, ITCaption, ITHead, ITHeadAction, ITHeadColumn, ITPagination, ITSort, ITTitleBar, ITTitleBarFilter, ITTitleBarSearch, ITableCellTemplateContext, ITooltipElement, ITooltipEventAction, ITooltipLinkAction, InputBorderStyleType, InputCheckboxGroupItem, InputChoiceStyleType, InputDateType, InputNumberType, InputRadioGroupItem, InputRichTextCommand, InputRichTextConfig, InputSliderSize, InputTextType, InputTextareaConfig, InputTextareaResize, InputTimeMeridiem, InputTimePartial, InputTimeType, InputToggleSwitchType, ModalCloseEvent, NebulaAnimations, NebulaBlob, NebulaColors, NebulaConfig, NebulaCoreConfig, NgClassValue, Pill, SelectionListItem, SnackbarCloseEvent, Star, StatusIndicator, StepChangeEvent, StepItem, StepItemContext, StepValidationContext, StepValidationEvent, StepValidator, TAccordionSize, TAccordionStyle, TBasePosition, TBaseSideNavSize, TBaseSideNavStyle, TBaseSize, TBaseStatusIconPosition, TBaseStatusSize, TBaseStatusStyle, TBaseStyle, TBehaviourAction, TButtonIconPosition, TButtonShape, TButtonSize, TButtonStyle, TButtonType, TCardStyle, TChipIconPosition, TChipSize, TChipType, TContainerSize, TCustomNgClass, TDividerOrientation, TDividerSpacing, THLJSLanguage, TIconPosition, TInputType, TModalCloseReason, TModalSize, TNebulaBlendMode, TPillIconPosition, TPillSize, TPillType, TProgressBarAnimation, TProgressBarSize, TProgressBarType, TPulseLoaderSize, TPulseLoaderType, TSectionHeading, TSectionSpacing, TSeparatorSize, TSideNavLink, TSkeletonLoaderSize, TSkeletonLoaderType, TSnackbarCloseReason, TSnackbarPosition, TSnackbarSize, TSnackbarStyle, TSpinnerSize, TSpinnerType, TStepNavigationSource, TStepperMotion, TStepperOrientation, TTabSize, TTabStyle, TTagIconPosition, TTagSize, TTagType, TToastCloseReason, TToastPosition, TToastSize, TToastStyle, TabChangeEvent, TabItem, TabItemContext, Tag, TimeFormat, ToastCloseEvent, ToastStackCloseEvent, ToastStackItem, TooltipPosition, TypeForm, Without, XOR };