cloud-ide-element 1.0.11 → 1.0.13

package/index.d.ts

@@ -1,15 +1,16 @@
-import * as i0 from '@angular/core';
-import { PipeTransform, OnChanges, OnInit, EventEmitter, SimpleChanges, OnDestroy, Renderer2, ElementRef, AfterContentInit, QueryList, TemplateRef } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { PipeTransform, OnChanges, OnInit, OnDestroy, EventEmitter, TemplateRef, SimpleChanges, Renderer2, ElementRef, AfterContentInit, QueryList, ViewContainerRef, AfterViewInit, Signal, Type, Injector, ComponentRef } from '@angular/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
-import { elementStyleType, labelPlacementType, labelDirType, autocapitalizeType, autocompleteType, controlType, inputType, themeSize, spinnerType, iconType, selectSearchType, ICoreSype, GetElementDataRequest } from 'cloud-ide-lms-model';
+import { elementStyleType, labelPlacementType, labelDirType, autocapitalizeType, autocompleteType, controlType, inputType, themeSize, spinnerType, iconType, selectSearchType, ICoreSype, GetElementDataRequest, fileManagerListByGroupIdControllerResponse } from 'cloud-ide-lms-model';
 import { Router, NavigationExtras } from '@angular/router';
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
 import * as cloud_ide_element from 'cloud-ide-element';
+import { HttpClient, HttpEvent } from '@angular/common/http';
 
 declare class CapitalizePipe implements PipeTransform {
     transform(value: string, capitalizationMethod: 'allUpperCase' | 'titleCase' | 'sentenceCase'): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CapitalizePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CapitalizePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;
 }
 
 /** @description type to register error related to control */
@@ -22,7 +23,7 @@ type ValidationStatus = {
     validation: ErrorValidationStatus;
     status: boolean;
 };
