@vallift/ngl 0.0.26 → 20.0.0

package/index.d.ts

@@ -1,5 +1,1847 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@vallift/ngl" />
-export * from './public-api';
+import * as _vallift_ngl from '@vallift/ngl';
+import { HttpHeaders, HttpEvent, HttpClient } from '@angular/common/http';
+import { Observable, Subject, Subscription } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { AfterContentInit, OnDestroy, AfterViewInit, OnInit, ElementRef, Renderer2, EventEmitter, OnChanges, ChangeDetectorRef, ViewContainerRef, ComponentFactoryResolver, ApplicationRef, Injector, QueryList, Type, OutputEmitterRef, OutputRefSubscription, SimpleChanges, WritableSignal, InjectionToken, PipeTransform, Provider } from '@angular/core';
+import * as _angular_forms from '@angular/forms';
+import { ControlValueAccessor, FormControl, NgControl, FormGroupDirective, FormGroup, AbstractControl, ValidatorFn, ValidationErrors, AsyncValidatorFn } from '@angular/forms';
+import { Router } from '@angular/router';
+import { DialogRef, Dialog } from '@angular/cdk/dialog';
+import { ComponentType, CdkPortal } from '@angular/cdk/portal';
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { Overlay } from '@angular/cdk/overlay';
+import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
+
+declare class BaseApiService {
+    config: _vallift_ngl.NglConfig;
+    protected defaultHeaders: HttpHeaders;
+    protected baseUrl: string;
+    private http;
+    constructor();
+    setDefaultHeaders(headers: HttpHeaders): void;
+    setBaseUrl(baseUrl: string): void;
+    protected get<T>(url: string, queryParams?: {
+        [key: string]: any;
+    }, customHeaders?: HttpHeaders, useCache?: boolean, cacheDurationMinutes?: number): Observable<any>;
+    protected fromFile<T>(url: string): Observable<T>;
+    protected getWithRetry<T>(url: string, customHeaders?: HttpHeaders, useCache?: boolean, cacheDurationMinutes?: number, maxRetries?: number, // Default retry count is 0
+    retryDelayMs?: number, enableRetry?: boolean): Observable<any>;
+    protected post<T>(url: string, body: any, queryParams?: {
+        [key: string]: any;
+    }, customHeaders?: HttpHeaders): Observable<any>;
+    protected put<T>(url: string, body: any, queryParams?: {
+        [key: string]: any;
+    }, customHeaders?: HttpHeaders): Observable<any>;
+    protected delete<T>(url: string, queryParams?: {
+        [key: string]: any;
+    }, customHeaders?: HttpHeaders): Observable<any>;
+    protected uploadFile(url: string, file: File, customHeaders?: HttpHeaders): Observable<HttpEvent<any>>;
+    protected uploadFiles(url: string, files: FileList, customHeaders?: HttpHeaders): Observable<HttpEvent<any>>;
+    protected uploadFormData(url: string, formData: FormData, customHeaders?: HttpHeaders, cancelSubject?: Subject<void>): Observable<HttpEvent<any>>;
+    protected transformResponse(data: any): any;
+    private handleHttpError;
+    private mergeHeaders;
+    private getFullUrl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BaseApiService>;
+}
+
+declare abstract class BaseControlValueAccessor implements ControlValueAccessor {
+    disabled: _angular_core.WritableSignal<boolean>;
+    touched: _angular_core.WritableSignal<boolean>;
+    formControl: FormControl<any>;
+    writeToInherited: boolean;
+    get hasErrors(): false | _angular_forms.ValidationErrors | null;
+    onChange: any;
+    onTouched: any;
+    writeValue(value: any): void;
+    protected abstract onWriteValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    markAsTouched(): void;
+    hasRequiredValidator(): boolean;
+}
+
+declare abstract class BaseControlValueAccessorV2<T> implements ControlValueAccessor {
+    controlValue: _angular_core.WritableSignal<T | null>;
+    actualValue: any;
+    disabled: _angular_core.WritableSignal<boolean>;
+    touched: _angular_core.WritableSignal<boolean>;
+    formControl: FormControl<any>;
+    writeToInherited: boolean;
+    ngControl: NgControl | null;
+    constructor();
+    initFormControl(): void;
+    get hasErrors(): false | _angular_forms.ValidationErrors | null;
+    onChange: any;
+    onTouched: any;
+    writeValue(value: T): void;
+    createInstance<T>(ClassRef: new () => T): T;
+    isOfType<T>(value: any, check: (value: any) => boolean): value is T;
+    protected abstract onValueReady(value: T): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    markAsTouched(): void;
+    hasRequiredValidator(): boolean;
+    updateValue(newValue: any): void;
+}
+type Schema<T> = {
+    [K in keyof T]: (value: any) => boolean;
+};
+declare function isValid<T>(value: any, schema: Schema<T>): value is T;
+declare function isDynamicType<T>(value: any, typeDefinition: new (...args: any[]) => T): boolean;
+declare function getDynamicTypeStructure(obj: any): string;
+
+declare abstract class BaseControlValueAccessorV3<T> implements ControlValueAccessor, AfterContentInit {
+    errorMessages: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    valueChanged: _angular_core.OutputEmitterRef<T>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    touched: _angular_core.WritableSignal<boolean>;
+    formControl: FormControl<any>;
+    ngControl: NgControl | null;
+    actualValue: T | undefined;
+    protected abstract onValueReady(value: T): void;
+    get controlValue(): T | undefined;
+    constructor();
+    ngAfterContentInit(): void;
+    get hasErrors(): false | _angular_forms.ValidationErrors | null;
+    private onChange;
+    onTouched: any;
+    writeValue(value: T): void;
+    onValueChange(value: T): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    markAsTouched(): void;
+    hasRequiredValidator(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseControlValueAccessorV3<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseControlValueAccessorV3<any>, "ng-component", never, { "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+interface BaseStateImpl<T> {
+    notifyLoading(): void;
+    notifySuccess(data: T): void;
+    notifyError(errorMsg: string): void;
+    clearState(): void;
+}
+declare class State<T> implements BaseStateImpl<T> {
+    responseSignal: _angular_core.WritableSignal<T | null>;
+    private initialLoadingSignal;
+    private loadingSignal;
+    private successSignal;
+    private failedSignal;
+    private errorSignal;
+    private stateSignal;
+    readonly response: _angular_core.Signal<T | null>;
+    readonly initialLoading: _angular_core.Signal<boolean>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly success: _angular_core.Signal<boolean>;
+    readonly failed: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly state: _angular_core.Signal<RequestState | null>;
+    constructor();
+    notifyInitialLoading(): void;
+    notifyLoading(): void;
+    notifySuccess(data: T): void;
+    notifyError(errorMsg: string): void;
+    clearState(): void;
+}
+declare enum RequestState {
+    idle = "idle",
+    initialLoading = "initialLoading",
+    loading = "loading",
+    error = "error",
+    success = "success"
+}
+
+declare class PaginationState<T> {
+    responseSignal: _angular_core.WritableSignal<T | null>;
+    private loadingSignal;
+    private successSignal;
+    private failedSignal;
+    private errorSignal;
+    private stateSignal;
+    readonly response: _angular_core.Signal<T | null>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly success: _angular_core.Signal<boolean>;
+    readonly failed: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly state: _angular_core.Signal<RequestState | null>;
+    items: _angular_core.WritableSignal<any[]>;
+    pageNumber: _angular_core.WritableSignal<number>;
+    pageSize: _angular_core.WritableSignal<number>;
+    totalRecords: _angular_core.WritableSignal<number>;
+    totalPages: _angular_core.WritableSignal<number>;
+    constructor();
+    notifyLoading(): void;
+    notifySuccess(response: any): void;
+    notifyError(errorMsg: string): void;
+    clearState(): void;
+}
+
+declare class AlertDialogComponent {
+    dialogRef: DialogRef<any, any>;
+    data: any;
+    onNoClicked(): void;
+    onYesClicked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogComponent, "app-alert-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class OverlayService {
+    private dialog;
+    private overlay;
+    private breakpointObserver;
+    private rendererFactory;
+    private renderer;
+    constructor();
+    private basePanelClass;
+    modalMaxHeightClass: string;
+    openNearElement<T>(component: ComponentType<T>, triggerElement: HTMLElement, options?: {
+        positionPreference?: 'topLeft' | 'topRight' | 'topCenter' | 'bottomLeft' | 'bottomRight' | 'bottomCenter' | 'leftTop' | 'leftCenter' | 'leftBottom' | 'rightTop' | 'rightCenter' | 'rightBottom' | 'center';
+        disableClose?: boolean;
+        data?: any;
+        scrollStrategy?: 'noop' | 'block' | 'reposition' | 'close';
+        isMobileResponsive?: boolean;
+    }): DialogRef<any, T>;
+    openAlert(title: string, message: string): DialogRef<any, AlertDialogComponent>;
+    openModal<T>(component: ComponentType<T>, options?: {
+        disableClose?: boolean;
+        maxHeightClass?: string;
+        data?: any;
+    }): DialogRef<any, T>;
+    private setOverlayMaxHeight;
+    openBackdrop<T>(component: ComponentType<T>, options?: {
+        disableClose?: boolean;
+        data?: any;
+    }): DialogRef<any, T>;
+    openBottomSheet<T>(component: ComponentType<T>, options?: {
+        disableClose?: boolean;
+        data?: any;
+    }): DialogRef<any, T>;
+    openFullScreen<T>(component: ComponentType<T>, options?: {
+        disableClose?: boolean;
+        data?: any;
+    }): DialogRef<any, T>;
+    openSidePanelRight<T>(component: ComponentType<T>, options?: {
+        widthInPx?: number;
+        disableClose?: boolean;
+        data?: any;
+    }): DialogRef<any, T>;
+    openSidePanelLeft<T>(component: ComponentType<T>, options?: {
+        widthInPx?: number;
+        disableClose?: boolean;
+        data?: any;
+    }): DialogRef<any, T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OverlayService>;
+}
+
+declare class UnsavedAwareDirective implements OnDestroy {
+    config: _vallift_ngl.NglConfig;
+    HANDLE_UNSAVED_CHANGES: boolean;
+    formGroupDirective: FormGroupDirective;
+    router: Router;
+    overlayService: OverlayService;
+    private routerSubscription?;
+    private isConfirming;
+    constructor();
+    confirmUnsavedChanges(): Promise<boolean>;
+    ngOnDestroy(): void;
+    unloadNotification($event: BeforeUnloadEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UnsavedAwareDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UnsavedAwareDirective, "form[unSavedAware]", never, {}, {}, never, never, true, never>;
+}
+
+type AnyObject = {
+    [key: string]: any;
+};
+declare function resolveTemplateWithObject(obj: AnyObject, expression: string, fallback?: string): string;
+declare enum TemplateResolverFormat {
+    THOUSAND_FORMAT = "THOUSAND_FORMAT",
+    MILLION_FORMAT = "MILLION_FORMAT",
+    BILLION_FORMAT = "BILLION_FORMAT",
+    CURRENCY_FORMAT = "CURRENCY_FORMAT",
+    PERCENTAGE_FORMAT = "PERCENTAGE_FORMAT",
+    ROUND_FORMAT = "ROUND_FORMAT"
+}
+declare enum TemplateResolverArrayUtil {
+    COUNT = "COUNT"
+}
+
+declare class PaginationComponent {
+    totalItems: _angular_core.InputSignal<number>;
+    pageSizeOptions: _angular_core.InputSignal<number[]>;
+    pageSize: number;
+    pageChange: _angular_core.OutputEmitterRef<PaginationEvent>;
+    currentPage: number;
+    get totalPages(): number;
+    get startItem(): number;
+    get endItem(): number;
+    changePageSize(event: string): void;
+    goToPage(page: number): void;
+    goToFirstPage(): void;
+    goToLastPage(): void;
+    goToNextPage(): void;
+    goToPreviousPage(): void;
+    emitPageChange(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginationComponent, "app-pagination", never, { "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+interface PaginationEvent {
+    pageNumber: number;
+    pageSize: number;
+}
+
+declare class BaseTableComponent<T> implements AfterViewInit {
+    pageSize: _angular_core.InputSignal<number>;
+    state: _angular_core.InputSignal<State<any> | undefined>;
+    isHorizontallyScrollable: _angular_core.InputSignal<boolean>;
+    itemsPerPage: _angular_core.InputSignal<number>;
+    pageChange: _angular_core.OutputEmitterRef<PaginationEvent>;
+    ngAfterViewInit(): void;
+    onPageChange(event: PaginationEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseTableComponent<any>, "app-base-table", never, { "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "isHorizontallyScrollable": { "alias": "isHorizontallyScrollable"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, never, ["[head]", "[body]"], true, never>;
+}
+interface PagingEvent {
+    pageNumber: number;
+    pageSize: number;
+}
+
+declare class SortableTableDirective implements OnInit, AfterViewInit {
+    private el;
+    private renderer;
+    sortChange: _angular_core.OutputEmitterRef<TableSortEvent>;
+    private currentKey;
+    private currentDirection;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onMouseEnter(th: HTMLElement): void;
+    onMouseLeave(th: HTMLElement): void;
+    onHeaderClick(th: HTMLElement): void;
+    updateSortIndicators(th: HTMLElement): void;
+    addSvgIcon(th: HTMLElement, direction: 'asc' | 'desc', isHover?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortableTableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SortableTableDirective, "[sortableTable]", never, {}, { "sortChange": "sortChange"; }, never, never, true, never>;
+}
+interface TableSortEvent {
+    key?: string | null;
+    direction?: string | null;
+}
+
+declare class ResizableColumnDirective implements AfterViewInit {
+    private startX;
+    private startWidth;
+    private resizeColumnHandler;
+    private stopResizeHandler;
+    el: ElementRef<any>;
+    renderer: Renderer2;
+    ngAfterViewInit(): void;
+    startResize(event: MouseEvent): void;
+    resizeColumn(event: MouseEvent): void;
+    stopResize(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizableColumnDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ResizableColumnDirective, "[appResizableColumn]", never, {}, {}, never, never, true, never>;
+}
+
+declare class TableResizableColumnsDirective implements AfterViewInit {
+    el: ElementRef<any>;
+    renderer: Renderer2;
+    applyResizableColumn: boolean;
+    constructor();
+    ngAfterViewInit(): void;
+    applyDirectiveLogic(): void;
+    addResizeFunctionality(thElement: HTMLElement, resizeDiv: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableResizableColumnsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TableResizableColumnsDirective, "[appTableResizableColumns]", never, { "applyResizableColumn": { "alias": "appTableResizableColumns"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AppSvgIconComponent {
+    src: string;
+    stretch: boolean;
+    size: number;
+    svgStyle: {
+        [key: string]: any;
+    };
+    getStyle(): {
+        'width.px': number;
+        'height.px': number;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppSvgIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppSvgIconComponent, "app-svg-icon", never, { "src": { "alias": "src"; "required": false; }; "stretch": { "alias": "stretch"; "required": false; }; "size": { "alias": "size"; "required": false; }; "svgStyle": { "alias": "svgStyle"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BreadcrumbComponent implements OnInit, OnDestroy {
+    router: Router;
+    breadcrumbs: Breadcrumb[];
+    private subscription;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private generateBreadcrumbs;
+    private formatSegment;
+    navigate(route: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbComponent, "app-breadcrumb", never, {}, {}, never, never, true, never>;
+}
+interface Breadcrumb {
+    title: string;
+    route?: string;
+}
+
+declare class ButtonComponent {
+    elementRef: ElementRef<any>;
+    document: Document;
+    renderer: Renderer2;
+    type: _angular_core.InputSignal<"submit" | "button" | "reset">;
+    disabled: _angular_core.InputSignal<boolean>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    appearance: _angular_core.InputSignal<"textType" | "primary" | "outline" | "primaryRounded" | "outlineRounded">;
+    loading: _angular_core.InputSignal<boolean>;
+    iconSize: _angular_core.InputSignal<number>;
+    iconSrc: _angular_core.InputSignal<string | null | undefined>;
+    iconColor: _angular_core.InputSignal<string | null>;
+    buttonColor: _angular_core.InputSignal<string>;
+    outlineColor: _angular_core.InputSignal<string>;
+    textButtonColor: _angular_core.InputSignal<string>;
+    size: _angular_core.InputSignal<"small" | "medium" | "large">;
+    buttonClick: EventEmitter<void>;
+    formGroupDirective: FormGroupDirective | null;
+    getButtonClass(): string;
+    getIconClass(): string | null;
+    getLoaderColor(): string;
+    onClick(): void;
+    validateForm(formGroup: FormGroup): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "app-button", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "buttonColor": { "alias": "buttonColor"; "required": false; "isSignal": true; }; "outlineColor": { "alias": "outlineColor"; "required": false; "isSignal": true; }; "textButtonColor": { "alias": "textButtonColor"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, ["*"], true, never>;
+}
+
+declare class CloseButtonComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloseButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloseButtonComponent, "app-close-button", never, {}, {}, never, never, true, never>;
+}
+
+declare class Rgba {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    constructor(r: number, g: number, b: number, a: number);
+    denormalize(): Rgba;
+    toString(): string;
+}
+declare class Hsva {
+    h: number;
+    s: number;
+    v: number;
+    a: number;
+    onChange: EventEmitter<Hsva>;
+    constructor(h: number, s: number, v: number, a: number);
+    onColorChange(value: {
+        s: number;
+        v: number;
+        rgX: number;
+        rgY: number;
+    }): void;
+    onHueChange(value: {
+        v: number;
+        rgX: number;
+    }): void;
+    onValueChange(value: {
+        v: number;
+        rgX: number;
+    }): void;
+    onAlphaChange(value: {
+        v: number;
+        rgX: number;
+    }): void;
+}
+declare class Hsla {
+    h: number;
+    s: number;
+    l: number;
+    a: number;
+    constructor(h: number, s: number, l: number, a: number);
+    denormalize(): Hsla;
+    toString(): string;
+}
+declare class Cmyk {
+    c: number;
+    m: number;
+    y: number;
+    k: number;
+    a: number;
+    constructor(c: number, m: number, y: number, k: number, a?: number);
+}
+
+declare enum ColorFormats {
+    HEX = 0,
+    RGBA = 1,
+    HSLA = 2,
+    CMYK = 3
+}
+
+declare class ColorConverterService {
+    constructor();
+    toFormat(hsva: Hsva | null, format: ColorFormats): string;
+    stringToFormat(color: string, format: ColorFormats): string;
+    hsva2hsla(hsva: Hsva): Hsla;
+    hsla2hsva(hsla: Hsla): Hsva;
+    hsvaToRgba(hsva: Hsva): Rgba;
+    cmykToRgb(cmyk: Cmyk): Rgba;
+    rgbaToCmyk(rgba: Rgba): Cmyk;
+    rgbaToHsva(rgba: Rgba): Hsva;
+    rgbaToHex(rgba: Rgba, allowHex8?: boolean): string;
+    normalizeCMYK(cmyk: Cmyk): Cmyk;
+    denormalizeCMYK(cmyk: Cmyk): Cmyk;
+    denormalizeRGBA(rgba: Rgba): Rgba;
+    stringToHsva(colorString?: string, allowHex8?: boolean): Hsva | null;
+    outputFormat(hsva: Hsva): string;
+    getFormatByString(color: string): string;
+    isValidHexColor(hex?: string): boolean;
+    addHexPrefixIfMissing(hex: string): string;
+    removeAlpha(hex: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorConverterService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ColorConverterService>;
+}
+
+declare class SliderPosition {
+    h: number;
+    s: number;
+    v: number;
+    a: number;
+    constructor(h: number, s: number, v: number, a: number);
+}
+
+declare class ColorPickerComponent extends BaseControlValueAccessorV3<string> implements OnInit, AfterViewInit, OnChanges {
+    hexColor: _angular_core.InputSignal<string>;
+    enableAdditionalColor: _angular_core.InputSignal<boolean>;
+    additionalColors: _angular_core.InputSignal<string[]>;
+    enableAlpha: _angular_core.InputSignal<boolean>;
+    controls: "default" | "only-alpha" | "no-alpha";
+    colorChanged: EventEmitter<string>;
+    onAlphaChange: EventEmitter<any>;
+    closeColorPicker: EventEmitter<any>;
+    color: Hsva;
+    COLOR_PICKER_HEIGHT: _angular_core.WritableSignal<number>;
+    COLOR_PICKER_WIDTH: _angular_core.WritableSignal<number>;
+    converterService: ColorConverterService;
+    cdr: ChangeDetectorRef;
+    hsva: _angular_core.WritableSignal<Hsva>;
+    private outputColor;
+    selectedColor: _angular_core.WritableSignal<string>;
+    private sliderDimMax;
+    slider: _angular_core.WritableSignal<SliderPosition>;
+    hueSliderColor: _angular_core.WritableSignal<string | null>;
+    alphaSliderColor: _angular_core.WritableSignal<string | null>;
+    hueSlider: ElementRef;
+    alphaSlider: ElementRef;
+    height: _angular_core.Signal<string>;
+    width: _angular_core.Signal<string>;
+    isTooltip: _angular_core.WritableSignal<boolean>;
+    format: ColorFormats;
+    hexColorValue: _angular_core.ModelSignal<string>;
+    alphaValue: _angular_core.WritableSignal<number>;
+    click(event: MouseEvent): void;
+    isOutside(event: any): any;
+    protected onValueReady(value: string): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: any): void;
+    ngAfterViewInit(): void;
+    setHexColor(hexColor: string, emit?: boolean): void;
+    mapRange(value: number): number;
+    onSliderChange(type: string, event: any): void;
+    setColor(color: Hsva): void;
+    getBackgroundColor(color: any): {
+        background: string;
+    };
+    private update;
+    onHexColorChange(event: any): void;
+    alphaChanged(event: any): void;
+    onApplyCLicked(): void;
+    getColorRows(): string[][];
+    onColorSelected(color: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPickerComponent, "app-color-picker", never, { "hexColor": { "alias": "hexColor"; "required": false; "isSignal": true; }; "enableAdditionalColor": { "alias": "enableAdditionalColor"; "required": false; "isSignal": true; }; "additionalColors": { "alias": "additionalColors"; "required": false; "isSignal": true; }; "enableAlpha": { "alias": "enableAlpha"; "required": false; "isSignal": true; }; "controls": { "alias": "controls"; "required": false; }; "hexColorValue": { "alias": "hexColorValue"; "required": false; "isSignal": true; }; }, { "colorChanged": "colorChanged"; "onAlphaChange": "onAlphaChange"; "closeColorPicker": "closeColorPicker"; "hexColorValue": "hexColorValueChange"; }, never, never, true, never>;
+}
+
+declare class ColorPickerDirective implements OnDestroy {
+    colorChanged: EventEmitter<string>;
+    private componentRef;
+    elementRef: ElementRef<any>;
+    viewContainerRef: ViewContainerRef;
+    componentFactoryResolver: ComponentFactoryResolver;
+    appRef: ApplicationRef;
+    injector: Injector;
+    overlay: any;
+    onClick(): void;
+    private initializeColorPicker;
+    closeColorPicker(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ColorPickerDirective, "[appColorPicker]", never, {}, { "colorChanged": "colorChanged"; }, never, never, true, never>;
+}
+
+declare class ContextMenuButtonComponent implements OnDestroy {
+    trigger: ElementRef;
+    overlay: Overlay;
+    dialog: Dialog;
+    actions: _angular_core.InputSignal<ContextMenuButtonAction[] | undefined>;
+    positionPreference: _angular_core.InputSignal<"topLeft" | "topRight" | "topCenter" | "bottomLeft" | "bottomRight" | "bottomCenter" | "leftTop" | "leftCenter" | "leftBottom" | "rightTop" | "rightCenter" | "rightBottom" | "center">;
+    onActionClicked: _angular_core.OutputEmitterRef<string>;
+    private basePanelClass;
+    private dialogRef?;
+    private subscription?;
+    ngOnDestroy(): void;
+    onMenuClicked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContextMenuButtonComponent, "app-context-menu-button", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "positionPreference": { "alias": "positionPreference"; "required": false; "isSignal": true; }; }, { "onActionClicked": "onActionClicked"; }, never, never, true, never>;
+}
+interface ContextMenuButtonAction {
+    iconPath?: string;
+    label: string;
+    actionKey: string;
+}
+
+declare class OverlayContextMenuComponent {
+    dialogRef: DialogRef<any, any>;
+    actions: ContextMenuButtonAction[];
+    _onActionClicked($event: MouseEvent, action: ContextMenuButtonAction): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayContextMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OverlayContextMenuComponent, "app-overlay-context-menu", never, {}, {}, never, never, true, never>;
+}
+
+declare class ContextMenuIconComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContextMenuIconComponent, "app-context-menu-icon", never, {}, {}, never, never, true, never>;
+}
+
+declare class DataTableComponent<T> extends BaseControlValueAccessorV3<TableStateEvent> implements AfterViewInit {
+    headerComponents: QueryList<any>;
+    columnDefs: _angular_core.InputSignal<ColumnDef[]>;
+    state: _angular_core.InputSignal<State<any>>;
+    pageSize: _angular_core.InputSignal<number>;
+    enableHorizontallyScrollable: _angular_core.InputSignal<boolean>;
+    enableResizableColumns: _angular_core.InputSignal<boolean>;
+    enableClickableRows: _angular_core.InputSignal<boolean>;
+    expandableComponent: _angular_core.InputSignal<any>;
+    enableColumnsConfig: _angular_core.InputSignal<boolean>;
+    filterComponent: _angular_core.InputSignal<any>;
+    enableSearch: _angular_core.InputSignal<boolean>;
+    disableInitialLoad: _angular_core.InputSignal<boolean>;
+    pageChange: OutputEmitterRef<PaginationEvent>;
+    sortChanged: OutputEmitterRef<TableSortEvent>;
+    tableStateChanged: OutputEmitterRef<TableStateEvent>;
+    onActionPerformed: OutputEmitterRef<TableActionEvent>;
+    filterChanged: OutputEmitterRef<any>;
+    onRowClicked: OutputEmitterRef<any>;
+    subscriptions: OutputRefSubscription[];
+    overlay: Overlay;
+    portal: CdkPortal;
+    paginationEvent?: PaginationEvent;
+    tableSortEvent?: TableSortEvent;
+    private searchText;
+    ngAfterViewInit(): void;
+    protected onValueReady(value: TableStateEvent): void;
+    onColumnSettingsClicked(columnsConfigTriggerElement: HTMLDivElement): void;
+    onSearchTextChanged($event: string): void;
+    onColumnVisibleOrHide($event: boolean, column: ColumnDef): void;
+    onSelectAllColumnClicked(): void;
+    getPropertyValue(item: any, column: ColumnDef): any;
+    onPageChange(event: PaginationEvent): void;
+    onSortChanged(event: TableSortEvent): void;
+    getThTrClass(column: ColumnDef): "text-left" | "text-center" | "text-right";
+    getFlexJustify(column: ColumnDef): "justify-start" | "justify-center" | "justify-end";
+    getBadgeProperty(item: any, column: ColumnDef): BadgeConfigProperty | null;
+    getContextMenuActions(actions: ContextMenuActionConfig[]): ContextMenuButtonAction[];
+    _onActionClicked($event: string, item: any, mouseEvent: MouseEvent | null): void;
+    expandedRowIndex: _angular_core.WritableSignal<number | null>;
+    onRowExpandedClicked(i: number): void;
+    _onRowClicked(item: any): void;
+    onCellActionPerformed($event: TableActionEvent): void;
+    onRowActionPerformed($event: TableActionEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableComponent<any>, "app-data-table", never, { "columnDefs": { "alias": "columnDefs"; "required": true; "isSignal": true; }; "state": { "alias": "state"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "enableHorizontallyScrollable": { "alias": "enableHorizontallyScrollable"; "required": false; "isSignal": true; }; "enableResizableColumns": { "alias": "enableResizableColumns"; "required": false; "isSignal": true; }; "enableClickableRows": { "alias": "enableClickableRows"; "required": false; "isSignal": true; }; "expandableComponent": { "alias": "expandableComponent"; "required": false; "isSignal": true; }; "enableColumnsConfig": { "alias": "enableColumnsConfig"; "required": false; "isSignal": true; }; "filterComponent": { "alias": "filterComponent"; "required": false; "isSignal": true; }; "enableSearch": { "alias": "enableSearch"; "required": false; "isSignal": true; }; "disableInitialLoad": { "alias": "disableInitialLoad"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "sortChanged": "sortChanged"; "tableStateChanged": "tableStateChanged"; "onActionPerformed": "onActionPerformed"; "filterChanged": "filterChanged"; "onRowClicked": "onRowClicked"; }, ["headerComponents"], ["*", "[body]"], true, never>;
+}
+interface ColumnDef {
+    title: string;
+    key?: string;
+    displayTemplate?: string;
+    sortKey?: string;
+    alignment?: 'left' | 'center' | 'right';
+    type: 'text' | 'date' | 'badge' | 'custom' | 'actions';
+    pinned?: 'left' | 'right' | null;
+    visible?: boolean | null;
+    component?: Type<any>;
+    textConfig?: TextConfig;
+    dateConfig?: DateConfig;
+    badgeConfig?: BadgeConfig;
+    customConfig?: CustomRendererConfig;
+    actionsConfig?: ActionConfig;
+    formatter?: (value: any) => any;
+    objectFormatter?: (value: any) => any;
+    propertyStyle?: (value: any) => any;
+}
+interface TextConfig {
+    textColorClass?: string;
+}
+interface DateConfig {
+    dateFormat?: string;
+    showIcon?: boolean;
+}
+interface BadgeConfig {
+    properties: BadgeConfigProperty[];
+}
+interface BadgeConfigProperty {
+    data: string;
+    displayText: string;
+    backgroundColorClass?: string;
+    borderColorClass?: string;
+    textColorClass?: string;
+    indicatorColorClass?: string;
+}
+interface CustomRendererConfig {
+    data?: any;
+}
+interface ActionConfig {
+    iconActions?: IconAction[];
+    threeDotMenuActions?: ContextMenuActionConfig[] | null;
+    textMenuActions?: ContextMenuActionConfig[] | null;
+    components?: Type<any>[];
+}
+interface IconAction {
+    iconPath: string;
+    actionKey: string;
+    label?: string;
+}
+interface ContextMenuActionConfig {
+    iconPath?: string;
+    actionKey: string;
+    label: string;
+}
+interface TableActionEvent {
+    actionKey: string;
+    item: any;
+    data?: any;
+}
+interface TableStateEvent {
+    searchText: string;
+    paginationEvent?: PaginationEvent;
+    tableSortEvent?: TableSortEvent;
+}
+
+declare class TableCustomComponent<T> {
+    rowData: T;
+    data: any;
+    rowPosition: number | undefined;
+    isLastRow: boolean;
+    actionPerformed: _angular_core.OutputEmitterRef<TableActionEvent>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCustomComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableCustomComponent<any>, "lib-table-custom-component", never, { "rowData": { "alias": "rowData"; "required": false; }; "data": { "alias": "data"; "required": false; }; "rowPosition": { "alias": "rowPosition"; "required": false; }; "isLastRow": { "alias": "isLastRow"; "required": false; }; }, { "actionPerformed": "actionPerformed"; }, never, never, true, never>;
+}
+
+declare class DynamicRendererComponent<T> implements OnChanges, OnDestroy {
+    component: Type<any>;
+    rowData: T;
+    data: _angular_core.InputSignal<any>;
+    rowPosition: _angular_core.InputSignal<number | undefined>;
+    isLastRow: _angular_core.InputSignal<boolean>;
+    actionPerformed: OutputEmitterRef<TableActionEvent>;
+    container: ViewContainerRef;
+    private componentRef?;
+    private actionSubscription?;
+    ngOnChanges(changes: SimpleChanges): void;
+    private loadComponent;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicRendererComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicRendererComponent<any>, "app-dynamic-renderer", never, { "component": { "alias": "component"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "rowPosition": { "alias": "rowPosition"; "required": false; "isSignal": true; }; "isLastRow": { "alias": "isLastRow"; "required": false; "isSignal": true; }; }, { "actionPerformed": "actionPerformed"; }, never, never, true, never>;
+}
+
+declare class EnvBannerComponent {
+    config: _vallift_ngl.NglConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EnvBannerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnvBannerComponent, "app-env-banner", never, {}, {}, never, never, true, never>;
+}
+
+declare class OpenFloatingMenuDirective implements OnDestroy {
+    private elementRef;
+    private overlayService;
+    component: Type<unknown>;
+    floatingMenuPositionPreference: 'topLeft' | 'topCenter' | 'topRight' | 'bottomLeft' | 'bottomCenter' | 'bottomRight';
+    floatingMenuData: any;
+    onFloatingMenuActionPerformed: EventEmitter<{
+        actionKey: string;
+        data: any;
+    }>;
+    private overlaySub?;
+    ngOnDestroy(): void;
+    onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OpenFloatingMenuDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OpenFloatingMenuDirective, "[libOpenFloatingMenu]", never, { "component": { "alias": "libOpenFloatingMenu"; "required": false; }; "floatingMenuPositionPreference": { "alias": "floatingMenuPositionPreference"; "required": false; }; "floatingMenuData": { "alias": "floatingMenuData"; "required": false; }; }, { "onFloatingMenuActionPerformed": "onFloatingMenuActionPerformed"; }, never, never, true, never>;
+}
+
+declare class ListviewComponent implements AfterViewInit {
+    state: _angular_core.InputSignal<PaginationState<any>>;
+    data: _angular_core.InputSignal<any>;
+    pageSize: _angular_core.InputSignal<number>;
+    component: _angular_core.InputSignal<Type<any>>;
+    enableSearch: _angular_core.InputSignal<boolean>;
+    enableSearchFullWidth: _angular_core.InputSignal<boolean>;
+    onStateChanged: _angular_core.OutputEmitterRef<TableStateEvent>;
+    onActionPerformed: _angular_core.OutputEmitterRef<TableActionEvent>;
+    private searchText;
+    ngAfterViewInit(): void;
+    onSearchTextChanged($event: string): void;
+    onScroll(): void;
+    onRowAction($event: TableActionEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListviewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListviewComponent, "app-listview", never, { "state": { "alias": "state"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "component": { "alias": "component"; "required": true; "isSignal": true; }; "enableSearch": { "alias": "enableSearch"; "required": false; "isSignal": true; }; "enableSearchFullWidth": { "alias": "enableSearchFullWidth"; "required": false; "isSignal": true; }; }, { "onStateChanged": "onStateChanged"; "onActionPerformed": "onActionPerformed"; }, never, never, true, never>;
+}
+
+declare class LoaderService {
+    loadingCount: _angular_core.WritableSignal<number>;
+    show(): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoaderService>;
+}
+
+declare class LoaderComponent {
+    loaderService: LoaderService;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderComponent, "app-loader", never, {}, {}, never, never, true, never>;
+}
+
+declare class NetworkImageComponent {
+    placeholderImage: _angular_core.InputSignal<string | undefined>;
+    imageUrl: _angular_core.InputSignal<string | undefined>;
+    isError: _angular_core.WritableSignal<boolean>;
+    placeHolderUrl: _angular_core.Signal<string>;
+    sourceUrl: _angular_core.Signal<string | undefined>;
+    handleImageError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NetworkImageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NetworkImageComponent, "lib-network-image", never, { "placeholderImage": { "alias": "placeholderImage"; "required": false; "isSignal": true; }; "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NoDataComponent {
+    size: _angular_core.InputSignal<number>;
+    message: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoDataComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NoDataComponent, "app-no-data", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NoDataTableComponent {
+    message: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoDataTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NoDataTableComponent, "app-no-data-table", never, { "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BaseOverlayComponent implements AfterViewInit {
+    container: ViewContainerRef;
+    actionsDiv: ElementRef<HTMLDivElement>;
+    actionsContainerDiv: ElementRef<HTMLDivElement>;
+    title: _angular_core.InputSignal<String>;
+    showTitle: _angular_core.InputSignal<boolean>;
+    showBackButton: _angular_core.InputSignal<boolean>;
+    enableDefaultLayout: _angular_core.InputSignal<boolean>;
+    onBackClicked: _angular_core.OutputEmitterRef<void>;
+    renderer: Renderer2;
+    dialogRef: DialogRef<any, any>;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    goBack(): void;
+    onCloseClicked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseOverlayComponent, "app-base-overlay", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "showTitle": { "alias": "showTitle"; "required": false; "isSignal": true; }; "showBackButton": { "alias": "showBackButton"; "required": false; "isSignal": true; }; "enableDefaultLayout": { "alias": "enableDefaultLayout"; "required": false; "isSignal": true; }; }, { "onBackClicked": "onBackClicked"; }, never, ["[body]", "[actions]"], true, never>;
+}
+
+declare class OverlayWizardUtils {
+    uiState: WritableSignal<OverlayWizard[]>;
+    wizard: WritableSignal<OverlayWizard[]>;
+    showBackButton(): boolean;
+    activeWizard(): OverlayWizard;
+    constructor(wizard: WritableSignal<OverlayWizard[]>, uiState?: WritableSignal<OverlayWizard[]> | null);
+    goBack(): void;
+    append(wizardKey: any): void;
+    closeUntil(wizard: any): void;
+}
+interface OverlayWizard {
+    title: string;
+    key: any;
+}
+
+declare class ResponsiveHelperComponent implements OnInit {
+    config: _vallift_ngl.NglConfig;
+    document: Document;
+    screenWidth: _angular_core.WritableSignal<number>;
+    constructor();
+    ngOnInit(): void;
+    onResize(event: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponsiveHelperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResponsiveHelperComponent, "app-responsive-helper", never, {}, {}, never, never, true, never>;
+}
+
+declare class ShimmerComponent {
+    type: _angular_core.InputSignal<"grid" | "list" | "single-line" | "multiline">;
+    count: _angular_core.InputSignal<number>;
+    loop: _angular_core.Signal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShimmerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShimmerComponent, "app-shimmer", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SpinnerComponent {
+    borderColor: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "app-spinner", never, { "borderColor": { "alias": "borderColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class StatusBadgeComponent {
+    status: _angular_core.InputSignal<string | null | undefined>;
+    backgroundColorClass: _angular_core.InputSignal<string | null>;
+    indicatorColor: _angular_core.InputSignal<string | null | undefined>;
+    textColorClass: _angular_core.InputSignal<string | null>;
+    borderColorClass: _angular_core.InputSignal<string | null>;
+    isUpperCase: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusBadgeComponent, "app-status-badge", never, { "status": { "alias": "status"; "required": true; "isSignal": true; }; "backgroundColorClass": { "alias": "backgroundColorClass"; "required": true; "isSignal": true; }; "indicatorColor": { "alias": "indicatorColor"; "required": false; "isSignal": true; }; "textColorClass": { "alias": "textColorClass"; "required": true; "isSignal": true; }; "borderColorClass": { "alias": "borderColorClass"; "required": true; "isSignal": true; }; "isUpperCase": { "alias": "isUpperCase"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SvgUrlIconComponent implements OnInit {
+    private http;
+    private sanitizer;
+    svgIcon: SafeHtml | null;
+    svgUrl: _angular_core.InputSignal<string>;
+    constructor(http: HttpClient, sanitizer: DomSanitizer);
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvgUrlIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SvgUrlIconComponent, "app-svg-url-icon", never, { "svgUrl": { "alias": "svgUrl"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare enum ToastType {
+    success = "success",
+    info = "info",
+    warning = "warning",
+    error = "error"
+}
+
+interface ToastEvent {
+    type: ToastType;
+    title?: string;
+    message: string;
+    duration?: number;
+    themeType?: 'light' | 'dark';
+}
+
+declare class ToastService {
+    static defaultDuration: number;
+    toastEvents: Observable<ToastEvent>;
+    private _toastEvents;
+    constructor();
+    /**
+     * Show success toast notification.
+     * @param title Toast title
+     * @param message Toast message
+     * @param duration
+     */
+    success(message: string, { title, duration }?: {
+        title?: string;
+        duration?: number;
+    }): void;
+    /**
+     * Show error toast notification.
+     * @param title Toast title
+     * @param message Toast message
+     * @param duration
+     */
+    error(message: string, { title, duration }?: {
+        title?: string;
+        duration?: number;
+    }): void;
+    /**
+     * Show info toast notification.
+     * @param title Toast title
+     * @param message Toast message
+     * @param duration
+     */
+    info(message: string, { title, duration }?: {
+        title?: string;
+        duration?: number;
+    }): void;
+    /**
+     * Show warning toast notification.
+     * @param title Toast title
+     * @param message Toast message
+     * @param duration
+     */
+    warning(message: string, { title, duration }?: {
+        title?: string;
+        duration?: number;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ToastService>;
+}
+
+declare class ToastComponent implements OnInit, OnDestroy {
+    disposeEvent: EventEmitter<any>;
+    type: ToastType;
+    title?: string;
+    message: string;
+    duration?: number;
+    themeType: _angular_core.InputSignal<"light" | "dark">;
+    themeClass: _angular_core.Signal<string>;
+    protected readonly ToastType: typeof ToastType;
+    ngOnInit(): void;
+    show(): void;
+    hide(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastComponent, "app-toast", never, { "type": { "alias": "type"; "required": false; }; "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "themeType": { "alias": "themeType"; "required": false; "isSignal": true; }; }, { "disposeEvent": "disposeEvent"; }, never, never, true, never>;
+}
+
+declare class ToasterComponent implements OnInit {
+    private toastService;
+    private cdr;
+    themeType: _angular_core.InputSignal<"light" | "dark">;
+    currentToasts: ToastEvent[];
+    constructor(toastService: ToastService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    subscribeToToasts(): void;
+    dispose(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToasterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToasterComponent, "app-toaster", never, { "themeType": { "alias": "themeType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TooltipDirective {
+    private overlay;
+    private elementRef;
+    private positionBuilder;
+    private overlayRef;
+    private longPressTimeout;
+    libTooltip: string;
+    tooltipPosition: _angular_core.InputSignal<"bottom" | "top" | "left" | "right" | "before" | "after">;
+    tooltipClass: _angular_core.InputSignal<string | string[] | Set<string> | {
+        [klass: string]: any;
+    }>;
+    constructor();
+    private showTooltip;
+    private hideTooltip;
+    private getPosition;
+    private isTouch;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onTouchStart(): void;
+    onTouchEnd(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[libTooltip]", never, { "libTooltip": { "alias": "libTooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "tooltipClass": { "alias": "tooltipClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ClickOutsideDirective implements AfterViewInit, OnDestroy {
+    clickOutside: EventEmitter<void>;
+    documentClickSubscription: Subscription | undefined;
+    document: Document;
+    element: ElementRef<any>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    isInside(elementToCheck: HTMLElement): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[clickOutside]", never, {}, { "clickOutside": "clickOutside"; }, never, never, true, never>;
+}
+
+declare class InvalidControlScrollDirective {
+    elementRef: ElementRef<any>;
+    formGroupDirective: FormGroupDirective;
+    constructor();
+    onSubmit(): void;
+    private scrollToFirstInvalidControl;
+    private getTopOffset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InvalidControlScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InvalidControlScrollDirective, "[appInvalidControlScroll]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InvalidControlScrollContainerDirective {
+    elementRef: ElementRef<any>;
+    formGroupDirective: FormGroupDirective;
+    scrollContainerDir: InvalidControlScrollContainerDirective | null;
+    private get containerEl();
+    constructor();
+    onSubmit(): void;
+    private scrollToFirstInvalidControl;
+    private getTopOffset;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InvalidControlScrollContainerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<InvalidControlScrollContainerDirective, "[appInvalidControlScrollContainer]", never, {}, {}, never, never, true, never>;
+}
+
+declare class BaseInputComponent {
+    title: _angular_core.InputSignal<string | null | undefined>;
+    isRequiredField: _angular_core.InputSignal<boolean>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    inputType: _angular_core.InputSignal<"number" | "file" | "text" | "search" | "email" | "password" | "tel" | "url">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseInputComponent, "app-base-input", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "isRequiredField": { "alias": "isRequiredField"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "inputType": { "alias": "inputType"; "required": false; "isSignal": true; }; }, {}, never, ["[input]", "[error]", "[icon]"], true, never>;
+}
+
+declare function deepEqual(obj1: any, obj2: any): boolean;
+declare function jsonEqual(json1: string, json2: string): boolean;
+
+declare class FormValidationUtils {
+    updateValidatorsIfNeeded(control: AbstractControl | null, addValidators: ValidatorFn[]): void;
+}
+
+declare class AppErrorComponent {
+    control: _angular_core.InputSignal<AbstractControl<any, any, any> | null>;
+    errorMessages: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    get hasErrors(): false | _angular_forms.ValidationErrors;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppErrorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppErrorComponent, "app-error", never, { "control": { "alias": "control"; "required": true; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CheckboxComponent extends BaseControlValueAccessorV3<boolean> implements OnInit, AfterContentInit {
+    title: _angular_core.InputSignal<string | null | undefined>;
+    id: _angular_core.WritableSignal<string>;
+    ngOnInit(): void;
+    protected onValueReady(value: boolean): void;
+    onCheckboxSelected($event: Event, enterKeyPressed?: boolean): void;
+    private getId;
+    handleKeydown($event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "app-checkbox", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type Weekday = 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday';
+declare class DatePickerComponent extends BaseControlValueAccessorV3<Date> implements OnInit {
+    minDate: _angular_core.InputSignal<Date | null | undefined>;
+    maxDate: _angular_core.InputSignal<Date | null | undefined>;
+    allowOnlyPast: _angular_core.InputSignal<boolean>;
+    allowOnlyFuture: _angular_core.InputSignal<boolean>;
+    allowToday: _angular_core.InputSignal<boolean>;
+    disabledDays: _angular_core.InputSignal<Weekday[]>;
+    disabledDates: _angular_core.InputSignal<Date[]>;
+    dateSelected: _angular_core.OutputEmitterRef<Date>;
+    days: {
+        day: Weekday;
+        displayName: string;
+    }[];
+    months: string[];
+    uiMode: _angular_core.WritableSignal<"date" | "month" | "year">;
+    activeMonth: number;
+    activeYear: number;
+    selectedDate?: Date | null;
+    years: {
+        value: number;
+        isEnabled: boolean;
+    }[];
+    daysOfMonth: {
+        value: number;
+        isEnabled: boolean;
+    }[];
+    blankDays: number[];
+    ngOnInit(): void;
+    protected onValueReady(value: Date): void;
+    initDate(): void;
+    getMMMYYYY(): string;
+    populateYears(): void;
+    populateDays(): void;
+    isSameDate(date1: Date, date2: Date): boolean;
+    isMonthEnabled(month: number): boolean;
+    onYearSelected(year: number): void;
+    onMonthSelected(month: number): void;
+    isToday(day: number): boolean;
+    onDaySelected(day: number): void;
+    resetPicker(): void;
+    isSelected(day: number): boolean;
+    previousMonthPressed(): void;
+    nextMonthPressed(): void;
+    onYearSelectionPressed(): void;
+    getFirstYear(): number;
+    getLastYear(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerComponent, "app-date-picker", never, { "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "allowOnlyPast": { "alias": "allowOnlyPast"; "required": false; "isSignal": true; }; "allowOnlyFuture": { "alias": "allowOnlyFuture"; "required": false; "isSignal": true; }; "allowToday": { "alias": "allowToday"; "required": false; "isSignal": true; }; "disabledDays": { "alias": "disabledDays"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; }, { "dateSelected": "dateSelected"; }, never, never, true, never>;
+}
+
+declare class DatePickerOverlayComponent {
+    dialogRef: DialogRef<any, any>;
+    data: {
+        selectedDate: Date | null;
+        minDate: Date | null;
+        maxDate: Date | null;
+        allowOnlyPast: boolean;
+        allowOnlyFuture: boolean;
+        disabledDays: Weekday[];
+        disabledDates: Date[];
+    };
+    onDateSelected($event: Date): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerOverlayComponent, "app-date-picker-overlay", never, {}, {}, never, never, true, never>;
+}
+
+declare enum InputDateFormat {
+    mmddyyyy = 0,
+    ddmmyyyy = 1
+}
+declare class DateInputComponent extends BaseControlValueAccessorV3<Date | null> implements OnDestroy {
+    trigger: ElementRef;
+    label: _angular_core.InputSignal<string | null | undefined>;
+    iconSrc: _angular_core.InputSignal<string | null | undefined>;
+    showDatePickerIcon: _angular_core.InputSignal<boolean>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    showErrorSpace: _angular_core.InputSignal<boolean>;
+    minDate: _angular_core.InputSignal<Date | null | undefined>;
+    maxDate: _angular_core.InputSignal<Date | null | undefined>;
+    allowOnlyPast: _angular_core.InputSignal<boolean>;
+    allowOnlyFuture: _angular_core.InputSignal<boolean>;
+    disabledDays: _angular_core.InputSignal<Weekday[]>;
+    disabledDates: _angular_core.InputSignal<Date[]>;
+    inputDateFormat: _angular_core.InputSignal<InputDateFormat>;
+    overlayService: OverlayService;
+    isFocused: _angular_core.WritableSignal<boolean>;
+    textInputValue: _angular_core.WritableSignal<string | null>;
+    private subscription?;
+    ngOnDestroy(): void;
+    protected onValueReady(value: any): void;
+    updateValidations(): void;
+    selValue(value: any): void;
+    isValidDate(date: any): boolean;
+    get placeHolder(): string;
+    getClass(): string;
+    onFocus(): void;
+    onBlur(): void;
+    onInputChanged($event: Event): void;
+    onDatePickerIconClicked(): void;
+    private parseDate;
+    private formatDate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateInputComponent, "app-date-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "showDatePickerIcon": { "alias": "showDatePickerIcon"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "showErrorSpace": { "alias": "showErrorSpace"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "allowOnlyPast": { "alias": "allowOnlyPast"; "required": false; "isSignal": true; }; "allowOnlyFuture": { "alias": "allowOnlyFuture"; "required": false; "isSignal": true; }; "disabledDays": { "alias": "disabledDays"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; "inputDateFormat": { "alias": "inputDateFormat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DateRangePickerComponent extends BaseControlValueAccessorV3<DateRangeEvent | null> implements OnInit {
+    minDate: _angular_core.InputSignal<Date | null | undefined>;
+    maxDate: _angular_core.InputSignal<Date | null | undefined>;
+    allowOnlyPast: _angular_core.InputSignal<boolean>;
+    allowOnlyFuture: _angular_core.InputSignal<boolean>;
+    allowToday: _angular_core.InputSignal<boolean>;
+    dateRangeSelected: _angular_core.OutputEmitterRef<DateRangeEvent>;
+    days: {
+        day: Weekday;
+        displayName: string;
+    }[];
+    months: string[];
+    uiMode: _angular_core.WritableSignal<"date" | "month" | "year">;
+    activeMonth: number;
+    activeYear: number;
+    startDate?: Date | null;
+    endDate?: Date | null;
+    selectingStart: boolean;
+    hoveredDate: Date | null;
+    years: {
+        value: number;
+        isEnabled: boolean;
+    }[];
+    daysOfMonth: {
+        value: number;
+        isEnabled: boolean;
+    }[];
+    blankDays: number[];
+    ngOnInit(): void;
+    protected onValueReady(value: DateRangeEvent): void;
+    initDate(): void;
+    getMMMYYYY(): string;
+    populateYears(): void;
+    populateDays(): void;
+    isMonthEnabled(month: number): boolean;
+    onYearSelected(year: number): void;
+    onMonthSelected(month: number): void;
+    isToday(day: number): boolean;
+    onDaySelected(day: number): void;
+    onDayHovered(day: number): void;
+    isDateInSelectionRange(day: number): boolean;
+    isDateInHoveredRange(day: number): boolean;
+    isDateHovered(day: number): boolean;
+    isDateInRange(day: number): boolean;
+    isSelectionStartDate(day: number): boolean | null | undefined;
+    isSelectionEndDate(day: number): boolean | null | undefined;
+    previousMonthPressed(): void;
+    nextMonthPressed(): void;
+    onYearSelectionPressed(): void;
+    getFirstYear(): number;
+    getLastYear(): number;
+    resetSelection(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangePickerComponent, "app-date-range-picker", never, { "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "allowOnlyPast": { "alias": "allowOnlyPast"; "required": false; "isSignal": true; }; "allowOnlyFuture": { "alias": "allowOnlyFuture"; "required": false; "isSignal": true; }; "allowToday": { "alias": "allowToday"; "required": false; "isSignal": true; }; }, { "dateRangeSelected": "dateRangeSelected"; }, never, never, true, never>;
+}
+interface DateRangeEvent {
+    startDate: Date;
+    endDate: Date;
+}
+
+declare class DropdownComponent<T> extends BaseControlValueAccessorV2<any> implements AfterContentInit, OnChanges {
+    cdr: ChangeDetectorRef;
+    renderer: Renderer2;
+    overlay: Overlay;
+    title: _angular_core.InputSignal<string | null | undefined>;
+    items: _angular_core.InputSignal<T[]>;
+    placeholder: _angular_core.InputSignal<string>;
+    prefixIconPath: _angular_core.InputSignal<string | null | undefined>;
+    isTitlePrefix: _angular_core.InputSignal<boolean>;
+    display: _angular_core.InputSignal<string | null | undefined>;
+    displayTemplate: _angular_core.InputSignal<string | null | undefined>;
+    value: _angular_core.InputSignal<string | null | undefined>;
+    searchKeyMatch: _angular_core.InputSignal<string | null | undefined>;
+    noDataMessage: _angular_core.InputSignal<string | undefined>;
+    state: _angular_core.InputSignal<State<any> | undefined>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    showErrorSpace: _angular_core.InputSignal<boolean>;
+    enableSearch: _angular_core.InputSignal<boolean>;
+    addActionText: _angular_core.InputSignal<string | null | undefined>;
+    minimumPopupWidth: _angular_core.InputSignal<number>;
+    noBorder: _angular_core.InputSignal<boolean>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    highlightedIndex: _angular_core.WritableSignal<number>;
+    selectedItem: _angular_core.WritableSignal<T | null>;
+    dropUp: _angular_core.WritableSignal<boolean>;
+    dropdownWidth: _angular_core.WritableSignal<number>;
+    filteredList: _angular_core.WritableSignal<T[]>;
+    errorMessages: _angular_core.WritableSignal<{
+        [key: string]: string;
+    }>;
+    valueChanged: _angular_core.OutputEmitterRef<T | null>;
+    addActionClicked: _angular_core.OutputEmitterRef<void>;
+    dropdownButton: ElementRef;
+    dropdown: ElementRef;
+    dropdownListContainer: ElementRef;
+    dropdownList: ElementRef;
+    private searchField;
+    scrollStrategy: _angular_cdk_overlay.BlockScrollStrategy;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected onValueReady(value: any): void;
+    ngAfterContentInit(): void;
+    getDisplayString(item: T | null): any;
+    getButtonClass(): string;
+    filterList(event: Event): void;
+    updateFilteredList(searchKeyword?: string): void;
+    findFirstMatch(searchKeyword?: string): T | null;
+    getValue(item: T): any;
+    getSelectedItem(): T | null;
+    toggleDropdown(): void;
+    updateHighlightedIndex(): void;
+    setPopupWidth(): void;
+    onClickOutside(): void;
+    onItemClicked(item: T): void;
+    setDropdownMaxHeight(): void;
+    adjustDropdownPosition(): void;
+    scrollToHighlightedItem(): void;
+    onResize(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    onClearSearchClicked(): void;
+    onAddActionClicked(): void;
+    getObjectByPathValue(objects: any[], path: string, value: any): T | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent<any>, "app-dropdown", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "prefixIconPath": { "alias": "prefixIconPath"; "required": false; "isSignal": true; }; "isTitlePrefix": { "alias": "isTitlePrefix"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "displayTemplate": { "alias": "displayTemplate"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "searchKeyMatch": { "alias": "searchKeyMatch"; "required": false; "isSignal": true; }; "noDataMessage": { "alias": "noDataMessage"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "showErrorSpace": { "alias": "showErrorSpace"; "required": false; "isSignal": true; }; "enableSearch": { "alias": "enableSearch"; "required": false; "isSignal": true; }; "addActionText": { "alias": "addActionText"; "required": false; "isSignal": true; }; "minimumPopupWidth": { "alias": "minimumPopupWidth"; "required": false; "isSignal": true; }; "noBorder": { "alias": "noBorder"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; "addActionClicked": "addActionClicked"; }, never, never, true, never>;
+}
+
+declare class FileUploaderComponent extends BaseControlValueAccessor implements OnInit, AfterContentInit {
+    fullWidth: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string | null | undefined>;
+    isRequired: _angular_core.InputSignal<boolean>;
+    uploading: _angular_core.InputSignal<boolean>;
+    errorMessages: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    fileSelected: _angular_core.OutputEmitterRef<File>;
+    fileRemoved: _angular_core.OutputEmitterRef<void>;
+    id: _angular_core.WritableSignal<string>;
+    selectedFile: _angular_core.WritableSignal<File | null>;
+    ngControl: NgControl | null;
+    constructor();
+    onWriteValue(value: any): void;
+    ngAfterContentInit(): void;
+    ngOnInit(): void;
+    onFileChange(event: Event): void;
+    onRemoveFileClicked(): void;
+    onViewFileClicked(): void;
+    private getId;
+    getFileNameFromUrl(url: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploaderComponent, "app-file-uploader", never, { "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "isRequired": { "alias": "isRequired"; "required": false; "isSignal": true; }; "uploading": { "alias": "uploading"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; }, { "fileSelected": "fileSelected"; "fileRemoved": "fileRemoved"; }, never, never, true, never>;
+}
+
+declare class MultiSelectDropdownComponent<T> extends BaseControlValueAccessor implements AfterContentInit {
+    cdr: ChangeDetectorRef;
+    renderer: Renderer2;
+    overlay: Overlay;
+    title: _angular_core.InputSignal<string | null | undefined>;
+    items: _angular_core.InputSignal<T[]>;
+    placeholder: _angular_core.InputSignal<string>;
+    display: _angular_core.InputSignal<string | null | undefined>;
+    displayTemplate: _angular_core.InputSignal<string | null | undefined>;
+    value: _angular_core.InputSignal<string>;
+    identifier: _angular_core.InputSignal<string>;
+    searchKeyMatch: _angular_core.InputSignal<string | null | undefined>;
+    noDataMessage: _angular_core.InputSignal<string | undefined>;
+    state: _angular_core.InputSignal<State<any> | undefined>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    showErrorSpace: _angular_core.InputSignal<boolean>;
+    enableSearch: _angular_core.InputSignal<boolean>;
+    addActionText: _angular_core.InputSignal<string | null | undefined>;
+    minimumPopupWidth: _angular_core.InputSignal<number>;
+    appearance: _angular_core.InputSignal<MultiSelectDropdownAppearance>;
+    valueChanged: _angular_core.OutputEmitterRef<T[]>;
+    addActionClicked: _angular_core.OutputEmitterRef<void>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    highlightedIndex: _angular_core.WritableSignal<number>;
+    dropUp: _angular_core.WritableSignal<boolean>;
+    dropdownWidth: _angular_core.WritableSignal<number>;
+    selectedItems: _angular_core.WritableSignal<T[]>;
+    filteredList: _angular_core.WritableSignal<T[]>;
+    errorMessages: _angular_core.WritableSignal<{
+        [key: string]: string;
+    }>;
+    dropdownButton: ElementRef;
+    dropdownListContainer: ElementRef;
+    dropdownList: ElementRef;
+    private searchField;
+    scrollStrategy: _angular_cdk_overlay.BlockScrollStrategy;
+    ngControl: NgControl | null;
+    MultiSelectDropdownAppearance: typeof MultiSelectDropdownAppearance;
+    constructor();
+    onWriteValue(value: any): void;
+    ngAfterContentInit(): void;
+    getValue(item: T): any;
+    getAllValues(): any[];
+    getObjectUsingValue(selectedItem: T): any;
+    getObjectUsingIdentifier(selectedItem: T): T | undefined;
+    getIdentifier(item: T): any;
+    isItemExistInFormControl(item: T): boolean | T | undefined;
+    isItemExistInNormalSelectionList(item: T): boolean | T | undefined;
+    onItemClicked(item: T): void;
+    getDisplayString(item: T | null): any;
+    filterList(event: Event): void;
+    updateFilteredList(searchKeyword?: string): void;
+    findFirstMatch(searchKeyword?: string): T | null;
+    updateHighlightedIndex(): void;
+    setPopupWidth(): void;
+    onClickOutside(): void;
+    toggleDropdown(): void;
+    setDropdownMaxHeight(): void;
+    adjustDropdownPosition(): void;
+    scrollToHighlightedItem(): void;
+    onResize(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    onClearSearchClicked(): void;
+    onSelectAllClicked(): void;
+    onClearSelectionClicked(): void;
+    getCsv(): string | null;
+    onAddActionClicked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiSelectDropdownComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiSelectDropdownComponent<any>, "app-multi-select-dropdown", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "displayTemplate": { "alias": "displayTemplate"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "identifier": { "alias": "identifier"; "required": false; "isSignal": true; }; "searchKeyMatch": { "alias": "searchKeyMatch"; "required": false; "isSignal": true; }; "noDataMessage": { "alias": "noDataMessage"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "showErrorSpace": { "alias": "showErrorSpace"; "required": false; "isSignal": true; }; "enableSearch": { "alias": "enableSearch"; "required": false; "isSignal": true; }; "addActionText": { "alias": "addActionText"; "required": false; "isSignal": true; }; "minimumPopupWidth": { "alias": "minimumPopupWidth"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; "addActionClicked": "addActionClicked"; }, never, never, true, never>;
+}
+declare enum MultiSelectDropdownAppearance {
+    standard = 0,
+    csv = 1,
+    chips = 2
+}
+
+declare class MultiSelectionFieldComponent<T> extends BaseControlValueAccessor implements AfterContentInit, OnChanges {
+    title: _angular_core.InputSignal<string | null | undefined>;
+    items: _angular_core.InputSignal<T[]>;
+    display: _angular_core.InputSignal<string | null | undefined>;
+    displayTemplate: _angular_core.InputSignal<string | null | undefined>;
+    iconSrc: _angular_core.InputSignal<string | null | undefined>;
+    dynamicIconPath: _angular_core.InputSignal<string | undefined>;
+    imageUrl: _angular_core.InputSignal<string | null | undefined>;
+    dynamicImageUrlPath: _angular_core.InputSignal<string | undefined>;
+    value: _angular_core.InputSignal<string | null>;
+    identifier: _angular_core.InputSignal<string>;
+    noDataMessage: _angular_core.InputSignal<string | undefined>;
+    state: _angular_core.InputSignal<State<any> | undefined>;
+    iconColor: _angular_core.InputSignal<string | undefined>;
+    dynamicIconColor: _angular_core.InputSignal<string | undefined>;
+    customActionText: _angular_core.InputSignal<string | undefined>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    itemWidth: _angular_core.InputSignal<number | null>;
+    isItemCentered: _angular_core.InputSignal<boolean>;
+    showSelectionTickMark: _angular_core.InputSignal<boolean>;
+    maximumDisplayItems: _angular_core.InputSignal<number | null>;
+    valueChanged: _angular_core.OutputEmitterRef<T[]>;
+    onCustomActionClicked: _angular_core.OutputEmitterRef<void>;
+    showAll: _angular_core.WritableSignal<boolean>;
+    selectedItems: _angular_core.WritableSignal<T[]>;
+    errorMessages: _angular_core.WritableSignal<{
+        [key: string]: string;
+    }>;
+    ngControl: NgControl | null;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    onWriteValue(value: any[]): void;
+    updateValue(): void;
+    ngAfterContentInit(): void;
+    getVisibleItems(): T[];
+    showMoreButton(): boolean;
+    showLessButton(): boolean;
+    showAllItems(): void;
+    shrinkItems(): void;
+    getObjectUsingValue(selectedItem: T): any;
+    getObjectUsingIdentifier(selectedItem: T): T | undefined;
+    getObjectUsingIdentifierValue(value: any): any | undefined;
+    getDisplayString(item: T): any;
+    getValue(item: T): any;
+    getAllValues(): any[];
+    getIdentifier(item: T): any;
+    isItemExistInFormControl(item: T): boolean | T | undefined;
+    isItemExistInNormalSelectionList(item: T): boolean | T | undefined;
+    onItemClicked(item: T): void;
+    getImageType(item: T): 'svg' | 'url' | null;
+    getDynamicIcon(item: T): string | null | undefined;
+    getDynamicIconColor(item: T): string | null | undefined;
+    customActionClicked(): void;
+    handleKeydown(event: KeyboardEvent, item: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiSelectionFieldComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiSelectionFieldComponent<any>, "app-multi-selection-field", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "displayTemplate": { "alias": "displayTemplate"; "required": false; "isSignal": true; }; "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "dynamicIconPath": { "alias": "dynamicIconPath"; "required": false; "isSignal": true; }; "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; "dynamicImageUrlPath": { "alias": "dynamicImageUrlPath"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "identifier": { "alias": "identifier"; "required": false; "isSignal": true; }; "noDataMessage": { "alias": "noDataMessage"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "dynamicIconColor": { "alias": "dynamicIconColor"; "required": false; "isSignal": true; }; "customActionText": { "alias": "customActionText"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "itemWidth": { "alias": "itemWidth"; "required": false; "isSignal": true; }; "isItemCentered": { "alias": "isItemCentered"; "required": false; "isSignal": true; }; "showSelectionTickMark": { "alias": "showSelectionTickMark"; "required": false; "isSignal": true; }; "maximumDisplayItems": { "alias": "maximumDisplayItems"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; "onCustomActionClicked": "onCustomActionClicked"; }, never, never, true, never>;
+}
+
+declare class TimePickerComponent extends BaseControlValueAccessorV2<TimePickerValue> implements AfterContentInit {
+    overlay: Overlay;
+    iconSrc: _angular_core.InputSignal<string | null | undefined>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    showErrorSpace: _angular_core.InputSignal<boolean>;
+    showTimePickerIcon: _angular_core.InputSignal<boolean>;
+    valueChanged: _angular_core.OutputEmitterRef<TimePickerValueEvent>;
+    scrollStrategy: _angular_cdk_overlay.BlockScrollStrategy;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    errorMessages: _angular_core.WritableSignal<{
+        [key: string]: string;
+    }>;
+    enableApplyActions: _angular_core.WritableSignal<boolean>;
+    hours: _angular_core.WritableSignal<number>;
+    minutes: _angular_core.WritableSignal<number>;
+    period: _angular_core.WritableSignal<"AM" | "PM" | null>;
+    is24HourFormat: _angular_core.WritableSignal<boolean>;
+    isFocused: _angular_core.WritableSignal<boolean>;
+    handleHourUpdate: boolean;
+    previousValidHours: number;
+    previousValidMinutes: number;
+    protected onValueReady(value: TimePickerValue): void;
+    ngAfterContentInit(): void;
+    onFocus(): void;
+    onBlur(): void;
+    getClass(): string;
+    onHourUpClicked(): void;
+    onHourDownClicked(): void;
+    onMinuteUpClicked(): void;
+    onMinuteDownClicked(): void;
+    togglePeriod(): void;
+    toggle24HourFormat(isChecked: boolean): void;
+    validateHours($event: FocusEvent): void;
+    validateMinutes($event: FocusEvent): void;
+    getFormattedHours(): string;
+    getFormattedMinutes(): string;
+    valueUpdated(): void;
+    onTimePickerIconClick(): void;
+    onClickOutside(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimePickerComponent, "app-time-picker", never, { "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "showErrorSpace": { "alias": "showErrorSpace"; "required": false; "isSignal": true; }; "showTimePickerIcon": { "alias": "showTimePickerIcon"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+interface TimePickerValue {
+    hours: number;
+    minutes: number;
+}
+interface TimePickerValueEvent {
+    hours12F: number;
+    minutes12F: number;
+    hours24F: number;
+    minutes24F: number;
+    period: 'AM' | 'PM' | null;
+}
+
+declare class NumberInputComponent extends BaseControlValueAccessorV2<TimePickerValue> implements AfterContentInit {
+    valueChanged: _angular_core.OutputEmitterRef<number>;
+    ngAfterContentInit(): void;
+    protected onValueReady(value: TimePickerValue): void;
+    increment(): void;
+    private text;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInputComponent, "app-number-input", never, {}, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class PhoneNumberInputComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneNumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneNumberInputComponent, "app-phone-number-input", never, {}, {}, never, never, true, never>;
+}
+
+declare class RadioButtonComponent extends BaseControlValueAccessor implements OnInit, AfterContentInit {
+    title: _angular_core.InputSignal<string | null | undefined>;
+    groupName: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<any>;
+    id: _angular_core.WritableSignal<string>;
+    valueChanged: EventEmitter<any>;
+    ngControl: NgControl | null;
+    errorMessages: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    constructor();
+    ngAfterContentInit(): void;
+    protected onWriteValue(obj: any): void;
+    ngOnInit(): void;
+    onRadioSelected($event: Event): void;
+    private getId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioButtonComponent, "app-radio-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "groupName": { "alias": "groupName"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class SingleItemPickerInputComponent<T> extends BaseControlValueAccessor implements AfterContentInit {
+    title: _angular_core.InputSignal<string>;
+    items: _angular_core.InputSignal<T[]>;
+    display: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<string | undefined>;
+    errorMessages: _angular_core.WritableSignal<{
+        [key: string]: string;
+    }>;
+    ngControl: NgControl | null;
+    isPopUpOpen: _angular_core.WritableSignal<boolean>;
+    valueChanged: EventEmitter<T | null>;
+    constructor();
+    onWriteValue(value: any): void;
+    ngAfterContentInit(): void;
+    getProperty(item: T): any;
+    getPropertyId(item: T): any;
+    onItemClicked(item: T): void;
+    outsideClicked(): void;
+    togglePopup(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SingleItemPickerInputComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SingleItemPickerInputComponent<any>, "app-single-item-picker-input", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class SingleSelectionFieldComponent<T> extends BaseControlValueAccessor implements AfterContentInit {
+    title: _angular_core.InputSignal<string | null | undefined>;
+    items: _angular_core.InputSignal<T[]>;
+    display: _angular_core.InputSignal<string | undefined>;
+    displayTemplate: _angular_core.InputSignal<string | null | undefined>;
+    iconSrc: _angular_core.InputSignal<string | null | undefined>;
+    dynamicIconPath: _angular_core.InputSignal<string | undefined>;
+    imageUrl: _angular_core.InputSignal<string | null | undefined>;
+    dynamicImageUrlPath: _angular_core.InputSignal<string | undefined>;
+    iconColor: _angular_core.InputSignal<string | undefined>;
+    dynamicIconColor: _angular_core.InputSignal<string | undefined>;
+    value: _angular_core.InputSignal<string | undefined>;
+    noDataMessage: _angular_core.InputSignal<string | undefined>;
+    state: _angular_core.InputSignal<State<any> | undefined>;
+    customActionText: _angular_core.InputSignal<string | undefined>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    itemWidth: _angular_core.InputSignal<number | null>;
+    isItemCentered: _angular_core.InputSignal<boolean>;
+    showSelectionTickMark: _angular_core.InputSignal<boolean>;
+    itemPlacement: _angular_core.InputSignal<"start" | "space-between">;
+    maximumDisplayItems: _angular_core.InputSignal<number | null>;
+    valueChanged: _angular_core.OutputEmitterRef<T | null>;
+    onCustomActionClicked: _angular_core.OutputEmitterRef<void>;
+    selectedItem: _angular_core.WritableSignal<T | null>;
+    showAll: _angular_core.WritableSignal<boolean>;
+    errorMessages: _angular_core.WritableSignal<{
+        [key: string]: string;
+    }>;
+    ngControl: NgControl | null;
+    constructor();
+    onWriteValue(value: any): void;
+    ngAfterContentInit(): void;
+    getVisibleItems(): T[];
+    showMoreButton(): boolean;
+    showLessButton(): boolean;
+    showAllItems(): void;
+    shrinkItems(): void;
+    getDisplayString(item: T): any;
+    getPropertyId(item: T | null): any;
+    getImageType(item: T): 'svg' | 'url' | null;
+    getDynamicIcon(item: T): string | null | undefined;
+    getDynamicIconColor(item: T): string | null | undefined;
+    onItemClicked(item: T): void;
+    customActionClicked(): void;
+    handleKeydown(event: KeyboardEvent, item: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SingleSelectionFieldComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SingleSelectionFieldComponent<any>, "app-single-selection-field", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "displayTemplate": { "alias": "displayTemplate"; "required": false; "isSignal": true; }; "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "dynamicIconPath": { "alias": "dynamicIconPath"; "required": false; "isSignal": true; }; "imageUrl": { "alias": "imageUrl"; "required": false; "isSignal": true; }; "dynamicImageUrlPath": { "alias": "dynamicImageUrlPath"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "dynamicIconColor": { "alias": "dynamicIconColor"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "noDataMessage": { "alias": "noDataMessage"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "customActionText": { "alias": "customActionText"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "itemWidth": { "alias": "itemWidth"; "required": false; "isSignal": true; }; "isItemCentered": { "alias": "isItemCentered"; "required": false; "isSignal": true; }; "showSelectionTickMark": { "alias": "showSelectionTickMark"; "required": false; "isSignal": true; }; "itemPlacement": { "alias": "itemPlacement"; "required": false; "isSignal": true; }; "maximumDisplayItems": { "alias": "maximumDisplayItems"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; "onCustomActionClicked": "onCustomActionClicked"; }, never, ["[post]"], true, never>;
+}
+
+declare class SwitchComponent extends BaseControlValueAccessor implements OnInit, AfterContentInit {
+    title: _angular_core.InputSignal<string | null | undefined>;
+    id: _angular_core.WritableSignal<string>;
+    valueChanged: EventEmitter<boolean>;
+    ngControl: NgControl | null;
+    errorMessages: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnInit(): void;
+    protected onWriteValue(value: any): void;
+    onSwitchSelected($event: Event): void;
+    private getId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "app-switch", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class TextAreaInputComponent extends BaseControlValueAccessor implements AfterContentInit {
+    appearance: _angular_core.InputSignal<"outline" | "fill">;
+    type: _angular_core.InputSignal<"number" | "text" | "search" | "email" | "password" | "tel" | "url">;
+    viewType: _angular_core.InputSignal<"text" | "text-area">;
+    label: _angular_core.InputSignal<string>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string>;
+    rows: _angular_core.InputSignal<number>;
+    errorMessages: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    showErrorSpace: _angular_core.InputSignal<boolean>;
+    changeValue: _angular_core.OutputEmitterRef<any>;
+    ngControl: NgControl | null;
+    constructor();
+    ngAfterContentInit(): void;
+    onValueChange(event: any): void;
+    protected onWriteValue(obj: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextAreaInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextAreaInputComponent, "app-text-area-input", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "viewType": { "alias": "viewType"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "showErrorSpace": { "alias": "showErrorSpace"; "required": false; "isSignal": true; }; }, { "changeValue": "changeValue"; }, never, never, true, never>;
+}
+
+declare class TextInputComponent extends BaseControlValueAccessor implements AfterContentInit, AfterViewInit, OnDestroy {
+    appearance: _angular_core.InputSignal<"outline" | "fill">;
+    type: _angular_core.InputSignal<"number" | "text" | "search" | "time" | "email" | "password" | "tel" | "url">;
+    viewType: _angular_core.InputSignal<"text" | "text-area">;
+    size: _angular_core.InputSignal<"small" | "medium" | "large">;
+    iconSrc: _angular_core.InputSignal<string | null | undefined>;
+    actionIcon: _angular_core.InputSignal<string | null | undefined>;
+    label: _angular_core.InputSignal<string | null | undefined>;
+    fullWidth: _angular_core.InputSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string>;
+    errorMessages: _angular_core.InputSignal<{
+        [key: string]: string;
+    }>;
+    showErrorSpace: _angular_core.InputSignal<boolean>;
+    mask: _angular_core.InputSignal<string | null>;
+    debounceSearchEnabled: _angular_core.InputSignal<boolean>;
+    autoFocus: _angular_core.InputSignal<boolean>;
+    inputRef: ElementRef<HTMLInputElement>;
+    changeValue: _angular_core.OutputEmitterRef<string>;
+    actionIconClicked: _angular_core.OutputEmitterRef<void>;
+    isFocused: _angular_core.WritableSignal<boolean>;
+    ngControl: NgControl | null;
+    private searchSubject;
+    constructor();
+    onWriteValue(value: any): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onValueChange(event: any): void;
+    getClass(): string;
+    sizeMap: Record<'small' | 'medium' | 'large', string>;
+    onActionClicked(): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextInputComponent, "app-text-input", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "viewType": { "alias": "viewType"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "iconSrc": { "alias": "iconSrc"; "required": false; "isSignal": true; }; "actionIcon": { "alias": "actionIcon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "showErrorSpace": { "alias": "showErrorSpace"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "debounceSearchEnabled": { "alias": "debounceSearchEnabled"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; }, { "changeValue": "changeValue"; "actionIconClicked": "actionIconClicked"; }, never, never, true, never>;
+}
+
+declare const defaultErrors: {
+    required: () => string;
+    minlength: ({ requiredLength, actualLength }: any) => string;
+    maxlength: ({ requiredLength, actualLength }: any) => string;
+    min: ({ min, actual }: any) => string;
+    max: ({ max, actual }: any) => string;
+    matchOthers: () => string;
+    email: () => string;
+    invalidDate: (errorMessage: any) => any;
+};
+declare const FORM_ERRORS: InjectionToken<{
+    required: () => string;
+    minlength: ({ requiredLength, actualLength }: any) => string;
+    maxlength: ({ requiredLength, actualLength }: any) => string;
+    min: ({ min, actual }: any) => string;
+    max: ({ max, actual }: any) => string;
+    matchOthers: () => string;
+    email: () => string;
+    invalidDate: (errorMessage: any) => any;
+}>;
+
+declare class HumanizeFormMessagesPipe implements PipeTransform {
+    private messages;
+    constructor(messages: any);
+    transform(validationErrors: ValidationErrors, overriddenMessages: {
+        [key: string]: string;
+    }): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HumanizeFormMessagesPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HumanizeFormMessagesPipe, "humanizeFormMessages", true>;
+}
+
+declare class DateUtils {
+    convertToMMDDYYYY(dateString: string | undefined | null): string | null;
+    convertTohhmm(dateString: string | undefined | null): string | null;
+    convertToDateTimeString(date: string, time?: string): string | undefined;
+    convertToMMYYYYString(mmyyyy: string): string | null;
+    getCurrentDateMMDDYYYY(): string | null;
+}
+
+declare function printInvalidFields(formGroup: FormGroup): void;
+
+declare function openLink(link: string, openInNewTab: boolean | undefined, document: Document, elementRef: ElementRef): void;
+
+interface JwtDecodeOptions {
+    header?: boolean;
+}
+interface JwtHeader {
+    typ?: string;
+    alg?: string;
+    kid?: string;
+}
+interface JwtPayload {
+    iss?: string;
+    sub?: string;
+    aud?: string[] | string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+}
+declare class InvalidTokenError extends Error {
+}
+declare function jwtDecode<T = JwtHeader>(token: string, options: JwtDecodeOptions & {
+    header: true;
+}): T;
+declare function jwtDecode<T = JwtPayload>(token: string, options?: JwtDecodeOptions): T;
+
+declare function arrayToCSV(arr: (string | null | undefined)[]): string;
+declare function arrayToSpaceSeparator(arr: (string | null | undefined)[]): string;
+declare function arrayToSeparator(arr: (string | null | undefined)[], separator?: string): string;
+declare function toSentenceCase(value: string): string;
+
+declare function mmddyyyyDateValidatorAsync(): AsyncValidatorFn;
+
+declare function onlyFutureDateValidator(): ValidatorFn;
+
+declare function onlyPastDateValidator(): ValidatorFn;
+
+declare class NglService {
+    private config;
+    constructor();
+    getBaseUrl(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NglService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NglService>;
+}
+
+interface NglConfig {
+    baseApiUrl: string;
+    enableUnsavedChangesWarning: boolean;
+    enableDevTools: boolean;
+}
+declare const NGL_CONFIG: InjectionToken<NglConfig>;
+
+declare function provideNglConfig(config: NglConfig): Provider;
+
+declare class SharedConstants {
+    static inputIdentifier: string;
+}
+
+export { AlertDialogComponent, AppErrorComponent, AppSvgIconComponent, BaseApiService, BaseControlValueAccessor, BaseControlValueAccessorV2, BaseControlValueAccessorV3, BaseInputComponent, BaseOverlayComponent, BaseTableComponent, BreadcrumbComponent, ButtonComponent, CheckboxComponent, ClickOutsideDirective, CloseButtonComponent, ColorConverterService, ColorFormats, ColorPickerComponent, ColorPickerDirective, ContextMenuButtonComponent, ContextMenuIconComponent, DataTableComponent, DateInputComponent, DatePickerComponent, DatePickerOverlayComponent, DateRangePickerComponent, DateUtils, DropdownComponent, DynamicRendererComponent, EnvBannerComponent, FORM_ERRORS, FileUploaderComponent, FormValidationUtils, HumanizeFormMessagesPipe, InputDateFormat, InvalidControlScrollContainerDirective, InvalidControlScrollDirective, InvalidTokenError, ListviewComponent, LoaderComponent, LoaderService, MultiSelectDropdownAppearance, MultiSelectDropdownComponent, MultiSelectionFieldComponent, NGL_CONFIG, NetworkImageComponent, NglService, NoDataComponent, NoDataTableComponent, NumberInputComponent, OpenFloatingMenuDirective, OverlayContextMenuComponent, OverlayService, OverlayWizardUtils, PaginationComponent, PaginationState, PhoneNumberInputComponent, RadioButtonComponent, RequestState, ResizableColumnDirective, ResponsiveHelperComponent, SharedConstants, ShimmerComponent, SingleItemPickerInputComponent, SingleSelectionFieldComponent, SortableTableDirective, SpinnerComponent, State, StatusBadgeComponent, SvgUrlIconComponent, SwitchComponent, TableCustomComponent, TableResizableColumnsDirective, TemplateResolverArrayUtil, TemplateResolverFormat, TextAreaInputComponent, TextInputComponent, TimePickerComponent, ToastComponent, ToastService, ToasterComponent, TooltipDirective, UnsavedAwareDirective, arrayToCSV, arrayToSeparator, arrayToSpaceSeparator, deepEqual, defaultErrors, getDynamicTypeStructure, isDynamicType, isValid, jsonEqual, jwtDecode, mmddyyyyDateValidatorAsync, onlyFutureDateValidator, onlyPastDateValidator, openLink, printInvalidFields, provideNglConfig, resolveTemplateWithObject, toSentenceCase };
+export type { ActionConfig, BadgeConfig, BadgeConfigProperty, BaseStateImpl, Breadcrumb, ColumnDef, ContextMenuActionConfig, ContextMenuButtonAction, CustomRendererConfig, DateConfig, DateRangeEvent, IconAction, JwtDecodeOptions, JwtHeader, JwtPayload, NglConfig, OverlayWizard, PaginationEvent, PagingEvent, Schema, TableActionEvent, TableSortEvent, TableStateEvent, TextConfig, TimePickerValue, TimePickerValueEvent, Weekday };