cloud-ide-element 1.0.4 → 1.0.5

package/index.d.ts

@@ -1,5 +1,1364 @@
+import * as i0 from '@angular/core';
+import { PipeTransform, OnChanges, OnInit, EventEmitter, SimpleChanges, OnDestroy, Renderer2, ElementRef, AfterContentInit, QueryList, TemplateRef } 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 { Router, NavigationExtras } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import * as cloud_ide_element from 'cloud-ide-element';
+
+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>;
+}
+
+/** @description type to register error related to control */
+type ErrorValidationStatus = {
+    maxlength?: string;
+    minlength?: string;
+    required?: string;
+};
+type ValidationStatus = {
+    validation: ErrorValidationStatus;
+    status: boolean;
+};
+declare class CideInputComponent implements ControlValueAccessor, Validator, OnChanges, OnInit {
+    capitalizePipe: CapitalizePipe;
+    private elementService;
+    constructor();
+    /**
+     * @description to se the visual of control like solid control offerd by material design or outline with a border
+     * @options solid | outline | standard
+     */
+    fill: elementStyleType;
+    /** @description Lable of control (Title), Like Name, Email */
+    label: string;
+    /** @description to hide and show label */
+    labelHide: boolean;
+    /** @description is control Editable or Disabled */
+    disabled: boolean;
+    /** @description Is Clear Input Cross button is visible or not */
+    clearInput: boolean;
+    /** @description Position of Label 'floating' | 'fixed' */
+    labelPlacement: labelPlacementType;
+    /** @description Lable direction from start of contrl or end of control */
+    labelDir: labelDirType;
+    /** @description Place holder for control to display if there is no value */
+    placeholder: string;
+    /** @description it is to set leading icon, at the start of control  */
+    leadingIcon: string;
+    /** @description it is to set trailing icon, at the end of control, for password type control eye is the trailing icon  */
+    trailingIcon: string;
+    /** @description to display below the control for suggestion, if there is any error then error will bw the first to shoe in place of help text */
+    helperText: string;
+    /** @description default true to collapse when there is no help text or error text, if false then element area in DOM will be reserved never detroy  */
+    helperTextCollapse: boolean;
+    /** @description show and hide helper text its forecfull */
+    hideHelperAndErrorText: boolean;
+    /** @description if found any error in control the error thext will be used to display error message, if there is help text still error text is having higher priority then helptext */
+    errorText: string;
+    /** @description maxlength for control */
+    maxlength: number;
+    /** @description minlength for control */
+    minlength: number;
+    /** @description is control is required or not input type is true | false */
+    required: boolean;
+    /** @description Auto capatalization for the value and applicable to word or to complete sentance */
+    autocapitalize: autocapitalizeType;
+    /** @description auto complete type to help reader what is the type of value */
+    autocomplete: autocompleteType;
+    /** @description type of control */
+    type: controlType;
+    /** @description width of control, default width is 100% */
+    width: string;
+    /** @description uniq id of control, used to differenciat the value also prevent value should not effect another values */
+    id: string;
+    /** @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
+     * Holds the size of the component like Small, Extra small, Large
+     * by Default it takes small size
+     * or the size set by the project setup service
+     * or it will beset for individual component
+     *
+     * Size Appled
+     * Component level then setup service then finally default md
+     *  Options: "2xs" | ""xs" | "sm" | "md" | "lg" | "xl" | "xxl"
+     */
+    size: themeSize;
+    /** @description to set return value using one way binding like: (ngModelChanges) or by two way binding [(ngModel)] */
+    ngModelChange: EventEmitter<inputType>;
+    /** @description is vale need to read from ngModel or from value(need to implement), it is detected and maild fals on value chnages */
+    isNgModel: boolean;
+    /** @description this is to set control value is valid or not, set by us inside validate callbck method called by angular  */
+    isValid: boolean;
+    /** @description when control is touched then the will maid true by the us to check it is touched or not, when we will set this true we will call the onTouched callback method of angualr to inform angular that somthis is changed and control is touched */
+    isTouched: boolean;
+    /** @description we will take type of control in type but is may be not exactly which input's type so we need to get type and set actule type to our input, also when type is set password but in calse view in textt then inuut type need to change to text */
+    typeInternal: controlType;
+    /** @description if traling is set the it is assigned by it, but some case tarling icon not as it is set need tro be changed at runtime, like password visibility hide and show */
+    trailingIconInternal: string;
+    isTrailingIconAllwedClick: boolean;
+    idRandom: string;
+    /**
+     * @description Function to call when the HTML Chnage to tell Angular somthing is changed.
+     * @field value : inputType
+     */
+    private onChange;
+    /** @description Function to call when the input is touched (clciked) to tell Angular somthing is changed. */
+    onTouched: () => void;
+    /** @description Function to call when the input is need to Validate to tell Angular somthing is changed (in case of some input dipendent validation). */
+    onValidate: () => void;
+    /**
+     * @description
+     * Method that performs synchronous validation against the provided control.
+     * Exicuted by Angular
+     *
+     * @param control The control to validate against.
+     *
+     * @returns A map of validation errors if validation fails,
+     * otherwise null.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    /**
+     * @description
+     * Registers a callback function to call when the validator inputs change.
+     * Exicuted by Angular
+     *
+     * @param fn The callback function
+     */
+    registerOnValidatorChange?(fn: () => void): void;
+    /** @description when form control change from model side this method is implemented  */
+    writeValue(value: inputType): void;
+    /** @description Allows Angular to register a function to call when the model changes. */
+    registerOnChange(fn: (value: inputType) => void): void;
+    /** @description Allows Angular to register a function to call when the input has been touched. */
+    registerOnTouched(fn: () => void): void;
+    /** @description Detect wether input propertires canged or not */
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    /** @description custom method run when HTML changes, we call method registerd by angular to detect change */
+    upDateValue(value: {
+        target: {
+            value: inputType;
+        };
+    } | Event): void;
+    /**
+     * @description method applicable in case of control type checkbox
+     *
+     * @param value boolean | string
+     */
+    updateValueCheckBox(value: string | boolean): void;
+    /** @description clear the value */
+    ClearInputValue(): void;
+    /** @description when HTML is focuesd */
+    focusControl(): void;
+    /** @description If control value need to be processed, like UPPERCASE */
+    processValue(value: inputType, type: controlType): inputType;
+    /** @description for capitalization */
+    autoCapitalizeByOption(value: inputType, type: controlType): inputType;
+    /** @description It is used to return the value is valid or not */
+    isValidValueAndType(value: inputType, type: controlType): boolean;
+    /** @description to check control is valid or not */
+    isControlValid(value: inputType): ValidationStatus;
+    /** @description Allows Angular to disable the input. */
+    setDisabledState(isDisabled: boolean): void;
+    /** @description Method for trailing Icon Click */
+    trailingIconClick(): void;
+    /**
+     * Method to generate Random String
+     * @param setupPrarameter { lenght: number, prefix: string }
+     * default lenght is 10, prefox is ""
+     * @returns string
+     */
+    randomString(setupPrarameter?: {
+        lenght: number;
+        prefix: string;
+    }): string;
+    getControlData(): Promise<void>;
+    /**
+     * @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>;
+}
+
+type ButtonVariant = 'primary' | 'secondary' | 'outline' | 'text' | 'link' | 'success' | 'danger' | 'warning' | 'info' | 'ghost';
+type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type ButtonType = 'button' | 'submit' | 'reset';
+type ButtonShape = 'default' | 'rounded' | 'pill' | 'square';
+type ButtonElevation = 'none' | 'low' | 'medium' | 'high';
 /**
- * Generated bundle index. Do not edit.
+ * Advanced Angular button component that provides a comprehensive button implementation
+ * with loading state, styling variants, animations, tooltips, and other features.
+ *
+ * This component uses proper Angular templating to avoid hydration issues (NG0500).
  */
-/// <amd-module name="cloud-ide-element" />
-export * from './public-api';
+declare class CideEleButtonComponent implements OnInit, OnChanges, OnDestroy {
+    private elementService;
+    private router;
+    private renderer;
+    private elementRef;
+    private destroy$;
+    private clickCount;
+    private clickDebouncer$;
+    constructor(elementService: CideElementsService, router: Router, renderer: Renderer2, elementRef: ElementRef);
+    /**
+     * @description Label of button like Submit, Update, Add, etc.
+     * Note: it is only used in case you did not set label between tags (via ng-content)
+     */
+    label: string;
+    /** @description Button style variant */
+    variant: ButtonVariant;
+    /** @description Button size */
+    size: ButtonSize;
+    /** @description Button HTML type attribute */
+    type: ButtonType;
+    /** @description Button shape */
+    shape: ButtonShape;
+    /** @description Button shadow elevation */
+    elevation: ButtonElevation;
+    /** @description Button disabled state */
+    disabled: boolean | null;
+    /** @description Unique ID of control, used to differentiate elements */
+    id: string;
+    /** @description Enables loading state with spinner */
+    loading: boolean;
+    /** @description Makes button take full width of container */
+    fullWidth: boolean;
+    /** @description Icon to display on the left side of the button */
+    leftIcon: string;
+    /** @description Icon to display on the right side of the button */
+    rightIcon: string;
+    /** @description Additional CSS classes to apply */
+    customClass: string;
+    /** @description Tooltip text to display on hover */
+    tooltip: string;
+    /** @description Aria label for accessibility */
+    ariaLabel: string;
+    /** @description Test ID for automated testing */
+    testId: string;
+    /** @description Route to navigate to when clicked (for link buttons) */
+    routerLink: string | unknown[];
+    /** @description Router navigation extras */
+    routerExtras: NavigationExtras;
+    /** @description Prevent multiple rapid clicks (debounce) */
+    preventDoubleClick: boolean;
+    /** @description Animation on click */
+    animated: boolean;
+    /**
+     * @description Click event of button
+     */
+    btnClick: EventEmitter<Event>;
+    /**
+     * @description Double click event
+     */
+    doubleClick: EventEmitter<Event>;
+    onClick(event: Event): void;
+    private handleClick;
+    private addClickAnimation;
+    ngOnInit(): void;
+    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>;
+}
+
+declare class CideSpinnerComponent {
+    /**
+     * @description
+     * Holds the size of the component like Small, Extra small, Large
+     * by Default it takes small size
+     * or the size set by the project setup service
+     * or it will beset for individual component
+     *
+     * Size Appled
+     * Component level then setup service then finally default md
+     *  Options: "xs" | "sm" | "md" | "lg" | "xl" | "xxl"
+     */
+    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>;
+}
+
+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>;
+}
+
+interface SelectOption {
+    value: string | number;
+    label: string;
+    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>;
+}
+declare class CideSelectComponent implements ControlValueAccessor, Validator, OnInit, OnChanges, AfterContentInit, OnDestroy {
+    private elementRef;
+    optionComponents: QueryList<CideSelectOptionComponent>;
+    searchInputRef: ElementRef<HTMLInputElement>;
+    label: string;
+    labelHide: boolean;
+    placeholder: string;
+    helperText: string;
+    errorText: string;
+    required: boolean;
+    disabled: boolean;
+    id: string;
+    ngModel: string | number;
+    size: themeSize;
+    fill: elementStyleType;
+    labelPlacement: labelPlacementType;
+    labelDir: labelDirType;
+    leadingIcon: string;
+    trailingIcon: string;
+    clearInput: boolean;
+    options: SelectOption[];
+    multiple: boolean;
+    searchable: boolean;
+    showSearchInput: boolean;
+    loading: boolean;
+    ngModelChange: EventEmitter<any>;
+    selectionChange: EventEmitter<SelectOption>;
+    searchChange: EventEmitter<selectSearchType>;
+    isOpen: boolean;
+    isTouched: boolean;
+    isValid: boolean;
+    searchTerm: string;
+    filteredOptions: SelectOption[];
+    dropdownPosition: 'bottom' | 'top';
+    private isDropdownInteraction;
+    private debugId;
+    private timeoutIds;
+    private interactionCount;
+    private maxInteractionCount;
+    constructor(elementRef: ElementRef);
+    onChange: (value: string | number) => void;
+    onTouched: () => void;
+    onValidate: () => void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: string | number): void;
+    registerOnChange(fn: (value: string | number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    validateValue(value: string | number): ValidationErrors | null;
+    toggleDropdown(): void;
+    ngOnDestroy(): void;
+    private onWindowResize;
+    private calculateDropdownPosition;
+    selectOption(option: SelectOption): void;
+    onBlur(): void;
+    focusControl(): void;
+    clearSelection(): void;
+    getSelectedOptionLabel(): string;
+    filterOptions(): void;
+    onSearchInput(event: Event): void;
+    onDropdownMouseDown(): void;
+    onDropdownMouseUp(): void;
+    isOptionSelected(option: SelectOption): boolean;
+    trackByValue(index: number, option: SelectOption): 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>;
+}
+
+interface TabItem {
+    id: string;
+    label: string;
+    disabled?: boolean;
+    icon?: string;
+    badge?: string | number;
+}
+declare class CideEleTabComponent implements OnInit {
+    tabs: TabItem[];
+    activeTabId?: string;
+    size: 'sm' | 'md' | 'lg';
+    variant: 'default' | 'pills' | 'underline';
+    fullWidth: boolean;
+    disabled: boolean;
+    tabChange: EventEmitter<TabItem>;
+    activeTab: i0.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>;
+}
+
+declare class CideEleFileInputComponent implements ControlValueAccessor {
+    label: string;
+    accept: string;
+    multiple: boolean;
+    disabled: boolean;
+    helperText: string;
+    errorText: string;
+    id: string;
+    fileChange: EventEmitter<FileList | null>;
+    files: FileList | null;
+    fileNames: string[];
+    private onChange;
+    private onTouched;
+    writeValue(files: FileList | null): void;
+    registerOnChange(fn: (files: FileList | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFileSelected(event: Event): void;
+    clearFiles(): void;
+    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; }; }, { "fileChange": "fileChange"; }, never, never, true, never>;
+}
+
+declare class CideTextareaComponent implements ControlValueAccessor, Validator, OnInit, OnChanges {
+    label: string;
+    labelHide: boolean;
+    placeholder: string;
+    helperText: string;
+    errorText: string;
+    required: boolean;
+    disabled: boolean;
+    minlength: number;
+    maxlength: number;
+    rows: number | string;
+    id: string;
+    ngModel: string;
+    size: themeSize;
+    fill: elementStyleType;
+    labelPlacement: labelPlacementType;
+    labelDir: labelDirType;
+    leadingIcon: string;
+    trailingIcon: string;
+    clearInput: boolean;
+    trailingIconInternal: string;
+    isTrailingIconAllwedClick: boolean;
+    ngModelChange: EventEmitter<string>;
+    isTouched: boolean;
+    isValid: boolean;
+    onChange: (value: string) => void;
+    onTouched: () => void;
+    onValidate: () => void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    validateValue(value: string): ValidationErrors | null;
+    onInput(event: Event): void;
+    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>;
+}
+
+declare class CideElementsService {
+    cide_element_data: {
+        [key: string]: ICoreSype;
+    };
+    is_cide_element_data_updated: BehaviorSubject<boolean>;
+    getElementData(body: GetElementDataRequest): Promise<ICoreSype>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideElementsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CideElementsService>;
+}
+
+type CideEleResizerDirection = 'horizontal' | 'vertical';
+type CideEleResizerDirectionTo = "right-to-left" | "left-to-right" | "";
+declare class CideEleResizerDirective implements OnInit {
+    private el;
+    private renderer;
+    direction: CideEleResizerDirection;
+    to: CideEleResizerDirectionTo;
+    prevElementSelector: string;
+    nextElementSelector: string;
+    parentElementSelector: string;
+    minPrevSize: number;
+    minNextSize: number;
+    usePercentage: boolean;
+    resizeStart: EventEmitter<void>;
+    resizing: EventEmitter<{
+        prevSize: number;
+        nextSize: number;
+    }>;
+    resizeEnd: EventEmitter<{
+        prevSize: number;
+        nextSize: number;
+    }>;
+    private isResizing;
+    private startPosition;
+    private prevElement;
+    private nextElement;
+    private prevSize;
+    private nextSize;
+    private containerSize;
+    private startPrevSize;
+    private startNextSize;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    onMouseDown(event: MouseEvent): void;
+    private onMouseMove;
+    private onMouseUp;
+    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>;
+}
+
+type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+type TooltipType = 'default' | 'success' | 'warning' | 'error' | 'info' | 'light' | 'dark';
+declare class TooltipDirective implements OnInit, OnDestroy {
+    private el;
+    private renderer;
+    cideEleTooltip: string;
+    tooltipColor: string;
+    tooltipBg: string;
+    tooltipPlacement: TooltipPlacement;
+    tooltipType: TooltipType;
+    tooltipDelay: number;
+    tooltipDir: TooltipPlacement;
+    tooltipShowArrow: boolean;
+    tooltipMultiline: boolean;
+    tooltipMaxWidth: string;
+    tooltipInteractive: boolean;
+    tooltipClass: string;
+    private tooltipElement;
+    private visible;
+    private showTimeout;
+    private hideTimeout;
+    private hideDelay;
+    private interactiveMouseLeaveHandler;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    onMouseEnter(): void;
+    onFocus(): void;
+    onMouseLeave(): void;
+    onBlur(): void;
+    onClick(): void;
+    ngOnDestroy(): void;
+    private clearTimeouts;
+    private show;
+    private hide;
+    private createTooltip;
+    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>;
+}
+
+declare class CideEleSkeletonLoaderComponent {
+    width: string;
+    height: string;
+    borderRadius: string;
+    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>;
+}
+
+type ColumnType = 'text' | 'number' | 'date' | 'boolean' | 'status' | 'actions' | 'custom' | 'order';
+type ColumnWidth = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto' | string;
+type TextAlign = 'left' | 'center' | 'right';
+interface GridColumn {
+    key: string;
+    header: string;
+    type: ColumnType;
+    width?: ColumnWidth;
+    sortable?: boolean;
+    searchable?: boolean;
+    truncate?: boolean;
+    align?: TextAlign;
+    renderer?: string;
+    valueGetter?: string;
+    formatter?: GridFormatter;
+    actions?: GridAction[];
+    statusConfig?: StatusConfig;
+}
+interface GridFormatter {
+    type: 'date' | 'currency' | 'percentage' | 'custom';
+    format?: string;
+    customFunction?: string;
+}
+interface StatusConfig {
+    activeValue: string | number | boolean;
+    activeLabel: string;
+    inactiveLabel: string;
+    activeClass: string;
+    inactiveClass: string;
+}
+interface GridAction {
+    key: string;
+    label: string;
+    icon: string;
+    variant: 'ghost' | 'primary' | 'outline' | 'danger';
+    tooltip?: string;
+    condition?: string;
+    onClick: string;
+}
+interface GridPaginationConfig {
+    enabled: boolean;
+    pageSize: number;
+    pageSizeOptions: number[];
+    showQuickJump: boolean;
+    showPageInfo: boolean;
+    showRefresh: boolean;
+}
+interface GridSearchConfig {
+    enabled: boolean;
+    placeholder: string;
+    searchableColumns: string[];
+    debounceMs?: number;
+}
+interface GridExportConfig {
+    enabled: boolean;
+    formats: ('csv' | 'excel' | 'pdf')[];
+    filename?: string;
+}
+interface GridLoadingConfig {
+    useDefer: boolean;
+    skeletonRows: number;
+    showOverlay: boolean;
+}
+interface GridScrollConfig {
+    enabled: boolean;
+    maxHeight?: string;
+    minHeight?: string;
+    stickyHeader?: boolean;
+    virtualScroll?: boolean;
+    rowHeight?: number;
+}
+interface GridTreeConfig {
+    enabled: boolean;
+    primaryKey: string;
+    foreignKey: string;
+    childrenKey?: string;
+    levelKey?: string;
+    expandedKey?: string;
+    hasChildrenKey?: string;
+}
+interface GridDragDropConfig {
+    enabled: boolean;
+    dragHandle?: string;
+    orderField?: string;
+    dragClass?: string;
+    dropClass?: string;
+}
+interface GridConfiguration<T = Record<string, unknown>> {
+    id: string;
+    title?: string;
+    subtitle?: string;
+    columns: GridColumn[];
+    data: T[];
+    trackBy?: string;
+    pagination: GridPaginationConfig;
+    search: GridSearchConfig;
+    export?: GridExportConfig;
+    loading: GridLoadingConfig;
+    scroll?: GridScrollConfig;
+    tree?: GridTreeConfig;
+    dragDrop?: GridDragDropConfig;
+    responsive: boolean;
+    striped?: boolean;
+    bordered?: boolean;
+    compact?: boolean;
+    fullHeight?: boolean;
+    onRowClick?: string;
+    onSort?: string;
+    onPageChange?: string;
+    onSearch?: string;
+    onRefresh?: string;
+    onExport?: string;
+    onRowReorder?: string;
+    tableClass?: string;
+    headerClass?: string;
+    rowClass?: string;
+    cellClass?: string;
+}
+interface GridState<T = Record<string, unknown>> {
+    currentPage: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+    searchQuery: string;
+    sortColumn?: string;
+    sortDirection?: 'asc' | 'desc';
+    loading: boolean;
+    isRefreshing: boolean;
+    selectedRows: T[];
+}
+interface GridEvent<T = Record<string, unknown>> {
+    type: 'rowClick' | 'sort' | 'pageChange' | 'search' | 'refresh' | 'export' | 'action' | 'rowReorder';
+    data: T | T[] | string | number | null | {
+        sourceItem: T;
+        sourceIndex: number;
+        targetItem: T;
+        targetIndex: number;
+        newOrder: T[];
+    };
+    column?: GridColumn;
+    action?: GridAction;
+}
+declare const DEFAULT_GRID_CONFIG: Partial<GridConfiguration>;
+type GridEventHandler<T = Record<string, unknown>> = (event: GridEvent<T>) => void;
+type GridCustomRenderer<T = Record<string, unknown>> = (value: unknown, row: T, column: GridColumn) => string;
+type GridCustomFormatter = (value: unknown, format?: string) => string;
+
+interface TemplateContext<T = Record<string, unknown>> {
+    $implicit: unknown;
+    row: T;
+    value: 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>;
+    serverSidePagination: boolean;
+    totalServerItems: number;
+    currentServerPage: number;
+    currentServerPageSize: number;
+    dragDropEnabled: boolean;
+    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>;
+    jumpToPage: number;
+    isDragOverRow: number | null;
+    isDragging: i0.WritableSignal<boolean>;
+    hasOrderChanged: i0.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>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Check if the config change is only a data update
+     */
+    private isDataOnlyUpdate;
+    /**
+     * Update only the data without triggering full grid re-initialization
+     * This prevents the search input and other UI state from being reset
+     */
+    private updateDataOnly;
+    private mergeConfigWithDefaults;
+    private initializeGrid;
+    /**
+     * Get the unique identifier for an item
+     */
+    private getItemId;
+    /**
+     * Get the order value for an item from the config
+     */
+    private getItemOrder;
+    /**
+     * Initialize the original order for drag and drop
+     */
+    private initializeOriginalOrder;
+    /**
+     * Refresh order tracking with current data (called when data updates)
+     */
+    private refreshOrderTracking;
+    private applyFilters;
+    /**
+     * Transform flat data to tree structure based on foreign key relationships
+     */
+    private transformToTree;
+    /**
+     * Recursively calculate item level in hierarchy for unlimited depth support
+     */
+    private calculateItemLevel;
+    /**
+     * Flatten tree structure for display, respecting expansion state with unlimited nesting
+     */
+    private flattenTreeForDisplay;
+    /**
+     * Toggle expand/collapse state of a tree item with unlimited nesting support
+     */
+    private toggleTreeExpand;
+    private updatePaginationState;
+    onPageChange(page: number | string): void;
+    onPageSizeChange(): void;
+    updatePageSize(value: string | number): void;
+    previousPage(): void;
+    nextPage(): void;
+    onJumpToPage(): void;
+    getEnhancedPageNumbers(): (number | string)[];
+    updateSearchQuery(value: inputType): void;
+    onSearch(): void;
+    onRefresh(): void;
+    setRefreshing(isRefreshing: boolean): void;
+    clearPageChangeLoading(): void;
+    /**
+     * Check if tree view is enabled
+     */
+    isTreeEnabled(): boolean;
+    /**
+     * Get tree configuration
+     */
+    getTreeConfig(): cloud_ide_element.GridTreeConfig | undefined;
+    /**
+     * Check if an item has children
+     */
+    hasChildren(item: T): boolean;
+    /**
+     * Get item level in tree
+     */
+    getItemLevel(item: T): number;
+    /**
+     * Check if item is expanded
+     */
+    isItemExpanded(item: T): boolean;
+    /**
+     * Get tree indent style
+     */
+    getTreeIndentStyle(item: T): string;
+    /**
+     * Get tree level background class for visual distinction
+     */
+    getTreeLevelClass(item: T): string;
+    /**
+     * Check if drag and drop is enabled
+     */
+    isDragDropEnabled(): boolean;
+    /**
+     * Get drag and drop configuration
+     */
+    getDragDropConfig(): cloud_ide_element.GridDragDropConfig | undefined;
+    /**
+     * Handle drag start event
+     */
+    onDragStart(event: DragEvent, item: T, index: number): void;
+    /**
+     * Handle drag over event
+     */
+    onDragOver(event: DragEvent): void;
+    /**
+     * Handle drag leave event
+     */
+    onDragLeave(event: DragEvent): void;
+    /**
+     * Handle drop event
+     */
+    onDrop(event: DragEvent, targetItem: T, targetIndex: number): void;
+    /**
+     * Handle drag end event
+     */
+    onDragEnd(event: DragEvent): void;
+    /**
+     * Calculate new order after reordering
+     */
+    private getNewOrder;
+    /**
+     * Get the current order number for a specific item
+     */
+    getCurrentOrderNumber(item: T): number;
+    /**
+     * Update the row order map with new positions after reordering
+     */
+    private updateRowOrderMap;
+    /**
+     * Check if any row has changed position by comparing old vs new positions
+     */
+    private checkIfOrderChanged;
+    /**
+     * Reset the row order map to original positions (for reset action)
+     */
+    private resetRowOrderMap;
+    /**
+     * Update the row order map baseline to current positions (for save action)
+     */
+    private updateRowOrderMapBaseline;
+    /**
+     * Get the current order array from the row order map
+     */
+    private getCurrentOrderFromMap;
+    /**
+     * Update local data order for visual reordering (LOCAL ONLY)
+     */
+    private updateLocalDataOrder;
+    /**
+     * Check if the current order has changed from the initial order
+     */
+    private checkOrderChanged;
+    onRowClick(item: T): void;
+    onActionClick(item: T, action: GridAction): void;
+    private emitEvent;
+    /**
+     * Get nested value from an object
+     * @param obj - The object to get the nested value from
+     * @param path - The path to the nested value (e.g., 'contact.email')
+     * @returns The nested value or undefined if not found
+     * @example
+     * const obj = { contact: { email: 'test@example.com' } };
+     * const value = getNestedValue(obj, 'contact.email');
+     * // value === 'test@example.com'
+     */
+    getNestedValue(obj: T, path: string): unknown;
+    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;
+    getStatusClass(value: unknown, statusConfig?: StatusConfig): string;
+    getStatusText(value: unknown, statusConfig?: StatusConfig): string;
+    getItemRangeText(): string;
+    getPageSizeOptions(): {
+        value: number;
+        label: string;
+    }[];
+    trackByFn(index: number, item: T): unknown;
+    getSkeletonArray(): number[];
+    get displayedData(): T[];
+    get columns(): GridColumn[];
+    get paginationConfig(): cloud_ide_element.GridPaginationConfig;
+    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>;
+}
+
+interface DropdownItem {
+    id: string;
+    label: string;
+    icon?: string;
+    iconColor?: string;
+    textColor?: string;
+    hoverBgColor?: string;
+    disabled?: boolean;
+    divider?: boolean;
+}
+interface DropdownConfig {
+    triggerIcon?: string;
+    triggerSize?: 'xs' | 'sm' | 'md' | 'lg';
+    triggerColor?: string;
+    triggerHoverColor?: string;
+    triggerHoverBgColor?: string;
+    menuWidth?: string;
+    menuPosition?: 'left' | 'right' | 'auto';
+    showArrow?: boolean;
+    forcePosition?: 'top' | 'bottom' | 'left' | 'right';
+    offsetX?: number;
+    offsetY?: number;
+}
+interface DropdownPosition {
+    vertical: 'top' | 'bottom';
+    horizontal: 'left' | 'right';
+    spaceAvailable: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+}
+declare class CideEleDropdownComponent implements OnInit, OnDestroy {
+    private destroyRef;
+    private dropdownManager;
+    private dropdownId;
+    dropdownContainer: i0.Signal<ElementRef<any>>;
+    dropdownMenu: i0.Signal<ElementRef<any> | undefined>;
+    set items(value: DropdownItem[]);
+    get items(): DropdownItem[];
+    private _items;
+    config: DropdownConfig;
+    triggerTemplate?: TemplateRef<{
+        $implicit: boolean;
+    }>;
+    menuTemplate?: TemplateRef<{
+        $implicit: DropdownItem[];
+    }>;
+    itemClick: EventEmitter<DropdownItem>;
+    dropdownToggle: EventEmitter<boolean>;
+    isOpen: i0.WritableSignal<boolean>;
+    currentPosition: i0.WritableSignal<DropdownPosition>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getTriggerClasses(): string;
+    getTriggerIconClasses(): string;
+    getMenuClasses(): string;
+    getMenuStyles(): string;
+    calculatePosition(): DropdownPosition;
+    private getMenuWidth;
+    private getEstimatedMenuHeight;
+    toggleDropdown(event: Event): void;
+    private openDropdown;
+    testMouseDown(item: DropdownItem): void;
+    onItemClick(item: DropdownItem, event: Event): void;
+    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>;
+}
+
+interface DropdownInstance {
+    id: string;
+    close: () => void;
+    element?: Element;
+}
+declare class DropdownManagerService {
+    private activeDropdowns;
+    private documentClickListener?;
+    private escapeKeyListener?;
+    constructor();
+    private initializeGlobalListeners;
+    registerDropdown(dropdown: DropdownInstance): void;
+    unregisterDropdown(id: string): void;
+    closeAllDropdowns(): void;
+    closeDropdown(id: string): void;
+    isDropdownOpen(id: string): boolean;
+    private handleDocumentClick;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownManagerService>;
+}
+
+interface ConfirmationRequest<T = unknown> {
+    id: string;
+    title: string;
+    message: string;
+    type: 'danger' | 'warning' | 'info' | 'success';
+    icon?: string;
+    confirmText?: string;
+    cancelText?: string;
+    customTemplate?: TemplateRef<unknown>;
+    customData?: T;
+    resolve: (value: boolean | T) => void;
+    reject: (reason?: unknown) => void;
+}
+interface ConfirmationOptions<T = unknown> {
+    title: string;
+    message: string;
+    type?: 'danger' | 'warning' | 'info' | 'success';
+    icon?: string;
+    confirmText?: string;
+    cancelText?: string;
+    customTemplate?: TemplateRef<unknown>;
+    customData?: T;
+}
+declare class ConfirmationService {
+    private confirmationQueue;
+    private currentRequest;
+    hasActiveConfirmation: i0.Signal<boolean>;
+    queueLength: i0.Signal<number>;
+    constructor();
+    /**
+     * Ask for confirmation with a simple yes/no dialog
+     */
+    ask(options: ConfirmationOptions<unknown>): Promise<boolean>;
+    /**
+     * Ask for confirmation with custom template and return custom data
+     */
+    askWithTemplate<T = unknown>(options: ConfirmationOptions<T> & {
+        customTemplate: TemplateRef<unknown>;
+    }): Promise<T>;
+    /**
+     * Quick confirmation for dangerous actions
+     */
+    confirmDelete(itemName?: string): Promise<boolean>;
+    /**
+     * Quick confirmation for permanent actions
+     */
+    confirmPermanentAction(action: string, itemName?: string): Promise<boolean>;
+    /**
+     * Quick confirmation for safe actions
+     */
+    confirmSafeAction(action: string, itemName?: string): Promise<boolean>;
+    private addToQueue;
+    private processQueue;
+    confirmCurrentRequest(data?: unknown): void;
+    cancelCurrentRequest(): void;
+    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>;
+}
+
+interface NotificationOptions {
+    message: string;
+    type?: 'success' | 'error' | 'warning' | 'info';
+    duration?: number;
+    showUndo?: boolean;
+    undoAction?: () => void;
+    undoText?: string;
+    icon?: string;
+    title?: string;
+}
+interface NotificationItem {
+    id: string;
+    message: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    duration: number;
+    showUndo: boolean;
+    undoAction?: () => void;
+    undoText: string;
+    icon: string;
+    title?: string;
+    timestamp: number;
+    isVisible: boolean;
+}
+declare class NotificationService {
+    private notifications;
+    private maxNotifications;
+    activeNotifications: i0.Signal<NotificationItem[]>;
+    constructor();
+    /**
+     * Show a success notification
+     */
+    success(message: string, options?: Partial<NotificationOptions>): string;
+    /**
+     * Show an error notification
+     */
+    error(message: string, options?: Partial<NotificationOptions>): string;
+    /**
+     * Show a warning notification
+     */
+    warning(message: string, options?: Partial<NotificationOptions>): string;
+    /**
+     * Show an info notification
+     */
+    info(message: string, options?: Partial<NotificationOptions>): string;
+    /**
+     * Show a notification with undo functionality
+     */
+    showWithUndo(message: string, undoAction: () => void, options?: Partial<NotificationOptions>): string;
+    /**
+     * Show a notification for reversible destructive actions
+     */
+    showReversibleAction(action: string, itemName: string, undoAction: () => void, options?: Partial<NotificationOptions>): string;
+    /**
+     * Show a notification for background tasks
+     */
+    showBackgroundTask(taskName: string, isComplete?: boolean, options?: Partial<NotificationOptions>): string;
+    /**
+     * Core show method
+     */
+    private show;
+    /**
+     * Remove a specific notification
+     */
+    remove(id: string): void;
+    /**
+     * Remove all notifications
+     */
+    clearAll(): void;
+    /**
+     * Execute undo action for a notification
+     */
+    executeUndo(id: string): void;
+    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>;
+}
+
+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>;
+    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>;
+}
+
+declare class CideEleToastNotificationComponent {
+    private notificationService;
+    activeNotifications: i0.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>;
+}
+
+declare class CideEleGlobalNotificationsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleGlobalNotificationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleGlobalNotificationsComponent, "cide-ele-global-notifications", never, {}, {}, never, never, true, never>;
+}
+
+interface JsonEditorConfig {
+    /** Enable syntax highlighting */
+    syntaxHighlighting?: boolean;
+    /** Enable line numbers */
+    showLineNumbers?: boolean;
+    /** Enable auto-formatting */
+    autoFormat?: boolean;
+    /** Enable validation */
+    validateOnChange?: boolean;
+    /** Theme for the editor */
+    theme?: 'light' | 'dark';
+    /** Minimum height in pixels */
+    minHeight?: number;
+    /** Maximum height in pixels */
+    maxHeight?: number;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Read-only mode */
+    readOnly?: boolean;
+    /** Show error messages */
+    showErrors?: boolean;
+}
+interface JsonEditorError {
+    line: number;
+    column: number;
+    message: string;
+    type: 'syntax' | 'validation';
+}
+declare class CideEleJsonEditorComponent implements OnInit, ControlValueAccessor {
+    label?: string;
+    helperText?: string;
+    required: boolean;
+    disabled: i0.WritableSignal<boolean>;
+    showCharacterCount: boolean;
+    config: JsonEditorConfig;
+    configSignal: i0.WritableSignal<JsonEditorConfig>;
+    valueChange: EventEmitter<string>;
+    objectChange: EventEmitter<object | null>;
+    errorsChange: EventEmitter<JsonEditorError[]>;
+    validChange: EventEmitter<boolean>;
+    jsonTextarea: i0.Signal<ElementRef<HTMLTextAreaElement>>;
+    private destroyRef;
+    jsonString: i0.WritableSignal<string>;
+    jsonObject: i0.WritableSignal<object | null>;
+    errors: i0.WritableSignal<JsonEditorError[]>;
+    editorId: string;
+    hasErrors: i0.Signal<boolean>;
+    isValid: i0.Signal<boolean>;
+    lineNumbers: i0.Signal<number[]>;
+    containerClass: i0.Signal<string>;
+    private defaultConfig;
+    ngOnInit(): void;
+    /**
+     * Handle input changes
+     */
+    onInput(event: Event): void;
+    /**
+     * Handle blur event
+     */
+    onBlur(): void;
+    /**
+     * Parse JSON string and emit object
+     */
+    private parseJson;
+    /**
+     * Validate JSON and update errors
+     */
+    private validateJson;
+    /**
+     * Format JSON with proper indentation
+     */
+    formatJson(): void;
+    /**
+     * Check if there's an error on a specific line
+     */
+    hasErrorOnLine(line: number): boolean;
+    /**
+     * Get error ID for accessibility
+     */
+    errorId(): string;
+    /**
+     * Focus the editor
+     */
+    focus(): void;
+    /**
+     * Clear the editor
+     */
+    clear(): void;
+    /**
+     * Get current JSON object
+     */
+    getValue(): object | null;
+    /**
+     * Get current JSON string
+     */
+    getStringValue(): string;
+    /**
+     * Check if JSON is valid
+     */
+    isValidJson(): boolean;
+    /**
+     * Get validation errors
+     */
+    getErrors(): JsonEditorError[];
+    writeValue(value: string | object | null | undefined): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    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>;
+}
+
+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 };