-declare class CideInputComponent implements ControlValueAccessor, Validator, OnChanges, OnInit {
+declare class CideInputComponent implements ControlValueAccessor, Validator, OnChanges, OnInit, OnDestroy {
     capitalizePipe: CapitalizePipe;
     private elementService;
     constructor();
@@ -76,10 +77,10 @@ declare class CideInputComponent implements ControlValueAccessor, Validator, OnC
     /** @description to get input value using one way binding like: [ngModel] or by two way binding [(ngModel)] */
     ngModel: inputType;
     option: string[];
-    /** @description min value for number type control */
-    min: number;
-    /** @description max value for number type control */
-    max: number;
+    /** @description min value for number type control or min date for date type control */
+    min: number | string;
+    /** @description max value for number type control or max date for date type control */
+    max: number | string;
     /**
      * @description
      * Holds the size of the component like Small, Extra small, Large
@@ -106,6 +107,25 @@ declare class CideInputComponent implements ControlValueAccessor, Validator, OnC
     trailingIconInternal: string;
     isTrailingIconAllwedClick: boolean;
     idRandom: string;
+    showDatePicker: boolean;
+    showMonthYearSelector: boolean;
+    currentMonth: number;
+    currentYear: number;
+    selectedDate: Date | null;
+    calendarDays: {
+        day: number;
+        isCurrentMonth: boolean;
+        isSelected: boolean;
+        isToday: boolean;
+        date: Date;
+    }[];
+    monthNames: string[];
+    shortMonthNames: string[];
+    private portalService;
+    private datePickerPortalId;
+    private viewContainerRef;
+    datePickerTemplate: TemplateRef<any>;
+    private datePickerViewRef;
     /**
      * @description Function to call when the HTML Chnage to tell Angular somthing is changed.
      * @field value : inputType
@@ -143,6 +163,7 @@ declare class CideInputComponent implements ControlValueAccessor, Validator, OnC
     /** @description Detect wether input propertires canged or not */
     ngOnChanges(changes: SimpleChanges): void;
     ngOnInit(): void;
+    ngOnDestroy(): void;
     /** @description custom method run when HTML changes, we call method registerd by angular to detect change */
     upDateValue(value: {
         target: {
@@ -186,8 +207,70 @@ declare class CideInputComponent implements ControlValueAccessor, Validator, OnC
      * @description use to detact the change in type if changes done this method is ued to run
      */
     detectTypeChange(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideInputComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideInputComponent, "cide-ele-input", never, { "fill": { "alias": "fill"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelHide": { "alias": "labelHide"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "clearInput": { "alias": "clearInput"; "required": false; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; }; "labelDir": { "alias": "labelDir"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "helperTextCollapse": { "alias": "helperTextCollapse"; "required": false; }; "hideHelperAndErrorText": { "alias": "hideHelperAndErrorText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "required": { "alias": "required"; "required": false; }; "autocapitalize": { "alias": "autocapitalize"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "type": { "alias": "type"; "required": false; }; "width": { "alias": "width"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ngModel": { "alias": "ngModel"; "required": false; }; "option": { "alias": "option"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "ngModelChange": "ngModelChange"; }, never, never, true, never>;
+    /**
+     * @description Format date to YYYY-MM-DD format (for form submission)
+     */
+    formatDate(date: Date | string): string;
+    /**
+     * @description Format date for display as "DD/MMM/YYYY" (e.g., "20/Jun/2025")
+     */
+    formatDateForDisplay(date: Date | string): string;
+    /**
+     * @description Get display value for date input
+     */
+    getDateDisplayValue(): string;
+    /**
+     * @description Initialize date picker with current values
+     */
+    initializeDatePicker(): void;
+    /**
+     * @description Generate calendar days for current month
+     */
+    generateCalendar(): void;
+    /**
+     * @description Create date picker using template-based portal service
+     */
+    private createDatePickerUsingPortal;
+    /**
+     * @description Close date picker
+     */
+    closeDatePicker(): void;
+    /**
+     * @description Navigate to previous month
+     */
+    previousMonth(): void;
+    /**
+     * @description Navigate to next month
+     */
+    nextMonth(): void;
+    /**
+     * @description Navigate to previous year
+     */
+    previousYear(): void;
+    /**
+     * @description Navigate to next year
+     */
+    nextYear(): void;
+    /**
+     * @description Toggle between calendar and month/year selector
+     */
+    toggleMonthYearSelector(): void;
+    /**
+     * @description Select a month from the month selector
+     */
+    selectMonth(monthIndex: number): void;
+    /**
+     * @description Select a date from the calendar
+     */
+    selectDate(dayInfo: {
+        day: number;
+        isCurrentMonth: boolean;
+        isSelected: boolean;
+        isToday: boolean;
+        date: Date;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideInputComponent, "cide-ele-input", never, { "fill": { "alias": "fill"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelHide": { "alias": "labelHide"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "clearInput": { "alias": "clearInput"; "required": false; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; }; "labelDir": { "alias": "labelDir"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "helperTextCollapse": { "alias": "helperTextCollapse"; "required": false; }; "hideHelperAndErrorText": { "alias": "hideHelperAndErrorText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "required": { "alias": "required"; "required": false; }; "autocapitalize": { "alias": "autocapitalize"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "type": { "alias": "type"; "required": false; }; "width": { "alias": "width"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ngModel": { "alias": "ngModel"; "required": false; }; "option": { "alias": "option"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "ngModelChange": "ngModelChange"; }, never, never, true, never>;
 }
 
 type ButtonVariant = 'primary' | 'secondary' | 'outline' | 'text' | 'link' | 'success' | 'danger' | 'warning' | 'info' | 'ghost';
@@ -268,8 +351,8 @@ declare class CideEleButtonComponent implements OnInit, OnChanges, OnDestroy {
     ngOnChanges(changes: SimpleChanges): void;
     ngOnDestroy(): void;
     getControlData(): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleButtonComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleButtonComponent, "button[cideEleButton], a[cideEleButton]", never, { "label": { "alias": "label"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "elevation": { "alias": "elevation"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "rightIcon": { "alias": "rightIcon"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "testId": { "alias": "testId"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "routerExtras": { "alias": "routerExtras"; "required": false; }; "preventDoubleClick": { "alias": "preventDoubleClick"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; }, { "btnClick": "btnClick"; "doubleClick": "doubleClick"; }, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleButtonComponent, "button[cideEleButton], a[cideEleButton]", never, { "label": { "alias": "label"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "elevation": { "alias": "elevation"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "leftIcon": { "alias": "leftIcon"; "required": false; }; "rightIcon": { "alias": "rightIcon"; "required": false; }; "customClass": { "alias": "customClass"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "testId": { "alias": "testId"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "routerExtras": { "alias": "routerExtras"; "required": false; }; "preventDoubleClick": { "alias": "preventDoubleClick"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; }, { "btnClick": "btnClick"; "doubleClick": "doubleClick"; }, never, ["*"], true, never>;
 }
 
 declare class CideSpinnerComponent {
@@ -286,16 +369,16 @@ declare class CideSpinnerComponent {
      */
     size: themeSize;
     type: spinnerType;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideSpinnerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideSpinnerComponent, "cide-ele-spinner", never, { "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideSpinnerComponent, "cide-ele-spinner", never, { "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 declare class CideIconComponent {
     size: themeSize;
     type: iconType;
     toolTip: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideIconComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideIconComponent, "cide-ele-icon", never, { "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "toolTip": { "alias": "toolTip"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideIconComponent, "cide-ele-icon", never, { "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "toolTip": { "alias": "toolTip"; "required": false; }; }, {}, never, ["*"], true, never>;
 }
 
 interface SelectOption {
@@ -303,14 +386,18 @@ interface SelectOption {
     label: string;
     disabled?: boolean;
 }
+interface SelectOptionObject {
+    [key: string]: any;
+    disabled?: boolean;
+}
 declare class CideSelectOptionComponent {
     private elementRef;
     value: string | number;
     disabled: boolean;
     get label(): string;
     constructor(elementRef: ElementRef);
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideSelectOptionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideSelectOptionComponent, "cide-ele-select-option", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideSelectOptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideSelectOptionComponent, "cide-ele-select-option", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
 }
 declare class CideSelectComponent implements ControlValueAccessor, Validator, OnInit, OnChanges, AfterContentInit, OnDestroy {
     private elementRef;
@@ -324,7 +411,7 @@ declare class CideSelectComponent implements ControlValueAccessor, Validator, On
     required: boolean;
     disabled: boolean;
     id: string;
-    ngModel: string | number;
+    ngModel: string | number | string[];
     size: themeSize;
     fill: elementStyleType;
     labelPlacement: labelPlacementType;
@@ -332,19 +419,39 @@ declare class CideSelectComponent implements ControlValueAccessor, Validator, On
     leadingIcon: string;
     trailingIcon: string;
     clearInput: boolean;
-    options: SelectOption[];
+    options: (SelectOption | SelectOptionObject)[];
     multiple: boolean;
     searchable: boolean;
     showSearchInput: boolean;
     loading: boolean;
-    ngModelChange: EventEmitter<any>;
-    selectionChange: EventEmitter<SelectOption>;
+    /**
+     * Key to extract the value from option objects.
+     * Default: 'value'. Use when options are objects with custom property names.
+     * Example: if options = [{id: 1, name: 'John'}, {id: 2, name: 'Jane'}], set valueKey = 'id'
+     */
+    valueKey: string;
+    /**
+     * Key to extract the label from option objects.
+     * Default: 'label'. Use when options are objects with custom property names.
+     * Example: if options = [{id: 1, name: 'John'}, {id: 2, name: 'Jane'}], set labelKey = 'name'
+     */
+    labelKey: string;
+    ngModelChange: EventEmitter<string | number | string[]>;
+    selectionChange: EventEmitter<any>;
     searchChange: EventEmitter<selectSearchType>;
     isOpen: boolean;
     isTouched: boolean;
     isValid: boolean;
     searchTerm: string;
-    filteredOptions: SelectOption[];
+    filteredOptions: (SelectOption | SelectOptionObject)[];
+    private searchDebounceTimeout;
+    private searchSubject;
+    private destroy$;
+    private isUpdatingOptions;
+    private portalService;
+    private dropdownPortalId;
+    dropdownTemplate: TemplateRef<any>;
+    dropdownContainer: ViewContainerRef;
     dropdownPosition: 'bottom' | 'top';
     private isDropdownInteraction;
     private debugId;
@@ -363,12 +470,21 @@ declare class CideSelectComponent implements ControlValueAccessor, Validator, On
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     validate(control: AbstractControl): ValidationErrors | null;
-    validateValue(value: string | number): ValidationErrors | null;
+    validateValue(value: string | number | string[]): ValidationErrors | null;
     toggleDropdown(): void;
+    private openDropdown;
+    private closeDropdown;
     ngOnDestroy(): void;
+    private createDropdownPortal;
+    private destroyDropdownPortal;
+    private updatePortalContext;
+    private updateOptionsInDOM;
+    private setupDebouncedSearch;
+    private performSearch;
+    private cleanupOrphanedPortals;
     private onWindowResize;
     private calculateDropdownPosition;
-    selectOption(option: SelectOption): void;
+    selectOption(option: SelectOption | SelectOptionObject): void;
     onBlur(): void;
     focusControl(): void;
     clearSelection(): void;
@@ -376,14 +492,18 @@ declare class CideSelectComponent implements ControlValueAccessor, Validator, On
     filterOptions(): void;
     onSearchInput(event: Event): void;
     onDropdownMouseDown(): void;
+    onSearchInputBlur(event: Event): void;
     onDropdownMouseUp(): void;
-    isOptionSelected(option: SelectOption): boolean;
-    trackByValue(index: number, option: SelectOption): string | number;
+    isOptionSelected(option: SelectOption | SelectOptionObject): boolean;
+    getOptionValue(option: SelectOption | SelectOptionObject): string | number;
+    getOptionLabel(option: SelectOption | SelectOptionObject): string;
+    private isSelectOption;
+    trackByValue(index: number, option: SelectOption | SelectOptionObject): string | number;
     private logDebug;
     private clearTimeouts;
     private addTimeout;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideSelectComponent, "cide-ele-select", never, { "label": { "alias": "label"; "required": false; }; "labelHide": { "alias": "labelHide"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ngModel": { "alias": "ngModel"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; }; "labelDir": { "alias": "labelDir"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "clearInput": { "alias": "clearInput"; "required": false; }; "options": { "alias": "options"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "showSearchInput": { "alias": "showSearchInput"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "ngModelChange": "ngModelChange"; "selectionChange": "change"; "searchChange": "searchChange"; }, ["optionComponents"], never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideSelectComponent, "cide-ele-select", never, { "label": { "alias": "label"; "required": false; }; "labelHide": { "alias": "labelHide"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ngModel": { "alias": "ngModel"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; }; "labelDir": { "alias": "labelDir"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "clearInput": { "alias": "clearInput"; "required": false; }; "options": { "alias": "options"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "showSearchInput": { "alias": "showSearchInput"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "valueKey": { "alias": "valueKey"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; }, { "ngModelChange": "ngModelChange"; "selectionChange": "change"; "searchChange": "searchChange"; }, ["optionComponents"], never, true, never>;
 }
 
 interface TabItem {
@@ -401,53 +521,428 @@ declare class CideEleTabComponent implements OnInit {
     fullWidth: boolean;
     disabled: boolean;
     tabChange: EventEmitter<TabItem>;
-    activeTab: i0.WritableSignal<string>;
+    activeTab: _angular_core.WritableSignal<string>;
     ngOnInit(): void;
     onTabClick(tab: TabItem): void;
     isActive(tabId: string): boolean;
     getTabClasses(tab: TabItem): string;
     getContainerClasses(): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleTabComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleTabComponent, "cide-ele-tab", never, { "tabs": { "alias": "tabs"; "required": false; }; "activeTabId": { "alias": "activeTabId"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "tabChange": "tabChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleTabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleTabComponent, "cide-ele-tab", never, { "tabs": { "alias": "tabs"; "required": false; }; "activeTabId": { "alias": "activeTabId"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "tabChange": "tabChange"; }, never, never, true, never>;
 }
 
-declare class CideEleFileInputComponent implements ControlValueAccessor, OnDestroy {
+/**
+ * Angular 20: Proper TypeScript interface for file upload data
+ * This interface defines the structure of additional data that can be sent with file uploads
+ */
+interface FileUploadData {
+    /** Alternative text for the uploaded file (useful for accessibility) */
+    altText?: string;
+    /** User ID associated with the upload */
+    userId?: string;
+    /** Array of permissions for the uploaded file */
+    permissions?: string[];
+    /** Array of tags to categorize the uploaded file */
+    tags?: string[];
+    /** Status of the file (e.g., 'active', 'pending', 'archived') */
+    fileStatus?: "file_manager_file_status_active";
+    /** Group ID for multiple file uploads */
+    groupId?: string;
+    /** Allow additional properties with proper typing */
+    [key: string]: string | number | string[] | undefined;
+}
+declare class CideEleFileInputComponent implements ControlValueAccessor, OnDestroy, OnInit, OnChanges, Validator {
+    private readonly fileManagerService;
+    private readonly notificationService;
+    private readonly elementService;
+    private readonly destroyRef;
+    private readonly floatingFileUploaderService;
     label: string;
     accept: string;
     multiple: boolean;
     disabled: boolean;
+    required: boolean;
     helperText: string;
     errorText: string;
     showPreview: boolean;
     previewWidth: string;
     previewHeight: string;
     previewBoxMode: boolean;
+    showFileName: boolean;
     placeholderText: string;
     placeholderIcon: string;
-    id: string;
+    autoUpload: boolean;
+    uploadData: FileUploadData;
+    showFloatingUploader: boolean;
+    floatingUploaderGroupId?: string;
     fileChange: EventEmitter<FileList | null>;
-    files: FileList | null;
-    fileNames: string[];
-    previewUrls: string[];
+    uploadSuccess: EventEmitter<string>;
+    uploadError: EventEmitter<string>;
+    uploadProgressChange: EventEmitter<number>;
+    readonly labelSignal: _angular_core.WritableSignal<string>;
+    readonly acceptSignal: _angular_core.WritableSignal<string>;
+    readonly multipleSignal: _angular_core.WritableSignal<boolean>;
+    readonly disabledSignal: _angular_core.WritableSignal<boolean>;
+    readonly requiredSignal: _angular_core.WritableSignal<boolean>;
+    readonly helperTextSignal: _angular_core.WritableSignal<string>;
+    readonly errorTextSignal: _angular_core.WritableSignal<string>;
+    readonly showPreviewSignal: _angular_core.WritableSignal<boolean>;
+    readonly previewWidthSignal: _angular_core.WritableSignal<string>;
+    readonly previewHeightSignal: _angular_core.WritableSignal<string>;
+    readonly previewBoxModeSignal: _angular_core.WritableSignal<boolean>;
+    readonly showFileNameSignal: _angular_core.WritableSignal<boolean>;
+    readonly placeholderTextSignal: _angular_core.WritableSignal<string>;
+    readonly placeholderIconSignal: _angular_core.WritableSignal<string>;
+    readonly autoUploadSignal: _angular_core.WritableSignal<boolean>;
+    readonly uploadDataSignal: _angular_core.WritableSignal<FileUploadData>;
+    readonly showFloatingUploaderSignal: _angular_core.WritableSignal<boolean>;
+    readonly floatingUploaderGroupIdSignal: _angular_core.WritableSignal<string | undefined>;
+    readonly id: _angular_core.WritableSignal<string>;
+    readonly isUploading: _angular_core.WritableSignal<boolean>;
+    readonly uploadProgress: _angular_core.WritableSignal<number>;
+    readonly uploadStatus: _angular_core.WritableSignal<"error" | "start" | "success" | "uploading" | "idle">;
+    readonly files: _angular_core.WritableSignal<FileList | null>;
+    readonly fileNames: _angular_core.WritableSignal<string[]>;
+    readonly previewUrls: _angular_core.WritableSignal<string[]>;
+    readonly uploadNotificationId: _angular_core.WritableSignal<string | null>;
+    readonly isDragOver: _angular_core.WritableSignal<boolean>;
+    readonly groupId: _angular_core.WritableSignal<string | null>;
+    readonly isMultipleUploadMode: _angular_core.WritableSignal<boolean>;
+    readonly hasEverUploaded: _angular_core.WritableSignal<boolean>;
+    readonly hasFiles: _angular_core.Signal<boolean>;
+    readonly canUpload: _angular_core.Signal<boolean>;
+    readonly isInErrorState: _angular_core.Signal<boolean>;
+    readonly isInSuccessState: _angular_core.Signal<boolean>;
+    readonly totalFileSize: _angular_core.Signal<number>;
+    readonly fileSizeInMB: _angular_core.Signal<string>;
     private onChange;
     private onTouched;
-    writeValue(files: FileList | null): void;
-    registerOnChange(fn: (files: FileList | null) => void): void;
+    private onValidatorChange;
+    readonly hasImages: _angular_core.Signal<boolean>;
+    readonly isPreviewBoxMode: _angular_core.Signal<boolean>;
+    readonly isImagePreviewAvailable: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: FileList | string | null): void;
+    registerOnChange(fn: (value: FileList | string | null) => void): void;
     registerOnTouched(fn: () => void): void;
+    registerOnValidatorChange(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
     onFileSelected(event: Event): void;
     clearFiles(): void;
+    private uploadFile;
+    /**
+     * Upload multiple files with group ID support
+     * FLOW: 1) Generate group ID first, 2) Upload all files with same group ID, 3) Emit group ID on completion
+     */
+    private uploadMultipleFiles;
+    /**
+     * Start uploading multiple files with the provided group ID
+     * All files will be uploaded with the SAME group ID that was generated before this method
+     */
+    private startMulti;
+    /**
+     * Handle completion of multiple file upload
+     */
+    private handleMultipleUploadComplete;
     private generatePreviews;
     private clearPreviews;
     private isImageFile;
-    isImagePreviewAvailable(): boolean;
+    private loadFileDetailsFromId;
+    /**
+     * Check if the component is in multiple file mode
+     */
+    private isMultipleFileMode;
+    /**
+     * Load files from group ID using the group API
+     */
+    private loadFilesFromGroupId;
+    private isImageFileFromName;
+    private isImageFileFromType;
     removePreview(index: number): void;
     ngOnDestroy(): void;
     triggerFileSelect(): void;
-    isPreviewBoxMode(): boolean;
-    hasImages(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleFileInputComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleFileInputComponent, "cide-ele-file-input", never, { "label": { "alias": "label"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "showPreview": { "alias": "showPreview"; "required": false; }; "previewWidth": { "alias": "previewWidth"; "required": false; }; "previewHeight": { "alias": "previewHeight"; "required": false; }; "previewBoxMode": { "alias": "previewBoxMode"; "required": false; }; "placeholderText": { "alias": "placeholderText"; "required": false; }; "placeholderIcon": { "alias": "placeholderIcon"; "required": false; }; }, { "fileChange": "fileChange"; }, never, never, true, never>;
+    /**
+     * Show floating uploader manually
+     * This can be called to show the floating uploader even when no files are selected
+     */
+    showUploader(): void;
+    /**
+     * Get total upload count from file manager service for this component's group ID
+     * Uses optimized service method for better performance
+     * Only counts files for this component's specific group ID
+     */
+    getUploadCount(): number;
+    /**
+     * Check if there are active uploads for this component's group ID
+     * Uses optimized service method for better performance
+     * Only checks files for this component's specific group ID
+     */
+    hasActiveUploads(): boolean;
+    /**
+     * Get count of active (non-completed) uploads for this component's group ID
+     * Only counts files for this component's specific group ID
+     */
+    getActiveUploadCount(): number;
+    /**
+     * Show floating uploader (alias for showUploader for template)
+     */
+    showFloatingUploaderDialog(): Promise<void>;
+    /**
+     * Get dynamic classes for drag and drop zone
+     */
+    getDragDropZoneClasses(): string;
+    /**
+     * Get dynamic classes for icon
+     */
+    getIconClasses(): string;
+    /**
+     * Get dynamic classes for preview box
+     */
+    getPreviewBoxClasses(): string;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDragEnter(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    private validateFileTypes;
+    private handleFileSelection;
+    isRequired(): boolean;
+    /**
+     * Angular 20: Utility method to get upload data with proper typing
+     * @returns Properly typed upload data
+     */
+    getUploadData(): FileUploadData;
+    /**
+     * Angular 20: Utility method to update upload data with type safety
+     * @param data Partial upload data to merge with existing data
+     */
+    updateUploadData(data: Partial<FileUploadData>): void;
+    getCurrentState(): {
+        id: string;
+        label: string;
+        required: boolean;
+        disabled: boolean;
+        accept: string;
+        multiple: boolean;
+        showPreview: boolean;
+        autoUpload: boolean;
+        uploadStatus: "error" | "start" | "success" | "uploading" | "idle";
+        isUploading: boolean;
+        uploadProgress: number;
+        files: {
+            name: string;
+            size: number;
+            type: string;
+        }[] | null;
+        fileNames: string[];
+        previewUrls: number;
+        helperText: string;
+        errorText: string;
+        placeholderText: string;
+        placeholderIcon: string;
+        previewWidth: string;
+        previewHeight: string;
+        previewBoxMode: boolean;
+        showFileName: boolean;
+        uploadData: FileUploadData;
+    };
+    getControlData(): Promise<void>;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFileInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleFileInputComponent, "cide-ele-file-input", never, { "label": { "alias": "label"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "showPreview": { "alias": "showPreview"; "required": false; }; "previewWidth": { "alias": "previewWidth"; "required": false; }; "previewHeight": { "alias": "previewHeight"; "required": false; }; "previewBoxMode": { "alias": "previewBoxMode"; "required": false; }; "showFileName": { "alias": "showFileName"; "required": false; }; "placeholderText": { "alias": "placeholderText"; "required": false; }; "placeholderIcon": { "alias": "placeholderIcon"; "required": false; }; "autoUpload": { "alias": "autoUpload"; "required": false; }; "uploadData": { "alias": "uploadData"; "required": false; }; "showFloatingUploader": { "alias": "showFloatingUploader"; "required": false; }; "floatingUploaderGroupId": { "alias": "floatingUploaderGroupId"; "required": false; }; }, { "fileChange": "fileChange"; "uploadSuccess": "uploadSuccess"; "uploadError": "uploadError"; "uploadProgressChange": "uploadProgressChange"; }, never, never, true, never>;
+}
+
+interface FloatingFileUploaderData {
+    userId?: string;
+    groupId?: string;
+    title?: string;
+    description?: string;
+    maxFileSize?: number;
+    allowedFileTypes?: string[];
+    multiple?: boolean;
+}
+declare class CideEleFloatingFileUploaderComponent implements OnInit, OnDestroy {
+    private destroyRef;
+    private fileManagerService;
+    data: FloatingFileUploaderData;
+    isVisible: _angular_core.WritableSignal<boolean>;
+    currentUserId: _angular_core.WritableSignal<string>;
+    currentGroupId: _angular_core.WritableSignal<string | null>;
+    uploadQueue: _angular_core.Signal<string[]>;
+    activeUploads: _angular_core.Signal<Map<string, cloud_ide_element.UploadProgress>>;
+    hasUploads: _angular_core.Signal<boolean>;
+    hasActiveUploads: _angular_core.Signal<boolean>;
+    pendingUploads: _angular_core.Signal<string[]>;
+    activeUploadsLocal: _angular_core.Signal<cloud_ide_element.UploadProgress[]>;
+    completedUploads: _angular_core.Signal<cloud_ide_element.UploadProgress[]>;
+    failedUploads: _angular_core.Signal<cloud_ide_element.UploadProgress[]>;
+    allFilesForGroup: _angular_core.Signal<{
+        fileId: string;
+        fileName: string;
+        stage: string;
+        percentage?: number;
+    }[]>;
+    hasFilesToShow: _angular_core.Signal<boolean>;
+    getUploadingCount(): number;
+    getCompletedCount(): number;
+    getFailedCount(): number;
+    isAnimating: _angular_core.WritableSignal<boolean>;
+    isDragOver: _angular_core.WritableSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    private initializeWithData;
+    private loadExistingFiles;
+    ngOnDestroy(): void;
+    /**
+     * Set up drag and drop functionality
+     */
+    private setupDragAndDrop;
+    /**
+     * Remove drag and drop listeners
+     */
+    private removeDragAndDropListeners;
+    /**
+     * Set up file input change listeners
+     */
+    private setupFileInputListeners;
+    /**
+     * Remove file input listeners
+     */
+    private removeFileInputListeners;
+    /**
+     * Handle file input change events
+     */
+    private handleFileInputChange;
+    /**
+     * Handle drag over event
+     */
+    private handleDragOver;
+    /**
+     * Handle drag leave event
+     */
+    private handleDragLeave;
+    /**
+     * Handle drop event
+     */
+    private handleDrop;
+    /**
+     * Handle files from drag and drop or file input
+     */
+    private handleFiles;
+    /**
+     * Update visibility - simplified for notification only
+     */
+    updateVisibility(): void;
+    /**
+     * Show with animation
+     */
+    private showWithAnimation;
+    /**
+     * Hide with animation
+     */
+    private hideWithAnimation;
+    /**
+     * Get upload summary text
+     */
+    getUploadSummary(): string;
+    /**
+     * Get overall progress percentage
+     */
+    getOverallProgress(): number;
+    /**
+     * Get status icon based on upload stage
+     */
+    getStatusIcon(stage: string): string;
+    /**
+     * Get status class based on upload stage
+     */
+    getStatusClass(stage: string): string;
+    /**
+     * Cancel upload
+     */
+    cancelUpload(fileId: string): void;
+    /**
+     * Get file name from file ID (extract from the ID format)
+     */
+    getFileNameFromId(fileId: string): string;
+    /**
+     * Get all files from service state (pending + active uploads + fetched files)
+     * This method now uses the computed property for consistency
+     */
+    getAllFiles(): {
+        fileId: string;
+        fileName: string;
+        stage: string;
+        percentage?: number;
+    }[];
+    /**
+     * Set current user ID
+     */
+    setCurrentUserId(userId: string): void;
+    /**
+     * Check if there are any uploads for the current group
+     */
+    hasUploadsForCurrentGroup(): boolean;
+    /**
+     * Handle drag over event for file drop
+     */
+    onDragOver(event: DragEvent): void;
+    /**
+     * Handle drag leave event for file drop
+     */
+    onDragLeave(event: DragEvent): void;
+    /**
+     * Handle drop event for file drop
+     */
+    onDrop(event: DragEvent): void;
+    /**
+     * Trigger file input click
+     */
+    triggerFileInput(): void;
+    /**
+     * Handle file input change
+     */
+    onFileInputChange(event: Event): void;
+    /**
+     * Handle file selection from drag/drop or file input
+     */
+    private handleFileSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFloatingFileUploaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleFloatingFileUploaderComponent, "cide-ele-floating-file-uploader", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface FileUploaderData {
+    groupId?: string;
+    userId?: string;
+    allowedTypes?: string[];
+    maxFileSize?: number;
+    uploadPath?: string;
+    multiple?: boolean;
+    autoUpload?: boolean;
+}
+declare class CideEleFloatingFileUploaderService {
+    private containerService;
+    constructor();
+    private initializeFileUploader;
+    /**
+     * Show file uploader in floating container
+     */
+    show(data?: FileUploaderData): Promise<string>;
+    /**
+     * Hide file uploader
+     */
+    hide(): void;
+    /**
+     * Show file uploader with specific group ID
+     */
+    showWithGroupId(groupId: string, additionalData?: Partial<FileUploaderData>): Promise<string>;
+    /**
+     * Show file uploader for user with specific settings
+     */
+    showForUser(userId: string, settings?: Partial<FileUploaderData>): Promise<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFloatingFileUploaderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideEleFloatingFileUploaderService>;
 }
 
 declare class CideTextareaComponent implements ControlValueAccessor, Validator, OnInit, OnChanges {
@@ -490,8 +985,107 @@ declare class CideTextareaComponent implements ControlValueAccessor, Validator,
     onBlur(): void;
     ClearInputValue(): void;
     trailingIconClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideTextareaComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideTextareaComponent, "cide-ele-textarea", never, { "label": { "alias": "label"; "required": false; }; "labelHide": { "alias": "labelHide"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ngModel": { "alias": "ngModel"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; }; "labelDir": { "alias": "labelDir"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "clearInput": { "alias": "clearInput"; "required": false; }; }, { "ngModelChange": "ngModelChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideTextareaComponent, "cide-ele-textarea", never, { "label": { "alias": "label"; "required": false; }; "labelHide": { "alias": "labelHide"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ngModel": { "alias": "ngModel"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; }; "labelDir": { "alias": "labelDir"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "trailingIcon": { "alias": "trailingIcon"; "required": false; }; "clearInput": { "alias": "clearInput"; "required": false; }; }, { "ngModelChange": "ngModelChange"; }, never, never, true, never>;
+}
+
+interface KeyboardShortcut {
+    id: string;
+    key: string;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    metaKey?: boolean;
+    description?: string;
+    action: () => void;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+}
+interface ShortcutOverride {
+    shortcutId: string;
+    newKey: string;
+    newCtrlKey?: boolean;
+    newAltKey?: boolean;
+    newShiftKey?: boolean;
+    newMetaKey?: boolean;
+}
+declare class KeyboardShortcutService implements OnDestroy {
+    private shortcuts;
+    private overrides;
+    private keydownListener?;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Register a new keyboard shortcut
+     */
+    register(shortcut: KeyboardShortcut): void;
+    /**
+     * Override an existing shortcut with new key combination
+     */
+    override(shortcutId: string, newKey: string, options?: {
+        ctrlKey?: boolean;
+        altKey?: boolean;
+        shiftKey?: boolean;
+        metaKey?: boolean;
+    }): void;
+    /**
+     * Remove a shortcut
+     */
+    unregister(shortcutId: string): void;
+    /**
+     * Remove override for a shortcut (restore original key combination)
+     */
+    removeOverride(shortcutId: string): void;
+    /**
+     * Get all registered shortcuts
+     */
+    getAllShortcuts(): KeyboardShortcut[];
+    /**
+     * Get shortcuts by category or filter
+     */
+    getShortcuts(filter?: (shortcut: KeyboardShortcut) => boolean): KeyboardShortcut[];
+    /**
+     * Check if a shortcut is registered
+     */
+    hasShortcut(shortcutId: string): boolean;
+    /**
+     * Get shortcut information
+     */
+    getShortcut(shortcutId: string): KeyboardShortcut | undefined;
+    /**
+     * Clear all shortcuts
+     */
+    clearAll(): void;
+    /**
+     * Set up global keyboard listener
+     */
+    private setupGlobalListener;
+    /**
+     * Remove global keyboard listener
+     */
+    private removeGlobalListener;
+    /**
+     * Handle keydown events
+     */
+    private handleKeydown;
+    /**
+     * Check if event matches shortcut
+     */
+    private matchesShortcut;
+    /**
+     * Check if event matches override
+     */
+    private matchesOverride;
+    /**
+     * Get human-readable key description
+     */
+    private getKeyDescription;
+    /**
+     * Get key description for a shortcut ID
+     */
+    getKeyDescriptionForShortcut(shortcutId: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyboardShortcutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KeyboardShortcutService>;
 }
 
 declare class CideElementsService {
@@ -500,8 +1094,8 @@ declare class CideElementsService {
     };
     is_cide_element_data_updated: BehaviorSubject<boolean>;
     getElementData(body: GetElementDataRequest): Promise<ICoreSype>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideElementsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CideElementsService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideElementsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideElementsService>;
 }
 
 type CideEleResizerDirection = 'horizontal' | 'vertical';
@@ -543,8 +1137,8 @@ declare class CideEleResizerDirective implements OnInit {
     private getPrevElement;
     private getNextElement;
     private getSizeProperty;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleResizerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CideEleResizerDirective, "[cideEleResizer]", never, { "direction": { "alias": "direction"; "required": false; }; "to": { "alias": "to"; "required": false; }; "prevElementSelector": { "alias": "prevElementSelector"; "required": false; }; "nextElementSelector": { "alias": "nextElementSelector"; "required": false; }; "parentElementSelector": { "alias": "parentElementSelector"; "required": false; }; "minPrevSize": { "alias": "minPrevSize"; "required": false; }; "minNextSize": { "alias": "minNextSize"; "required": false; }; "usePercentage": { "alias": "usePercentage"; "required": false; }; }, { "resizeStart": "resizeStart"; "resizing": "resizing"; "resizeEnd": "resizeEnd"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleResizerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CideEleResizerDirective, "[cideEleResizer]", never, { "direction": { "alias": "direction"; "required": false; }; "to": { "alias": "to"; "required": false; }; "prevElementSelector": { "alias": "prevElementSelector"; "required": false; }; "nextElementSelector": { "alias": "nextElementSelector"; "required": false; }; "parentElementSelector": { "alias": "parentElementSelector"; "required": false; }; "minPrevSize": { "alias": "minPrevSize"; "required": false; }; "minNextSize": { "alias": "minNextSize"; "required": false; }; "usePercentage": { "alias": "usePercentage"; "required": false; }; }, { "resizeStart": "resizeStart"; "resizing": "resizing"; "resizeEnd": "resizeEnd"; }, never, never, true, never>;
 }
 
 type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
@@ -585,8 +1179,26 @@ declare class TooltipDirective implements OnInit, OnDestroy {
     private styleTooltip;
     private positionTooltip;
     private destroyTooltip;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[cideEleTooltip]", never, { "cideEleTooltip": { "alias": "cideEleTooltip"; "required": false; }; "tooltipColor": { "alias": "tooltipColor"; "required": false; }; "tooltipBg": { "alias": "tooltipBg"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipType": { "alias": "tooltipType"; "required": false; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; }; "tooltipDir": { "alias": "tooltipDir"; "required": false; }; "tooltipShowArrow": { "alias": "tooltipShowArrow"; "required": false; }; "tooltipMultiline": { "alias": "tooltipMultiline"; "required": false; }; "tooltipMaxWidth": { "alias": "tooltipMaxWidth"; "required": false; }; "tooltipInteractive": { "alias": "tooltipInteractive"; "required": false; }; "tooltipClass": { "alias": "tooltipClass"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[cideEleTooltip]", never, { "cideEleTooltip": { "alias": "cideEleTooltip"; "required": false; }; "tooltipColor": { "alias": "tooltipColor"; "required": false; }; "tooltipBg": { "alias": "tooltipBg"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipType": { "alias": "tooltipType"; "required": false; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; }; "tooltipDir": { "alias": "tooltipDir"; "required": false; }; "tooltipShowArrow": { "alias": "tooltipShowArrow"; "required": false; }; "tooltipMultiline": { "alias": "tooltipMultiline"; "required": false; }; "tooltipMaxWidth": { "alias": "tooltipMaxWidth"; "required": false; }; "tooltipInteractive": { "alias": "tooltipInteractive"; "required": false; }; "tooltipClass": { "alias": "tooltipClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive to display images from file manager by ID
+ * Usage: <img cideEleFileImage [fileId]="yourFileId" [altText]="'Image'" class="your-css-classes" />
+ */
+declare class CideEleFileImageDirective implements OnInit, OnDestroy {
+    fileId: string | null;
+    altText: string;
+    private readonly fileManagerService;
+    private readonly elementRef;
+    private readonly destroyRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadImage;
+    private displayImage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFileImageDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CideEleFileImageDirective, "[cideEleFileImage]", never, { "fileId": { "alias": "fileId"; "required": false; }; "altText": { "alias": "altText"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 declare class CideEleSkeletonLoaderComponent {
@@ -596,8 +1208,8 @@ declare class CideEleSkeletonLoaderComponent {
     count: number;
     circle: boolean;
     animation: 'pulse' | 'wave' | 'none';
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleSkeletonLoaderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleSkeletonLoaderComponent, "cide-ele-skeleton-loader", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "count": { "alias": "count"; "required": false; }; "circle": { "alias": "circle"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleSkeletonLoaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleSkeletonLoaderComponent, "cide-ele-skeleton-loader", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "count": { "alias": "count"; "required": false; }; "circle": { "alias": "circle"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 type ColumnType = 'text' | 'number' | 'date' | 'boolean' | 'status' | 'actions' | 'custom' | 'order';
@@ -738,6 +1350,7 @@ interface GridEvent<T = Record<string, unknown>> {
         targetItem: T;
         targetIndex: number;
         newOrder: T[];
+        allOrders?: T[];
     };
     column?: GridColumn;
     action?: GridAction;
@@ -754,11 +1367,8 @@ interface TemplateContext<T = Record<string, unknown>> {
     column: GridColumn;
 }
 type TemplateRenderer<T = Record<string, unknown>> = TemplateRef<TemplateContext<T>>;
-type StringRenderer<T = Record<string, unknown>> = (value: unknown, row: T) => string;
-type Renderer<T = Record<string, unknown>> = StringRenderer<T> | TemplateRenderer<T>;
 declare class CideEleDataGridComponent<T = Record<string, unknown>> implements OnInit, OnChanges, OnDestroy {
     config: GridConfiguration<T>;
-    customRenderers: Record<string, StringRenderer<T>>;
     templateRenderers: Record<string, unknown>;
     customFormatters: Record<string, (value: unknown, format?: string) => string>;
     actionHandlers: Record<string, (data: T, action?: GridAction) => void>;
@@ -770,27 +1380,27 @@ declare class CideEleDataGridComponent<T = Record<string, unknown>> implements O
     gridEvent: EventEmitter<GridEvent<T>>;
     private internalData;
     private filteredData;
-    currentPage: i0.WritableSignal<number>;
-    pageSize: i0.WritableSignal<number>;
-    totalItems: i0.WritableSignal<number>;
-    totalPages: i0.WritableSignal<number>;
-    searchQuery: i0.WritableSignal<string>;
-    loading: i0.WritableSignal<boolean>;
-    isRefreshing: i0.WritableSignal<boolean>;
-    pageChangeLoading: i0.WritableSignal<boolean>;
+    currentPage: _angular_core.WritableSignal<number>;
+    pageSize: _angular_core.WritableSignal<number>;
+    totalItems: _angular_core.WritableSignal<number>;
+    totalPages: _angular_core.WritableSignal<number>;
+    searchQuery: _angular_core.WritableSignal<string>;
+    loading: _angular_core.WritableSignal<boolean>;
+    isRefreshing: _angular_core.WritableSignal<boolean>;
+    pageChangeLoading: _angular_core.WritableSignal<boolean>;
     jumpToPage: number;
     isDragOverRow: number | null;
-    isDragging: i0.WritableSignal<boolean>;
-    hasOrderChanged: i0.WritableSignal<boolean>;
+    isDragging: _angular_core.WritableSignal<boolean>;
+    hasOrderChanged: _angular_core.WritableSignal<boolean>;
     private originalOrderIds;
     private initialDataOrderIds;
     private rowOrderMap;
     private localReorderedData;
     private searchDebounceTimer?;
     private isDataUpdate;
-    hasNextPage: i0.Signal<boolean>;
-    hasPreviousPage: i0.Signal<boolean>;
-    mergedConfig: i0.WritableSignal<GridConfiguration<T>>;
+    hasNextPage: _angular_core.Signal<boolean>;
+    hasPreviousPage: _angular_core.Signal<boolean>;
+    mergedConfig: _angular_core.WritableSignal<GridConfiguration<T>>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     ngOnChanges(changes: SimpleChanges): void;
@@ -822,6 +1432,14 @@ declare class CideEleDataGridComponent<T = Record<string, unknown>> implements O
      */
     private refreshOrderTracking;
     private applyFilters;
+    /**
+     * Preserve tree expansion state from current data
+     */
+    private preserveTreeExpansionState;
+    /**
+     * Apply preserved tree expansion state to new data
+     */
+    private applyTreeExpansionState;
     /**
      * Transform flat data to tree structure based on foreign key relationships
      */
@@ -841,7 +1459,7 @@ declare class CideEleDataGridComponent<T = Record<string, unknown>> implements O
     private updatePaginationState;
     onPageChange(page: number | string): void;
     onPageSizeChange(): void;
-    updatePageSize(value: string | number): void;
+    updatePageSize(value: string | number | string[]): void;
     previousPage(): void;
     nextPage(): void;
     onJumpToPage(): void;
@@ -925,16 +1543,29 @@ declare class CideEleDataGridComponent<T = Record<string, unknown>> implements O
     private checkIfOrderChanged;
     /**
      * Reset the row order map to original positions (for reset action)
+     * Includes all items from hierarchical structure (parents and children)
      */
     private resetRowOrderMap;
     /**
      * Update the row order map baseline to current positions (for save action)
+     * Includes all items from hierarchical structure (parents and children)
      */
     private updateRowOrderMapBaseline;
     /**
      * Get the current order array from the row order map
+     * Includes all items from hierarchical structure (parents and children)
      */
     private getCurrentOrderFromMap;
+    /**
+     * Get only the items that have actually changed order
+     * Includes all items from hierarchical structure (parents and children)
+     */
+    private getChangedOrders;
+    /**
+     * Flatten all data for order tracking (includes all hierarchical children)
+     * This method ensures that all items (parents and children) are included in order tracking
+     */
+    private flattenAllDataForOrderTracking;
     /**
      * Update local data order for visual reordering (LOCAL ONLY)
      */
@@ -957,15 +1588,37 @@ declare class CideEleDataGridComponent<T = Record<string, unknown>> implements O
      * // value === 'test@example.com'
      */
     getNestedValue(obj: T, path: string): unknown;
+    /**
+     * Set a nested value in an object using dot notation
+     * @param obj The object to modify
+     * @param path The dot notation path (e.g., 'contact.email')
+     * @param value The value to set
+     * @example
+     * const obj = { contact: { email: 'old@example.com' } };
+     * setNestedValue(obj, 'contact.email', 'new@example.com');
+     * // obj.contact.email === 'new@example.com'
+     */
+    setNestedValue(obj: T, path: string, value: unknown): void;
+    /**
+     * Compare two order arrays to check if they are different
+     * This method can be used by parent components to check if order has actually changed
+     * @param currentOrder Current order array
+     * @param originalOrder Original order array
+     * @returns true if orders are different, false if they are the same
+     */
+    compareOrders(currentOrder: Array<{
+        id: string | undefined;
+        order: number | undefined;
+    }>, originalOrder: Array<{
+        id: string | undefined;
+        order: number | undefined;
+    }>): boolean;
     formatValue(value: unknown, column: GridColumn): string;
     private formatDate;
     private formatCurrency;
     private formatPercentage;
-    renderCustomCell(value: unknown, row: T, column: GridColumn): string;
     isTemplateRenderer(rendererKey: string): boolean;
-    isStringRenderer(rendererKey: string): boolean;
     getTemplateRenderer(rendererKey: string): TemplateRenderer<T> | null;
-    getStringRenderer(rendererKey: string): StringRenderer<T> | null;
     getTemplateContext(value: unknown, row: T, column: GridColumn): TemplateContext<T>;
     getColumnWidthClass(width?: ColumnWidth): string;
     getColumnMaxWidthClass(width?: ColumnWidth): string;
@@ -984,8 +1637,8 @@ declare class CideEleDataGridComponent<T = Record<string, unknown>> implements O
     get searchConfig(): cloud_ide_element.GridSearchConfig;
     get loadingConfig(): cloud_ide_element.GridLoadingConfig;
     get scrollConfig(): cloud_ide_element.GridScrollConfig | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleDataGridComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleDataGridComponent<any>, "cide-ele-data-grid", never, { "config": { "alias": "config"; "required": false; }; "customRenderers": { "alias": "customRenderers"; "required": false; }; "templateRenderers": { "alias": "templateRenderers"; "required": false; }; "customFormatters": { "alias": "customFormatters"; "required": false; }; "actionHandlers": { "alias": "actionHandlers"; "required": false; }; "serverSidePagination": { "alias": "serverSidePagination"; "required": false; }; "totalServerItems": { "alias": "totalServerItems"; "required": false; }; "currentServerPage": { "alias": "currentServerPage"; "required": false; }; "currentServerPageSize": { "alias": "currentServerPageSize"; "required": false; }; "dragDropEnabled": { "alias": "dragDropEnabled"; "required": false; }; }, { "gridEvent": "gridEvent"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleDataGridComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleDataGridComponent<any>, "cide-ele-data-grid", never, { "config": { "alias": "config"; "required": false; }; "templateRenderers": { "alias": "templateRenderers"; "required": false; }; "customFormatters": { "alias": "customFormatters"; "required": false; }; "actionHandlers": { "alias": "actionHandlers"; "required": false; }; "serverSidePagination": { "alias": "serverSidePagination"; "required": false; }; "totalServerItems": { "alias": "totalServerItems"; "required": false; }; "currentServerPage": { "alias": "currentServerPage"; "required": false; }; "currentServerPageSize": { "alias": "currentServerPageSize"; "required": false; }; "dragDropEnabled": { "alias": "dragDropEnabled"; "required": false; }; }, { "gridEvent": "gridEvent"; }, never, never, true, never>;
 }
 
 interface DropdownItem {
@@ -1010,6 +1663,8 @@ interface DropdownConfig {
     forcePosition?: 'top' | 'bottom' | 'left' | 'right';
     offsetX?: number;
     offsetY?: number;
+    minWidth?: number;
+    usePortal?: boolean;
 }
 interface DropdownPosition {
     vertical: 'top' | 'bottom';
@@ -1024,9 +1679,13 @@ interface DropdownPosition {
 declare class CideEleDropdownComponent implements OnInit, OnDestroy {
     private destroyRef;
     private dropdownManager;
+    private portalService;
+    private viewContainerRef;
     private dropdownId;
-    dropdownContainer: i0.Signal<ElementRef<any>>;
-    dropdownMenu: i0.Signal<ElementRef<any> | undefined>;
+    private portalId;
+    dropdownContainer: _angular_core.Signal<ElementRef<any>>;
+    dropdownMenu: _angular_core.Signal<ElementRef<any> | undefined>;
+    dropdownMenuTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
     set items(value: DropdownItem[]);
     get items(): DropdownItem[];
     private _items;
@@ -1039,27 +1698,30 @@ declare class CideEleDropdownComponent implements OnInit, OnDestroy {
     }>;
     itemClick: EventEmitter<DropdownItem>;
     dropdownToggle: EventEmitter<boolean>;
-    isOpen: i0.WritableSignal<boolean>;
-    currentPosition: i0.WritableSignal<DropdownPosition>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    currentPosition: _angular_core.WritableSignal<DropdownPosition>;
     ngOnInit(): void;
-    ngOnDestroy(): void;
     getTriggerClasses(): string;
     getTriggerIconClasses(): string;
     getMenuClasses(): string;
     getMenuStyles(): string;
     calculatePosition(): DropdownPosition;
     private getMenuWidth;
+    protected getSafeConfig(): DropdownConfig;
     private getEstimatedMenuHeight;
     toggleDropdown(event: Event): void;
     private openDropdown;
     testMouseDown(item: DropdownItem): void;
     onItemClick(item: DropdownItem, event: Event): void;
+    private createPortalDropdown;
+    private destroyPortalDropdown;
     closeDropdown(): void;
     getItemClasses(item: DropdownItem): string;
     onWindowResize(): void;
     onWindowScroll(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleDropdownComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleDropdownComponent, "cide-ele-dropdown", never, { "items": { "alias": "items"; "required": false; }; "config": { "alias": "config"; "required": false; }; "triggerTemplate": { "alias": "triggerTemplate"; "required": false; }; "menuTemplate": { "alias": "menuTemplate"; "required": false; }; }, { "itemClick": "itemClick"; "dropdownToggle": "dropdownToggle"; }, never, never, true, never>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleDropdownComponent, "cide-ele-dropdown", never, { "items": { "alias": "items"; "required": false; }; "config": { "alias": "config"; "required": false; }; "triggerTemplate": { "alias": "triggerTemplate"; "required": false; }; "menuTemplate": { "alias": "menuTemplate"; "required": false; }; }, { "itemClick": "itemClick"; "dropdownToggle": "dropdownToggle"; }, never, never, true, never>;
 }
 
 interface DropdownInstance {
@@ -1080,8 +1742,8 @@ declare class DropdownManagerService {
     isDropdownOpen(id: string): boolean;
     private handleDocumentClick;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownManagerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownManagerService>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownManagerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DropdownManagerService>;
 }
 
 interface ConfirmationRequest<T = unknown> {
@@ -1107,12 +1769,13 @@ interface ConfirmationOptions<T = unknown> {
     customTemplate?: TemplateRef<unknown>;
     customData?: T;
 }
-declare class ConfirmationService {
-    private confirmationQueue;
-    private currentRequest;
-    hasActiveConfirmation: i0.Signal<boolean>;
-    queueLength: i0.Signal<number>;
+declare class ConfirmationService implements OnDestroy {
+    private readonly confirmationQueue;
+    private readonly currentRequest;
+    readonly hasActiveConfirmation: _angular_core.Signal<boolean>;
+    readonly queueLength: _angular_core.Signal<number>;
     constructor();
+    ngOnDestroy(): void;
     /**
      * Ask for confirmation with a simple yes/no dialog
      */
@@ -1142,10 +1805,10 @@ declare class ConfirmationService {
     private removeCurrentRequest;
     private generateId;
     private getDefaultIcon;
-    getCurrentRequest(): i0.WritableSignal<ConfirmationRequest<unknown> | null>;
-    getHasActiveConfirmation(): i0.Signal<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmationService>;
+    getCurrentRequest(): _angular_core.WritableSignal<ConfirmationRequest<unknown> | null>;
+    getHasActiveConfirmation(): _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ConfirmationService>;
 }
 
 interface NotificationOptions {
@@ -1157,6 +1820,8 @@ interface NotificationOptions {
     undoText?: string;
     icon?: string;
     title?: string;
+    progress?: number;
+    showProgress?: boolean;
 }
 interface NotificationItem {
     id: string;
@@ -1170,11 +1835,13 @@ interface NotificationItem {
     title?: string;
     timestamp: number;
     isVisible: boolean;
+    progress?: number;
+    showProgress?: boolean;
 }
 declare class NotificationService {
     private notifications;
     private maxNotifications;
-    activeNotifications: i0.Signal<NotificationItem[]>;
+    activeNotifications: _angular_core.Signal<NotificationItem[]>;
     constructor();
     /**
      * Show a success notification
@@ -1204,6 +1871,14 @@ declare class NotificationService {
      * Show a notification for background tasks
      */
     showBackgroundTask(taskName: string, isComplete?: boolean, options?: Partial<NotificationOptions>): string;
+    /**
+     * Show a progress notification
+     */
+    showProgress(message: string, progress?: number, options?: Partial<NotificationOptions>): string;
+    /**
+     * Update progress for an existing notification
+     */
+    updateProgress(id: string, progress: number, message?: string): void;
     /**
      * Core show method
      */
@@ -1223,43 +1898,500 @@ declare class NotificationService {
     private addNotification;
     private generateId;
     private getDefaultIcon;
-    getNotifications(): i0.WritableSignal<NotificationItem[]>;
-    getActiveNotifications(): i0.Signal<NotificationItem[]>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+    getNotifications(): _angular_core.WritableSignal<NotificationItem[]>;
+    getActiveNotifications(): _angular_core.Signal<NotificationItem[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NotificationService>;
 }
 
-declare class CideEleConfirmationModalComponent {
-    private confirmationService;
-    hasActiveConfirmation: i0.Signal<boolean>;
-    currentRequest: i0.WritableSignal<cloud_ide_element.ConfirmationRequest<unknown> | null>;
-    customData: i0.WritableSignal<unknown>;
-    getHeaderClass: i0.Signal<string>;
-    getIconClass: i0.Signal<"success" | "danger" | "warning" | "info">;
-    getConfirmButtonClass: i0.Signal<string>;
+/**
+ * File Manager Interfaces
+ * Based on core_file_manager table schema
+ */
+interface ICoreCyfm {
+    _id?: string;
+    cyfm_name?: string;
+    cyfm_alt_text?: string;
+    cyfm_path?: string;
+    cyfm_size_in_byte?: number;
+    cyfm_type?: string;
+    cyfm_creation_dt?: string;
+    cyfm_id_user?: string;
+    cyfm_permissions?: string[];
+    cyfm_tags?: string[];
+    cyfm_version?: number;
+    cyfm_file_status_sygmt?: string;
+    cyfm_group_id?: string;
+    cyfm_ismultiple?: boolean;
+    cyfm_isactive?: boolean;
+}
+interface ICoreFileManager extends ICoreCyfm {
+    _id: string;
+    cyfm_name: string;
+    cyfm_path: string;
+    cyfm_size_in_byte: number;
+    cyfm_type: string;
+    cyfm_creation_dt: string;
+    cyfm_id_user: string;
+    cyfm_permissions: string[];
+    cyfm_tags: string[];
+    cyfm_version: number;
+    cyfm_file_status_sygmt: string;
+    cyfm_group_id?: string;
+    cyfm_ismultiple?: boolean;
+    cyfm_isactive: boolean;
+}
+interface controllerResponse {
+    success?: boolean;
+    error_code?: string;
+    message?: string;
+    data?: any;
+    code?: string;
+    action?: string;
+    total?: number;
+    pageIndex?: number;
+    pageSize?: number;
+    controls?: {
+        [key: string]: string;
+    };
+}
+type IFileManagerErrorLogger = {
+    [key in keyof MFileManager]: string;
+};
+declare class MFileManager {
+    cyfm_id: string;
+    constructor(init: MFileManager);
+    Validate?(): Partial<IFileManagerErrorLogger>;
+}
+declare class ICoreCyfmSave implements ICoreCyfm {
+    _id?: string;
+    cyfm_name?: string;
+    cyfm_alt_text?: string;
+    cyfm_path?: string;
+    cyfm_size_in_byte?: number;
+    cyfm_type?: string;
+    cyfm_creation_dt?: string;
+    cyfm_id_user?: string;
+    cyfm_permissions?: string[];
+    cyfm_tags?: string[];
+    cyfm_version?: number;
+    cyfm_file_status_sygmt?: string;
+    cyfm_group_id?: string;
+    cyfm_isactive?: boolean;
+    cyfm_ismultiple?: boolean;
+    cyfm_file_base64: string;
+    cyfm_temp_unique_id: string;
+    constructor(init: ICoreCyfmSave);
+}
+declare class CoreFileManagerInsertUpdatePayload {
+    core_file_manager_new: ICoreCyfmSave[];
+    core_file_manager_update: ICoreCyfm[];
+    core_file_manager_delete: ICoreCyfm[];
+    constructor(init: CoreFileManagerInsertUpdatePayload);
+    Validate?(): Partial<IFileManagerErrorLogger>;
+}
+interface fileManagerResponseData extends ICoreCyfm {
+    cyfm_file_base64: string;
+}
+interface fileManagerControllerResponse extends controllerResponse {
+    data?: fileManagerResponseData[];
+}
+interface CoreFileManagerInsertUpdateResponse extends controllerResponse {
+    data?: {
+        core_file_manager: {
+            cyfm_id: string;
+            cyfm_temp_unique_id: string;
+        }[];
+    };
+}
+interface mongooseObjectIdCreateControllerResponse extends controllerResponse {
+    data?: {
+        objectId: string;
+    };
+}
+interface IFileUploadRequest {
+    file: File;
+    altText?: string;
+    tags?: string[];
+    permissions?: string[];
+    userId?: string;
+    groupId?: string;
+    [key: string]: string | number | string[] | File | undefined;
+}
+interface IFileUploadResponse {
+    success: boolean;
+    message: string;
+    data?: ICoreFileManager;
+    error?: string;
+}
+interface IFileListRequest {
+    pageIndex: number;
+    pageSize: number;
+    search?: string;
+    fileType?: string;
+    status?: string;
+    userId?: string;
+    tags?: string[];
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+interface IFileListResponse {
+    success: boolean;
+    message: string;
+    data: ICoreFileManager[];
+    total: number;
+    pageIndex: number;
+    pageSize: number;
+}
+interface IFileDeleteResponse {
+    success: boolean;
+    message: string;
+    data?: string;
+}
+interface IFileUpdateRequest {
+    _id: string;
+    cyfm_name?: string;
+    cyfm_alt_text?: string;
+    cyfm_tags?: string[];
+    cyfm_permissions?: string[];
+    cyfm_file_status_sygmt?: string;
+    cyfm_isactive?: boolean;
+}
+interface IFileUpdateResponse {
+    success: boolean;
+    message: string;
+    data?: ICoreFileManager;
+}
+interface IFileUploadProgress {
+    fileId: string;
+    fileName: string;
+    progress: number;
+    status: 'pending' | 'uploading' | 'completed' | 'error' | 'cancelled';
+    error?: string;
+    uploadedFile?: any;
+}
+interface IFileUploadQueueItem extends IFileUploadProgress {
+    file: File;
+}
+interface IFileFilterOptions {
+    fileTypes: string[];
+    statuses: string[];
+    dateRange?: {
+        start: Date;
+        end: Date;
+    };
+    sizeRange?: {
+        min: number;
+        max: number;
+    };
+    tags: string[];
+}
+interface IFileGroupingOptions {
+    groupBy: 'type' | 'status' | 'date' | 'size' | 'user' | 'none';
+    sortBy: 'name' | 'size' | 'date' | 'type';
+    sortOrder: 'asc' | 'desc';
+}
+
+interface FileUploadOptions {
+    altText?: string;
+    userId?: string;
+    permissions?: string[];
+    tags?: string[];
+    fileStatus?: string;
+    groupId?: string;
+    isMultiple?: boolean;
+    retryAttempts?: number;
+    timeout?: number;
+    [key: string]: string | number | string[] | undefined | boolean;
+}
+interface UploadProgress {
+    loaded: number;
+    total: number;
+    percentage: number;
+    stage: 'reading' | 'uploading' | 'complete' | 'error';
+    groupId?: string;
+}
+interface ServiceState {
+    isUploading: boolean;
+    uploadQueue: string[];
+    activeUploads: Map<string, UploadProgress>;
+    error: string | null;
+}
+declare class CideEleFileManagerService {
+    private readonly http;
+    private readonly destroyRef;
+    private readonly _baseUrl;
+    private readonly _objectIdEndpoint;
+    private readonly _userId;
+    private readonly _isUploading;
+    private readonly _uploadQueue;
+    private readonly _activeUploads;
+    private readonly _fetchedFiles;
+    private readonly _fileIdMapping;
+    private readonly _error;
+    readonly baseUrl: _angular_core.Signal<string>;
+    readonly objectIdEndpoint: _angular_core.Signal<string>;
+    readonly userId: _angular_core.Signal<string>;
+    readonly isUploading: _angular_core.Signal<boolean>;
+    readonly uploadQueue: _angular_core.Signal<string[]>;
+    readonly activeUploads: _angular_core.Signal<Map<string, UploadProgress>>;
+    readonly fetchedFiles: _angular_core.Signal<Map<string, any[]>>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly hasActiveUploads: _angular_core.Signal<boolean>;
+    readonly queueLength: _angular_core.Signal<number>;
+    readonly totalFetchedFiles: _angular_core.Signal<number>;
+    readonly getFileCountByGroup: _angular_core.Signal<Map<string, number>>;
+    readonly serviceState: _angular_core.Signal<{
+        isUploading: boolean;
+        uploadQueue: string[];
+        activeUploads: Map<string, UploadProgress>;
+        fetchedFiles: Map<string, any[]>;
+        error: string | null;
+    }>;
+    constructor();
+    /**
+     * Upload a file with base64 encoding and progress tracking
+     * Angular 20: Enhanced with better error handling, retry logic, and signal-based state
+     * @param file The file to upload
+     * @param options Upload options and additional data
+     * @param progressCallback Optional callback for progress updates
+     * @returns Observable with the upload response
+     */
+    uploadFile(file: File, options?: FileUploadOptions, progressCallback?: (progress: number) => void): Observable<CoreFileManagerInsertUpdateResponse>;
+    /**
+     * Set the base URL for API calls
+     * Angular 20: Using signal-based state management
+     * @param url The base URL for the API
+     */
+    setBaseUrl(url: string): void;
+    /**
+     * Set the user ID for file uploads
+     * Angular 20: Using signal-based state management
+     * @param userId The user ID to associate with uploaded files
+     */
+    setUserId(userId: string): void;
+    /**
+     * Set the object ID generation endpoint
+     * Angular 20: Using signal-based state management
+     * @param endpoint The endpoint for generating object IDs (e.g., '/utility/generateObjectId')
+     */
+    setObjectIdEndpoint(endpoint: string): void;
+    /**
+     * Generate Object ID for group uploads
+     * Calls the backend API to generate a unique ObjectId for grouping multiple files
+     * Uses the configurable object ID endpoint instead of hardcoded path
+     * @returns Observable with the generated ObjectId
+     */
+    generateObjectId(): Observable<mongooseObjectIdCreateControllerResponse>;
+    /**
+     * Angular 20: Helper methods for state management
+     */
+    private generateFileId;
+    private addToUploadQueue;
+    private removeFromUploadQueue;
+    private updateUploadProgress;
+    private removeActiveUpload;
+    /**
+     * Angular 20: Enhanced error handling
+     */
+    private handleError;
+    /**
+     * Get file details by ID
+     * @param payload The file ID to fetch details for
+     * @returns Observable with file details
+     */
+    getFileDetails(payload: MFileManager): Observable<fileManagerControllerResponse>;
+    /**
+     * Get files by group ID and store them in service state
+     * @param groupId The group ID to fetch files for
+     * @returns Observable with files list
+     */
+    getFilesByGroupId(groupId: string): Observable<fileManagerListByGroupIdControllerResponse>;
+    /**
+     * Fetch and store files by group ID in service state
+     * @param groupId The group ID to fetch files for
+     * @returns Observable that completes when files are stored
+     */
+    fetchAndStoreFilesByGroupId(groupId: string): Observable<any[]>;
+    /**
+     * Get fetched files for a specific group ID
+     * @param groupId The group ID to get files for
+     * @returns Array of files for the group
+     */
+    getFetchedFilesByGroupId(groupId: string): any[];
+    /**
+     * Signal to trigger floating uploader visibility
+     */
+    private readonly _showFloatingUploader;
+    private readonly _triggerGroupId;
+    readonly showFloatingUploader: _angular_core.Signal<boolean>;
+    readonly getTriggerGroupId: _angular_core.Signal<string | null>;
+    /**
+     * Trigger floating uploader to show with group ID
+     * This is the ONLY way to pass group ID to floating uploader
+     */
+    triggerFloatingUploaderShow(groupId?: string): void;
+    /**
+     * Get all files (active uploads + fetched files) for a group ID
+     * @param groupId The group ID to get files for
+     * @returns Combined array of active and fetched files
+     */
+    getAllFilesForGroup(groupId: string): Array<{
+        fileId: string;
+        fileName: string;
+        stage: string;
+        percentage?: number;
+    }>;
+    /**
+     * Get file name from file ID (extract from the ID format)
+     */
+    private getFileNameFromId;
+    /**
+     * Angular 20: Service utility methods
+     */
+    clearError(): void;
+    getUploadProgress(fileId: string): UploadProgress | undefined;
+    cancelUpload(fileId: string): void;
+    /**
+     * Clear all completed uploads from active uploads
+     * Called when the floating uploader is closed
+     */
+    clearCompletedUploads(): void;
+    /**
+     * Remove a specific completed upload from active uploads
+     */
+    removeCompletedUpload(fileId: string): void;
+    /**
+     * Optimized method to get file count for a specific group
+     * Uses computed property for better performance
+     */
+    getFileCountForGroup(groupId: string): number;
+    /**
+     * Optimized method to check if group has active uploads
+     */
+    hasActiveUploadsForGroup(groupId: string): boolean;
+    /**
+     * Angular 20: File validation utility
+     */
+    validateFile(file: File, maxSizeMB?: number, allowedTypes?: string[]): {
+        valid: boolean;
+        error?: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFileManagerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideEleFileManagerService>;
+}
+
+declare class CideCoreFileManagerService {
+    private http;
+    private apiUrl;
+    private fileListSubject;
+    fileList$: Observable<ICoreFileManager[]>;
+    constructor(http: HttpClient);
+    /**
+     * Get file list from API
+     */
+    getFileList(body: IFileListRequest): Observable<IFileListResponse>;
+    /**
+     * Get file list using mock data (deprecated - use getFileList instead)
+     */
+    getFileListWithMockData(_body: IFileListRequest): Observable<IFileListResponse>;
+    /**
+     * Get file list from cache (if available)
+     */
+    getFileListFromCache(): ICoreFileManager[];
+    /**
+     * Upload file with progress tracking
+     */
+    uploadFile(request: IFileUploadRequest): Observable<HttpEvent<IFileUploadResponse>>;
+    /**
+     * Upload file with progress tracking (mock version - deprecated)
+     */
+    uploadFileWithMockData(request: IFileUploadRequest): Observable<HttpEvent<IFileUploadResponse>>;
+    /**
+     * Update file metadata
+     */
+    updateFile(request: IFileUpdateRequest): Observable<IFileUpdateResponse>;
+    /**
+     * Delete file
+     */
+    deleteFile(id: string): Observable<IFileDeleteResponse>;
+    /**
+     * Delete multiple files
+     */
+    deleteMultipleFiles(ids: string[]): Observable<{
+        success: boolean;
+        message?: string;
+        data?: unknown;
+    }>;
+    /**
+     * Toggle file active status
+     */
+    toggleFileStatus(id: string): Observable<IFileListResponse>;
+    /**
+     * Get file by ID
+     */
+    getFileById(id: string): Observable<{
+        success: boolean;
+        message: string;
+        data?: ICoreFileManager;
+    }>;
+    /**
+     * Find file by ID
+     */
+    findFileById(id: string, items?: ICoreFileManager[]): ICoreFileManager | null;
+    /**
+     * Get file size in human readable format
+     */
+    getFileSizeDisplay(bytes: number): string;
+    /**
+     * Get file type icon
+     */
+    getFileTypeIcon(fileType: string): string;
+    /**
+     * Refresh file list from server
+     */
+    private refreshFileList;
+    /**
+     * Handle errors
+     */
+    private handleError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideCoreFileManagerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideCoreFileManagerService>;
+}
+
+declare class CideEleConfirmationModalComponent implements OnInit, OnDestroy {
+    private readonly confirmationService;
+    readonly hasActiveConfirmation: _angular_core.Signal<boolean>;
+    readonly currentRequest: _angular_core.WritableSignal<cloud_ide_element.ConfirmationRequest<unknown> | null>;
+    readonly customData: _angular_core.WritableSignal<unknown>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    readonly getHeaderClass: _angular_core.Signal<string>;
+    readonly getIconClass: _angular_core.Signal<string>;
+    readonly getConfirmButtonClass: _angular_core.Signal<string>;
     onBackdropClick(event: Event): void;
     onCancel(): void;
     onConfirm(): void;
     updateCustomData(data: unknown): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleConfirmationModalComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleConfirmationModalComponent, "cide-ele-confirmation-modal", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleConfirmationModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleConfirmationModalComponent, "cide-ele-confirmation-modal", never, {}, {}, never, never, true, never>;
 }
 
 declare class CideEleToastNotificationComponent {
     private notificationService;
-    activeNotifications: i0.Signal<NotificationItem[]>;
+    activeNotifications: _angular_core.Signal<NotificationItem[]>;
     getToastClass(notification: NotificationItem): string;
     getIconClass(type: string): string;
     removeNotification(id: string): void;
     executeUndo(id: string): void;
     trackByNotification(index: number, notification: NotificationItem): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleToastNotificationComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleToastNotificationComponent, "cide-ele-toast-notification", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleToastNotificationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleToastNotificationComponent, "cide-ele-toast-notification", never, {}, {}, never, never, true, never>;
 }
 
 declare class CideEleGlobalNotificationsComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleGlobalNotificationsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleGlobalNotificationsComponent, "cide-ele-global-notifications", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleGlobalNotificationsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleGlobalNotificationsComponent, "cide-ele-global-notifications", never, {}, {}, never, never, true, never>;
 }
 
 interface JsonEditorConfig {
@@ -1294,24 +2426,24 @@ declare class CideEleJsonEditorComponent implements OnInit, ControlValueAccessor
     label?: string;
     helperText?: string;
     required: boolean;
-    disabled: i0.WritableSignal<boolean>;
+    disabled: _angular_core.WritableSignal<boolean>;
     showCharacterCount: boolean;
     config: JsonEditorConfig;
-    configSignal: i0.WritableSignal<JsonEditorConfig>;
+    configSignal: _angular_core.WritableSignal<JsonEditorConfig>;
     valueChange: EventEmitter<string>;
     objectChange: EventEmitter<object | null>;
     errorsChange: EventEmitter<JsonEditorError[]>;
     validChange: EventEmitter<boolean>;
-    jsonTextarea: i0.Signal<ElementRef<HTMLTextAreaElement>>;
+    jsonTextarea: _angular_core.Signal<ElementRef<HTMLTextAreaElement>>;
     private destroyRef;
-    jsonString: i0.WritableSignal<string>;
-    jsonObject: i0.WritableSignal<object | null>;
-    errors: i0.WritableSignal<JsonEditorError[]>;
+    jsonString: _angular_core.WritableSignal<string>;
+    jsonObject: _angular_core.WritableSignal<object | null>;
+    errors: _angular_core.WritableSignal<JsonEditorError[]>;
     editorId: string;
-    hasErrors: i0.Signal<boolean>;
-    isValid: i0.Signal<boolean>;
-    lineNumbers: i0.Signal<number[]>;
-    containerClass: i0.Signal<string>;
+    hasErrors: _angular_core.Signal<boolean>;
+    isValid: _angular_core.Signal<boolean>;
+    lineNumbers: _angular_core.Signal<number[]>;
+    containerClass: _angular_core.Signal<string>;
     private defaultConfig;
     ngOnInit(): void;
     /**
@@ -1372,9 +2504,376 @@ declare class CideEleJsonEditorComponent implements OnInit, ControlValueAccessor
     setDisabledState(isDisabled: boolean): void;
     private onChange;
     private onTouched;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleJsonEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleJsonEditorComponent, "cide-ele-json-editor", never, { "label": { "alias": "label"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showCharacterCount": { "alias": "showCharacterCount"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "valueChange": "valueChange"; "objectChange": "objectChange"; "errorsChange": "errorsChange"; "validChange": "validChange"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleJsonEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleJsonEditorComponent, "cide-ele-json-editor", never, { "label": { "alias": "label"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showCharacterCount": { "alias": "showCharacterCount"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "valueChange": "valueChange"; "objectChange": "objectChange"; "errorsChange": "errorsChange"; "validChange": "validChange"; }, never, never, true, never>;
+}
+
+interface FloatingContainerConfig {
+    id: string;
+    title: string;
+    icon?: string;
+    headerColor?: string;
+    width?: string;
+    height?: string;
+    minWidth?: string;
+    minHeight?: string;
+    maxWidth?: string;
+    maxHeight?: string;
+    resizable?: boolean;
+    draggable?: boolean;
+    closable?: boolean;
+    minimizable?: boolean;
+    maximizable?: boolean;
+    isMinimized?: boolean;
+    isMaximized?: boolean;
+    componentId?: string;
+    componentConfig?: {
+        inputs?: {
+            [key: string]: any;
+        };
+        outputs?: {
+            [key: string]: (event: any) => void;
+        };
+    };
+}
+declare class CideEleFloatingContainerComponent implements AfterViewInit, OnDestroy {
+    config: _angular_core.WritableSignal<FloatingContainerConfig>;
+    isMinimized: Signal<boolean>;
+    isMaximized: Signal<boolean>;
+    isVisible: Signal<boolean>;
+    closeEvent: EventEmitter<string>;
+    minimizeEvent: EventEmitter<string>;
+    maximizeEvent: EventEmitter<string>;
+    clickEvent: EventEmitter<string>;
+    containerRef: ElementRef<HTMLDivElement>;
+    position: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    }>;
+    isDragging: _angular_core.WritableSignal<boolean>;
+    isResizing: _angular_core.WritableSignal<boolean>;
+    computedConfig: Signal<FloatingContainerConfig>;
+    private dragStart;
+    private resizeStart;
+    private originalPosition;
+    private originalSize;
+    private savedPosition;
+    savedHeight: string;
+    ngAfterViewInit(): void;
+    constructor();
+    ngOnDestroy(): void;
+    centerContainer(): void;
+    startDrag(event: MouseEvent): void;
+    onDragMove(event: MouseEvent): void;
+    onDragEnd(): void;
+    startResize(event: MouseEvent): void;
+    onResizeMove(event: MouseEvent): void;
+    onResizeEnd(): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onHeaderClick(event: MouseEvent): void;
+    minimize(): void;
+    bringToFront(): void;
+    toggleMaximize(): void;
+    close(): void;
+    getHeaderBackground(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFloatingContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleFloatingContainerComponent, "cide-ele-floating-container", never, { "config": { "alias": "config"; "required": false; }; "isMinimized": { "alias": "isMinimized"; "required": false; }; "isMaximized": { "alias": "isMaximized"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, { "closeEvent": "closeEvent"; "minimizeEvent": "minimizeEvent"; "maximizeEvent": "maximizeEvent"; "clickEvent": "clickEvent"; }, never, ["*"], true, never>;
+}
+
+interface FloatingComponentConfig {
+    componentId: string;
+    componentType?: Type<any>;
+    inputs?: {
+        [key: string]: any;
+    };
+    outputs?: {
+        [key: string]: (event: any) => void;
+    };
+}
+interface FloatingContainerInstance {
+    id: string;
+    config: FloatingContainerConfig;
+    isVisible: boolean;
+    isMinimized: boolean;
+    isMaximized: boolean;
+    zIndex: number;
+    instanceId: string;
+    componentType: string;
+    createdAt: Date;
+    lastAccessed: Date;
+}
+declare class CideEleFloatingContainerService {
+    private injector;
+    private containers;
+    private nextZIndex;
+    private instanceCounter;
+    private componentRegistry;
+    private activeComponents;
+    constructor(injector: Injector);
+    visibleContainers: _angular_core.Signal<FloatingContainerInstance[]>;
+    minimizedContainers: _angular_core.Signal<FloatingContainerInstance[]>;
+    maximizedContainers: _angular_core.Signal<FloatingContainerInstance[]>;
+    show(config: FloatingContainerConfig): string;
+    hide(containerId: string): void;
+    /**
+     * Get the maximum z-index among all visible containers
+     */
+    private getMaxZIndex;
+    /**
+     * Bring a container to the front (highest z-index)
+     */
+    bringToFront(containerId: string): void;
+    minimize(containerId: string): void;
+    maximize(containerId: string): void;
+    getContainer(containerId: string): FloatingContainerInstance | undefined;
+    isVisible(containerId: string): boolean;
+    isMinimized(containerId: string): boolean;
+    isMaximized(containerId: string): boolean;
+    hideAll(): void;
+    minimizeAll(): void;
+    private generateId;
+    private generateInstanceId;
+    getInstancesByComponentType(componentType: string): FloatingContainerInstance[];
+    getActiveInstancesByComponentType(componentType: string): FloatingContainerInstance[];
+    getInstanceCount(componentType: string): number;
+    getActiveInstanceCount(componentType: string): number;
+    closeAllInstancesOfType(componentType: string): void;
+    minimizeAllInstancesOfType(componentType: string): void;
+    bringAllInstancesToFront(componentType: string): void;
+    getInstanceByInstanceId(instanceId: string): FloatingContainerInstance | undefined;
+    updateLastAccessed(containerId: string): void;
+    /**
+     * Register a component for dynamic loading
+     */
+    registerComponent(componentId: string, componentType: Type<any>): void;
+    /**
+     * Unregister a component
+     */
+    unregisterComponent(componentId: string): void;
+    /**
+     * Get registered component type
+     */
+    getComponentType(componentId: string): Type<any> | undefined;
+    /**
+     * Check if component is registered
+     */
+    isComponentRegistered(componentId: string): boolean;
+    /**
+     * Get registered component IDs
+     */
+    getRegisteredComponentIds(): string[];
+    /**
+     * Create and load component dynamically
+     */
+    loadComponent(componentId: string, viewContainer: ViewContainerRef, config?: FloatingComponentConfig): ComponentRef<any> | null;
+    /**
+     * Destroy component
+     */
+    destroyComponent(componentId: string): void;
+    /**
+     * Get active component count
+     */
+    getActiveComponentCount(): number;
+    /**
+     * Clear all active components
+     */
+    clearActiveComponents(): void;
+    /**
+     * Get config signal for a container
+     */
+    getConfigSignal(config: FloatingContainerConfig): _angular_core.WritableSignal<FloatingContainerConfig>;
+    /**
+     * Get minimized signal for a container
+     */
+    getMinimizedSignal(containerId: string): _angular_core.Signal<boolean>;
+    /**
+     * Get maximized signal for a container
+     */
+    getMaximizedSignal(containerId: string): _angular_core.Signal<boolean>;
+    getZIndexSignal(containerId: string): _angular_core.Signal<number>;
+    /**
+     * Set z-index for a specific container
+     */
+    setZIndex(containerId: string, zIndex: number): void;
+    /**
+     * Get visible signal for a container
+     */
+    getVisibleSignal(containerId: string): _angular_core.Signal<boolean>;
+    /**
+     * Get component config for dynamic loading
+     */
+    getComponentConfig(config: FloatingContainerConfig): {
+        componentId: string;
+        inputs: {
+            [key: string]: any;
+        } | undefined;
+        outputs: {
+            [key: string]: (event: any) => void;
+        } | undefined;
+    } | undefined;
+    /**
+     * Handle container close event
+     */
+    onClose(containerId: string): void;
+    /**
+     * Handle container minimize event
+     */
+    onMinimize(containerId: string): void;
+    /**
+     * Handle container maximize event
+     */
+    onMaximize(containerId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFloatingContainerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideEleFloatingContainerService>;
+}
+
+declare class CideEleFloatingContainerManagerComponent {
+    containerService: CideEleFloatingContainerService;
+    visibleContainers: _angular_core.Signal<cloud_ide_element.FloatingContainerInstance[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFloatingContainerManagerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CideEleFloatingContainerManagerComponent, "cide-ele-floating-container-manager", never, {}, {}, never, never, true, never>;
+}
+
+declare class CideEleFloatingFeaturesService {
+    private containerService;
+    private shortcutsService;
+    constructor();
+    showFeature(featureId: string, config: FloatingContainerConfig): string;
+    showComponent(containerId: string, componentId: string, title: string, componentType?: any, config?: Partial<FloatingContainerConfig>): string;
+    /**
+     * Generic method for showing any component with input data
+     *
+     * @example
+     * // Pass data to a component
+     * this.floatingFeaturesService.showComponentWithData(
+     *   'my-component-container',
+     *   'my-component',
+     *   'My Component Title',
+     *   {
+     *     data: {
+     *       userId: '123',
+     *       userName: 'John Doe',
+     *       settings: { theme: 'dark' }
+     *     },
+     *     outputs: {
+     *       onSave: (data) => console.log('Save event:', data),
+     *       onCancel: () => console.log('Cancel clicked')
+     *     }
+     *   },
+     *   {
+     *     width: '600px',
+     *     height: '400px',
+     *     icon: 'settings'
+     *   }
+     * );
+     */
+    showComponentWithData(containerId: string, componentId: string, title: string, componentData: {
+        data: {
+            [key: string]: any;
+        };
+        outputs?: {
+            [key: string]: (event: any) => void;
+        };
+    }, containerConfig?: Partial<FloatingContainerConfig>): string;
+    showMultipleInstances(componentId: string, titlePrefix: string, count: number, config?: Partial<FloatingContainerConfig>): string[];
+    getInstancesOfType(componentType: string): cloud_ide_element.FloatingContainerInstance[];
+    getActiveInstancesOfType(componentType: string): cloud_ide_element.FloatingContainerInstance[];
+    closeAllInstancesOfType(componentType: string): void;
+    minimizeAllInstancesOfType(componentType: string): void;
+    getInstanceCount(componentType: string): number;
+    getActiveInstanceCount(componentType: string): number;
+    registerComponent(componentId: string, componentType: any): void;
+    unregisterComponent(componentId: string): void;
+    hideFeature(featureId: string): void;
+    bringToFront(featureId: string): void;
+    minimize(featureId: string): void;
+    maximize(featureId: string): void;
+    isVisible(featureId: string): boolean;
+    hideAll(): void;
+    minimizeAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFloatingFeaturesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CideEleFloatingFeaturesService>;
+}
+
+declare class CideEleFloatingContainerDynamicDirective implements OnInit, OnDestroy {
+    private viewContainer;
+    private containerService;
+    componentId: string;
+    componentConfig?: FloatingComponentConfig;
+    isVisible: boolean;
+    private componentRef;
+    constructor(viewContainer: ViewContainerRef, containerService: CideEleFloatingContainerService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    private loadComponent;
+    private destroyComponent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CideEleFloatingContainerDynamicDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CideEleFloatingContainerDynamicDirective, "[cideEleFloatingDynamic]", never, { "componentId": { "alias": "componentId"; "required": false; }; "componentConfig": { "alias": "componentConfig"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FloatingContainerShortcutsService {
+    private keyboardShortcutService;
+    private containerService;
+    private readonly Z_INDEX_LAYERS;
+    constructor();
+    /**
+     * Register default floating container shortcuts
+     */
+    private registerDefaultShortcuts;
+    /**
+     * Register number shortcuts (Alt + 1, Alt + 2, etc.)
+     */
+    private registerNumberShortcuts;
+    /**
+     * Open new floating container
+     */
+    private openNewContainer;
+    /**
+     * Focus previous container
+     */
+    private focusPreviousContainer;
+    /**
+     * Hide all containers
+     */
+    private hideAllContainers;
+    /**
+     * Show all containers
+     */
+    private showAllContainers;
+    /**
+     * Minimize all containers
+     */
+    private minimizeAllContainers;
+    /**
+     * Focus container by index
+     */
+    private focusContainerByIndex;
+    /**
+     * Open file uploader
+     */
+    private openFileUploader;
+    /**
+     * Open entity rights sharing
+     */
+    private openEntityRightsSharing;
+    /**
+     * Duplicate current container
+     */
+    private duplicateCurrentContainer;
+    /**
+     * Close current container
+     */
+    private closeCurrentContainer;
+    /**
+     * Toggle container visibility
+     */
+    private toggleContainerVisibility;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingContainerShortcutsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FloatingContainerShortcutsService>;
 }
 
-export { CideEleButtonComponent, CideEleConfirmationModalComponent, CideEleDataGridComponent, CideEleDropdownComponent, CideEleFileInputComponent, CideEleGlobalNotificationsComponent, CideEleJsonEditorComponent, CideEleResizerDirective, CideEleSkeletonLoaderComponent, CideEleTabComponent, CideEleToastNotificationComponent, CideElementsService, CideIconComponent, CideInputComponent, CideSelectComponent, CideSelectOptionComponent, CideSpinnerComponent, CideTextareaComponent, ConfirmationService, DEFAULT_GRID_CONFIG, DropdownManagerService, NotificationService, TooltipDirective };
-export type { ButtonElevation, ButtonShape, ButtonSize, ButtonType, ButtonVariant, CideEleResizerDirection, CideEleResizerDirectionTo, ColumnType, ColumnWidth, ConfirmationOptions, ConfirmationRequest, DropdownConfig, DropdownInstance, DropdownItem, DropdownPosition, ErrorValidationStatus, GridAction, GridColumn, GridConfiguration, GridCustomFormatter, GridCustomRenderer, GridDragDropConfig, GridEvent, GridEventHandler, GridExportConfig, GridFormatter, GridLoadingConfig, GridPaginationConfig, GridScrollConfig, GridSearchConfig, GridState, GridTreeConfig, JsonEditorConfig, JsonEditorError, NotificationItem, NotificationOptions, Renderer, SelectOption, StatusConfig, StringRenderer, TabItem, TemplateContext, TemplateRenderer, TextAlign, TooltipPlacement, TooltipType, ValidationStatus };
+export { CideCoreFileManagerService, CideEleButtonComponent, CideEleConfirmationModalComponent, CideEleDataGridComponent, CideEleDropdownComponent, CideEleFileImageDirective, CideEleFileInputComponent, CideEleFileManagerService, CideEleFloatingContainerComponent, CideEleFloatingContainerDynamicDirective, CideEleFloatingContainerManagerComponent, CideEleFloatingContainerService, CideEleFloatingFeaturesService, CideEleFloatingFileUploaderComponent, CideEleFloatingFileUploaderService, CideEleGlobalNotificationsComponent, CideEleJsonEditorComponent, CideEleResizerDirective, CideEleSkeletonLoaderComponent, CideEleTabComponent, CideEleToastNotificationComponent, CideElementsService, CideIconComponent, CideInputComponent, CideSelectComponent, CideSelectOptionComponent, CideSpinnerComponent, CideTextareaComponent, ConfirmationService, CoreFileManagerInsertUpdatePayload, DEFAULT_GRID_CONFIG, DropdownManagerService, FloatingContainerShortcutsService, ICoreCyfmSave, KeyboardShortcutService, MFileManager, NotificationService, TooltipDirective };
+export type { ButtonElevation, ButtonShape, ButtonSize, ButtonType, ButtonVariant, CideEleResizerDirection, CideEleResizerDirectionTo, ColumnType, ColumnWidth, ConfirmationOptions, ConfirmationRequest, CoreFileManagerInsertUpdateResponse, DropdownConfig, DropdownInstance, DropdownItem, DropdownPosition, ErrorValidationStatus, FileUploadData, FileUploadOptions, FileUploaderData, FloatingComponentConfig, FloatingContainerConfig, FloatingContainerInstance, FloatingFileUploaderData, GridAction, GridColumn, GridConfiguration, GridCustomFormatter, GridCustomRenderer, GridDragDropConfig, GridEvent, GridEventHandler, GridExportConfig, GridFormatter, GridLoadingConfig, GridPaginationConfig, GridScrollConfig, GridSearchConfig, GridState, GridTreeConfig, ICoreCyfm, ICoreFileManager, IFileDeleteResponse, IFileFilterOptions, IFileGroupingOptions, IFileListRequest, IFileListResponse, IFileManagerErrorLogger, IFileUpdateRequest, IFileUpdateResponse, IFileUploadProgress, IFileUploadQueueItem, IFileUploadRequest, IFileUploadResponse, JsonEditorConfig, JsonEditorError, KeyboardShortcut, NotificationItem, NotificationOptions, SelectOption, SelectOptionObject, ServiceState, ShortcutOverride, StatusConfig, TabItem, TemplateContext, TemplateRenderer, TextAlign, TooltipPlacement, TooltipType, UploadProgress, ValidationStatus, controllerResponse, fileManagerControllerResponse, fileManagerResponseData, mongooseObjectIdCreateControllerResponse };