import * as _angular_core from '@angular/core'; import { PipeTransform, OnChanges, OnInit, OnDestroy, EventEmitter, TemplateRef, SimpleChanges, ElementRef, AfterContentInit, QueryList, ViewContainerRef, Renderer2, Signal, AfterViewInit, Type, Injector, ComponentRef } from '@angular/core'; import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors, FormGroup } from '@angular/forms'; import { elementStyleType, labelPlacementType, labelDirType, autocapitalizeType, autocompleteType, controlType, inputType, themeSize, selectSearchType, ICoreSype, GetElementDataRequest, iconType, spinnerType, fileManagerListByGroupIdControllerResponse } from 'cloud-ide-lms-model'; import * as cloud_ide_element from 'cloud-ide-element'; import { BehaviorSubject, Observable } from 'rxjs'; import { Router, NavigationExtras } from '@angular/router'; import { HttpClient, HttpEvent } from '@angular/common/http'; declare class CapitalizePipe implements PipeTransform { transform(value: string, capitalizationMethod: 'allUpperCase' | 'titleCase' | 'sentenceCase'): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵpipe: _angular_core.ɵɵPipeDeclaration; } /** @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, OnDestroy { capitalizePipe: CapitalizePipe; private elementService; private cdr; 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 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 step value for number type control */ step: number | string; /** * @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; /** @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; 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; private datePickerViewRef; showTimePicker: boolean; timeHours: number; timeMinutes: number; timeSeconds: number; timeFormat: 'AM' | 'PM'; private timePickerPortalId; timePickerTemplate: TemplateRef; showDateTimePicker: boolean; dateTimeStep: 'date' | 'time'; private dateTimePickerPortalId; dateTimePickerTemplate: TemplateRef; /** * @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; ngOnDestroy(): 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; /** * @description Helper to check if type is time (for template type narrowing) */ isTimeType(): boolean; /** * @description use to detact the change in type if changes done this method is ued to run */ detectTypeChange(): void; /** * @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; /** * @description Initialize time picker with current values */ initializeTimePicker(): void; /** * @description Create time picker using template-based portal service */ private createTimePickerUsingPortal; /** * @description Close time picker */ closeTimePicker(): void; /** * @description Increment/decrement time value */ adjustTime(unit: 'hours' | 'minutes' | 'seconds', direction: 'up' | 'down'): void; /** * @description Toggle AM/PM */ toggleTimeFormat(): void; /** * @description Apply selected time */ applyTime(): void; /** * @description Get time display value for the input field */ getTimeDisplayValue(): string; /** * @description Initialize datetime picker */ initializeDateTimePicker(): void; /** * @description Create datetime picker using portal service */ private createDateTimePickerUsingPortal; /** * @description Close datetime picker */ closeDateTimePicker(): void; /** * @description Select date in datetime picker (just updates the selected date, time stays visible) */ selectDateTimeDate(dayInfo: { day: number; isCurrentMonth: boolean; isSelected: boolean; isToday: boolean; date: Date; }): void; /** * @description Apply datetime (combines date and time) */ applyDateTime(): void; /** * @description Get datetime display value */ getDateTimeDisplayValue(): string; /** * @description Back to date selection in datetime picker */ backToDateSelection(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface SelectOption { value: string | number; 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: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CideSelectComponent implements ControlValueAccessor, Validator, OnInit, OnChanges, AfterContentInit, OnDestroy { private elementRef; optionComponents: QueryList; searchInputRef: ElementRef; label: _angular_core.InputSignal; labelHide: _angular_core.InputSignal; placeholder: _angular_core.InputSignal; helperText: _angular_core.InputSignal; errorText: _angular_core.InputSignal; required: _angular_core.InputSignal; disabled: _angular_core.InputSignal; id: _angular_core.InputSignal; ngModel: string | number | string[]; size: _angular_core.InputSignal; fill: _angular_core.InputSignal; labelPlacement: _angular_core.InputSignal; labelDir: _angular_core.InputSignal; leadingIcon: _angular_core.InputSignal; trailingIcon: _angular_core.InputSignal; clearInput: _angular_core.InputSignal; options: _angular_core.InputSignal<(SelectOption | SelectOptionObject)[]>; multiple: _angular_core.InputSignal; searchable: _angular_core.InputSignal; showSearchInput: _angular_core.InputSignal; loading: _angular_core.InputSignal; /** * 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: _angular_core.InputSignal; /** * 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: _angular_core.InputSignal; /** * Tree/Hierarchy configuration for displaying options in a tree structure * When enabled, options will be displayed with indentation and tree connectors */ treeView: _angular_core.InputSignal<{ enabled: boolean; primaryKey?: string; foreignKey?: string; levelKey?: string; } | null>; ngModelChange: EventEmitter; selectionChange: EventEmitter; searchChange: EventEmitter; isOpen: boolean; isTouched: boolean; isValid: boolean; searchTerm: string; filteredOptions: (SelectOption | SelectOptionObject)[]; private searchDebounceTimeout; private searchSubject; private destroy$; private isUpdatingOptions; private portalService; private dropdownPortalId; dropdownTemplate: TemplateRef; dropdownContainer: ViewContainerRef; dropdownPosition: 'bottom' | 'top'; private isDropdownInteraction; dropdownWidthConstraints: { minWidth: number; maxWidth: number; }; 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; private _disabledState; isDisabled(): boolean; validate(control: AbstractControl): 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 | SelectOptionObject): void; onBlur(): void; focusControl(): void; clearSelection(): void; getSelectedOptionLabel(): string; /** * Get display label for selected option * For tree view, shows the full path or abbreviated path if too long */ private getSelectedDisplayLabel; /** * Abbreviate long paths: "Parent 1 /.../ Last Child" * Shows first and last segments with "/.../" in between if path is too long */ private abbreviatePath; filterOptions(): void; /** * Build tree structure from flat options and flatten with hierarchy visualization */ private buildTreeStructure; /** * Get nested value from object using dot notation */ private getNestedValue; onSearchInput(event: Event): void; onDropdownMouseDown(): void; onSearchInputBlur(event: Event): void; onDropdownMouseUp(): void; 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: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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; activeTab: _angular_core.WritableSignal; ngOnInit(): void; onTabClick(tab: TabItem): void; isActive(tabId: string): boolean; getTabClasses(tab: TabItem): string; getContainerClasses(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * 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; autoUpload: boolean; uploadData: FileUploadData; showFloatingUploader: boolean; floatingUploaderGroupId?: string; fileChange: EventEmitter; uploadSuccess: EventEmitter; uploadError: EventEmitter; uploadProgressChange: EventEmitter; readonly labelSignal: _angular_core.WritableSignal; readonly acceptSignal: _angular_core.WritableSignal; readonly multipleSignal: _angular_core.WritableSignal; readonly disabledSignal: _angular_core.WritableSignal; readonly requiredSignal: _angular_core.WritableSignal; readonly helperTextSignal: _angular_core.WritableSignal; readonly errorTextSignal: _angular_core.WritableSignal; readonly showPreviewSignal: _angular_core.WritableSignal; readonly previewWidthSignal: _angular_core.WritableSignal; readonly previewHeightSignal: _angular_core.WritableSignal; readonly previewBoxModeSignal: _angular_core.WritableSignal; readonly showFileNameSignal: _angular_core.WritableSignal; readonly placeholderTextSignal: _angular_core.WritableSignal; readonly placeholderIconSignal: _angular_core.WritableSignal; readonly autoUploadSignal: _angular_core.WritableSignal; readonly uploadDataSignal: _angular_core.WritableSignal; readonly showFloatingUploaderSignal: _angular_core.WritableSignal; readonly floatingUploaderGroupIdSignal: _angular_core.WritableSignal; readonly id: _angular_core.WritableSignal; readonly isUploading: _angular_core.WritableSignal; readonly uploadProgress: _angular_core.WritableSignal; readonly uploadStatus: _angular_core.WritableSignal<"start" | "error" | "uploading" | "success" | "idle">; readonly files: _angular_core.WritableSignal; readonly fileNames: _angular_core.WritableSignal; readonly previewUrls: _angular_core.WritableSignal; readonly uploadNotificationId: _angular_core.WritableSignal; readonly isDragOver: _angular_core.WritableSignal; readonly groupId: _angular_core.WritableSignal; readonly isMultipleUploadMode: _angular_core.WritableSignal; readonly hasEverUploaded: _angular_core.WritableSignal; readonly failedFile: _angular_core.WritableSignal; readonly hasFiles: _angular_core.Signal; readonly canUpload: _angular_core.Signal; readonly isInErrorState: _angular_core.Signal; readonly isInSuccessState: _angular_core.Signal; readonly canRetry: _angular_core.Signal; readonly totalFileSize: _angular_core.Signal; readonly fileSizeInMB: _angular_core.Signal; private onChange; private onTouched; private onValidatorChange; readonly hasImages: _angular_core.Signal; readonly isPreviewBoxMode: _angular_core.Signal; readonly isImagePreviewAvailable: _angular_core.Signal; 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; /** * Retry uploading the failed file */ retryUpload(): 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; 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; /** * 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; /** * 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): void; getCurrentState(): { id: string; label: string; required: boolean; disabled: boolean; accept: string; multiple: boolean; showPreview: boolean; autoUpload: boolean; uploadStatus: "start" | "error" | "uploading" | "success" | "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; validate(control: AbstractControl): ValidationErrors | null; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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; fileInputRef: ElementRef; data: FloatingFileUploaderData; isVisible: _angular_core.WritableSignal; currentUserId: _angular_core.WritableSignal; currentGroupId: _angular_core.WritableSignal; uploadQueue: _angular_core.Signal; activeUploads: _angular_core.Signal>; hasUploads: _angular_core.Signal; hasActiveUploads: _angular_core.Signal; pendingUploads: _angular_core.Signal; activeUploadsLocal: _angular_core.Signal; completedUploads: _angular_core.Signal; failedUploads: _angular_core.Signal; allFilesForGroup: _angular_core.Signal<{ fileId: string; fileName: string; stage: string; percentage?: number; }[]>; hasFilesToShow: _angular_core.Signal; getUploadingCount(): number; getCompletedCount(): number; getFailedCount(): number; isAnimating: _angular_core.WritableSignal; isDragOver: _angular_core.WritableSignal; 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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; /** * Hide file uploader */ hide(): void; /** * Show file uploader with specific group ID */ showWithGroupId(groupId: string, additionalData?: Partial): Promise; /** * Show file uploader for user with specific settings */ showForUser(userId: string, settings?: Partial): Promise; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } 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; 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: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface BreadcrumbItem { id: string; label: string; icon?: string; url?: string; disabled?: boolean; type?: 'root' | 'category' | 'entity' | 'custom'; metadata?: any; } interface BreadcrumbDropdownOption { id: string; label: string; icon?: string; disabled?: boolean; action?: () => void; } interface BreadcrumbSeparator { type: 'chevron' | 'slash' | 'arrow' | 'dot' | 'custom'; icon?: string; text?: string; } type BreadcrumbStyle = 'modern' | 'classic' | 'minimal' | 'hierarchical'; interface BreadcrumbConfig { style: BreadcrumbStyle; separator: BreadcrumbSeparator; showHomeIcon: boolean; homeIcon: string; maxItems: number; showDropdownOnOverflow: boolean; dropdownOptions: BreadcrumbDropdownOption[]; clickableItems: boolean; showTooltips: boolean; responsive: boolean; compact: boolean; animated: boolean; } declare class CideEleBreadcrumbComponent implements OnInit, OnDestroy { items: _angular_core.InputSignal; style: _angular_core.InputSignal; separator: _angular_core.InputSignal; showHomeIcon: _angular_core.InputSignal; homeIcon: _angular_core.InputSignal; maxItems: _angular_core.InputSignal; showDropdownOnOverflow: _angular_core.InputSignal; dropdownOptions: _angular_core.InputSignal; clickableItems: _angular_core.InputSignal; showTooltips: _angular_core.InputSignal; responsive: _angular_core.InputSignal; compact: _angular_core.InputSignal; animated: _angular_core.InputSignal; loadingInput: _angular_core.InputSignal; disabled: _angular_core.InputSignal; contextId: _angular_core.InputSignal; pageCode: _angular_core.InputSignal; itemClick: EventEmitter; dropdownOptionClick: EventEmitter; homeClick: EventEmitter; private showDropdown; private isOverflowing; private visibleItems; private hiddenItems; private localItems; private localLoading; showDropdownSignal: _angular_core.Signal; isOverflowingSignal: _angular_core.Signal; visibleItemsSignal: _angular_core.Signal; hiddenItemsSignal: _angular_core.Signal; config: _angular_core.Signal; effectiveLoading: _angular_core.Signal; private cleanupEffect?; constructor(); ngOnInit(): void; ngOnDestroy(): void; onDocumentClick(event: Event): void; private processItems; private getConfigForStyle; onItemClick(item: BreadcrumbItem): void; onHomeClick(): void; onDropdownToggle(): void; onDropdownOptionClick(option: BreadcrumbDropdownOption): void; getItemClasses(item: BreadcrumbItem, isLast?: boolean): string; getContainerClasses(): string; getSeparatorIcon(): string; getTooltipText(item: BreadcrumbItem): string; toggleDropdown(): void; closeDropdown(): void; updateItems(newItems: BreadcrumbItem[]): void; addItem(item: BreadcrumbItem): void; removeItem(itemId: string): void; setLoading(value: boolean): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CideElementsService { cide_element_data: { [key: string]: ICoreSype; }; is_cide_element_data_updated: BehaviorSubject; getElementData(body: GetElementDataRequest): Promise; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Export Service - Provides export functionality for Excel (XLSX) and PDF without third-party libraries */ declare class ExportService { /** * Export data to Excel format * Uses HTML table with Excel MIME type for better compatibility * This approach is more reliable than XML across different Excel versions */ exportToExcel(data: any[], columns: { key: string; label: string; }[], filename?: string): void; /** * Export data to PDF format * Uses browser's print functionality to generate PDF */ exportToPDF(data: any[], columns: { key: string; label: string; }[], filename?: string): void; /** * Export data to CSV format */ exportToCSV(data: any[], columns: { key: string; label: string; }[], filename?: string): void; /** * Generate Excel HTML format content * This approach uses HTML tables with Excel-specific MIME type and namespace * More compatible across Excel versions (2003, 2007, 2010, 2016, Office 365) * Also works with Google Sheets and LibreOffice Calc */ private generateExcelXML; /** * Generate HTML content for PDF printing */ private generatePDFHTML; /** * Download file helper */ private downloadFile; /** * Escape HTML special characters */ private escapeHTML; /** * Escape CSV special characters */ private escapeCSV; /** * Get PDF header cell style */ private getPDFHeaderStyle; /** * Get PDF cell style */ private getPDFCellStyle; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Currency Display Format Options */ type CurrencyDisplayFormat = 'symbol_before' | 'symbol_after' | 'code_before' | 'code_after'; /** * Currency Configuration Interface * Matches the structure from accounts library financial config */ interface CurrencyConfig { currencyCode?: string; currencySymbol?: string; displayFormat?: CurrencyDisplayFormat; showSymbol?: boolean; showCode?: boolean; decimalPlaces?: number; thousandSeparator?: string; decimalSeparator?: string; locale?: string; roundingMethod?: 'round' | 'floor' | 'ceiling' | 'none'; roundingPrecision?: number; } /** * Default Currency Configuration * Defaults to Indian Rupees (INR) */ declare const DEFAULT_CURRENCY_CONFIG: CurrencyConfig; /** * Currency Pipe * * Formats numbers as currency using global currency configuration. * Supports override for specific formatting needs. * * @example * ```html * * {{ amount | currency }} * * * {{ amount | currency: { currencySymbol: '₹' } }} * * * {{ amount | currency: { decimalPlaces: 0 } }} * * * {{ amount | currency: { displayFormat: 'symbol_after' } }} * ``` */ declare class CurrencyPipe implements PipeTransform { private readonly currencyService; /** * Transform number to formatted currency string * @param value - Number to format * @param override - Optional override configuration * @returns Formatted currency string */ transform(value: number | string | null | undefined, override?: Partial): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵpipe: _angular_core.ɵɵPipeDeclaration; } 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: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } 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; 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: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** * Path Helper Utility * Cloned from cloud-ide-lms-model to avoid dependencies */ declare const cidePath: { join: (path: string[]) => string; }; /** * Host Manager Routes * Cloned from cloud-ide-lms-model to avoid dependencies * * Base path for host name to interceptor and replace with actual URL * for more details refer https://docs.google.com/document/d/1CwB4evLsQuatG4jI0U1faRtmqtNmIfZOE4fDWiz9-sQ/edit?pli=1#bookmark=id.j3vzaryhajl1 * __version__ need to add in future */ declare const hostManagerRoutesUrl: { cideSuiteHost: string; }; /** * Notification Routes * Cloned from cloud-ide-lms-model to avoid dependencies */ declare const notificationRoutesUrl: { module: string; notifications: string; unreadCount: string; }; 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'; /** * 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). */ declare class CideEleButtonComponent implements OnInit, OnChanges, OnDestroy { private elementService; private router; private renderer; private elementRef; private destroy$; private clickCount; private clickDebouncer$; isStandaloneElement: boolean; 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; /** * @description Double click event */ doubleClick: EventEmitter; onClick(event: Event): void; private handleClick; private addClickAnimation; ngOnInit(): void; ngOnChanges(changes: SimpleChanges): void; ngOnDestroy(): void; getControlData(): Promise; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CideIconComponent { size: themeSize; type: iconType; toolTip: string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Apple-inspired dark/light mode toggle component * * Features: * - Smooth animated toggle switch * - Apple-style design with rounded corners and shadows * - Works on pages without header/sidebar (dynamic website, login pages, auth project) * - Automatically syncs with system theme preference * - Persists user preference to localStorage */ declare class CideEleThemeToggleComponent implements OnInit, OnDestroy { private readonly themeService; private readonly destroyRef; readonly isDarkMode: _angular_core.WritableSignal; readonly isAnimating: _angular_core.WritableSignal; readonly togglePosition: _angular_core.Signal<"translate-x-5" | "translate-x-0">; readonly toggleBgColor: _angular_core.Signal<"tw-bg-gradient-to-r tw-from-blue-500 tw-to-indigo-600" | "tw-bg-gray-200 dark:tw-bg-gray-700">; ngOnInit(): void; ngOnDestroy(): void; /** * Toggle between light and dark mode */ toggleTheme(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface NotificationOptions { message: string; type?: 'success' | 'error' | 'warning' | 'info'; duration?: number; showUndo?: boolean; undoAction?: () => void; undoText?: string; icon?: string; title?: string; progress?: number; showProgress?: boolean; } 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; progress?: number; showProgress?: boolean; } declare class NotificationService { private notifications; private maxNotifications; activeNotifications: _angular_core.Signal; constructor(); /** * Show a success notification */ success(message: string, options?: Partial): string; /** * Show an error notification */ error(message: string, options?: Partial): string; /** * Show a warning notification */ warning(message: string, options?: Partial): string; /** * Show an info notification */ info(message: string, options?: Partial): string; /** * Show a notification with undo functionality */ showWithUndo(message: string, undoAction: () => void, options?: Partial): string; /** * Show a notification for reversible destructive actions */ showReversibleAction(action: string, itemName: string, undoAction: () => void, options?: Partial): string; /** * Show a notification for background tasks */ showBackgroundTask(taskName: string, isComplete?: boolean, options?: Partial): string; /** * Show a progress notification */ showProgress(message: string, progress?: number, options?: Partial): string; /** * Update progress for an existing notification */ updateProgress(id: string, progress: number, message?: string): void; /** * 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(): _angular_core.WritableSignal; getActiveNotifications(): _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } interface ServerNotification { _id: string; not_id_user: string | { _id?: string; name?: string; email?: string; }; not_type: 'info' | 'success' | 'warning' | 'error' | 'system'; not_category: string; not_title: string; not_message: string; not_data?: any; not_action_url?: string; not_action_label?: string; not_status: 'pending' | 'sent' | 'delivered' | 'read' | 'archived'; not_priority: 'low' | 'normal' | 'high' | 'urgent'; not_read_at?: Date; not_delivered_at?: Date; not_archived_at?: Date; not_channels?: { in_app?: boolean; email?: boolean; sms?: boolean; }; not_created_at: Date; not_updated_at: Date; } interface NotificationListResponse { success: boolean; code: number; message: string; data: ServerNotification[]; total?: number; } interface NotificationResponse { success: boolean; code: number; message: string; data: ServerNotification; } interface UnreadCountResponse { success: boolean; code: number; message: string; data: { count: number; }; } interface CreateNotificationDto { not_id_user: string; not_type?: 'info' | 'success' | 'warning' | 'error' | 'system'; not_category: string; not_title: string; not_message: string; not_data?: any; not_action_url?: string; not_action_label?: string; not_priority?: 'low' | 'normal' | 'high' | 'urgent'; not_channels?: { in_app?: boolean; email?: boolean; sms?: boolean; }; not_expires_at?: Date; not_id_created_by?: string; } declare class NotificationApiService { private readonly http; private readonly apiUrl; /** * Get user notifications */ getNotifications(params?: { status?: string; type?: string; category?: string; priority?: string; pageIndex?: number; pageSize?: number; pagination?: boolean; }): Observable; /** * Get notification by ID */ getNotificationById(id: string): Observable; /** * Get unread count */ getUnreadCount(): Observable; /** * Create notification */ createNotification(payload: CreateNotificationDto): Observable; /** * Mark notification as read */ markAsRead(id: string): Observable; /** * Mark all notifications as read */ markAllAsRead(): Observable; /** * Archive notification */ archiveNotification(id: string): Observable; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } interface NotificationPayload { id: string; type: 'info' | 'success' | 'warning' | 'error' | 'system'; category: string; title: string; message: string; data?: any; action_url?: string; action_label?: string; priority: 'low' | 'normal' | 'high' | 'urgent'; created_at: Date; timestamp: Date; } interface ConnectionStatus { connected: boolean; socketId?: string; userId?: string; timestamp?: Date; } declare class WebSocketNotificationService implements OnDestroy { private socket; private notificationSubject; private connectionStatusSubject; private notifications; private unreadNotifications; notification$: Observable; connectionStatus$: Observable; allNotifications: _angular_core.Signal; unreadNotificationsCount: _angular_core.Signal; isConnected: _angular_core.Signal; /** * Connect to Socket.IO server */ connect(token: string, userId?: string): void; /** * Fallback URL resolution */ private resolveUrlFallback; /** * Connect with resolved URL */ private connectWithUrl; /** * Setup Socket.IO event handlers */ private setupEventHandlers; /** * Acknowledge notification receipt */ acknowledgeNotification(notificationId: string): void; /** * Mark notification as read */ markAsRead(notificationId: string): void; /** * Mark all as read */ markAllAsRead(): void; /** * Disconnect from server */ disconnect(): void; /** * Clear all notifications */ clearNotifications(): void; /** * Remove notification from list */ removeNotification(notificationId: string): void; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * 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; } 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; } 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; 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; readonly objectIdEndpoint: _angular_core.Signal; readonly userId: _angular_core.Signal; readonly isUploading: _angular_core.Signal; readonly uploadQueue: _angular_core.Signal; readonly activeUploads: _angular_core.Signal>; readonly fetchedFiles: _angular_core.Signal>; readonly error: _angular_core.Signal; readonly hasActiveUploads: _angular_core.Signal; readonly queueLength: _angular_core.Signal; readonly totalFetchedFiles: _angular_core.Signal; readonly getFileCountByGroup: _angular_core.Signal>; readonly serviceState: _angular_core.Signal<{ isUploading: boolean; uploadQueue: string[]; activeUploads: Map; fetchedFiles: Map; 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; /** * 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; /** * 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; /** * 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; /** * 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; /** * 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; readonly getTriggerGroupId: _angular_core.Signal; /** * 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; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class CideCoreFileManagerService { private http; private apiUrl; private fileListSubject; fileList$: Observable; constructor(http: HttpClient); /** * Get file list from API */ getFileList(body: IFileListRequest): Observable; /** * Get file list using mock data (deprecated - use getFileList instead) */ getFileListWithMockData(_body: IFileListRequest): Observable; /** * Get file list from cache (if available) */ getFileListFromCache(): ICoreFileManager[]; /** * Upload file with progress tracking */ uploadFile(request: IFileUploadRequest): Observable>; /** * Upload file with progress tracking (mock version - deprecated) */ uploadFileWithMockData(request: IFileUploadRequest): Observable>; /** * Update file metadata */ updateFile(request: IFileUpdateRequest): Observable; /** * Delete file */ deleteFile(id: string): Observable; /** * Delete multiple files */ deleteMultipleFiles(ids: string[]): Observable<{ success: boolean; message?: string; data?: unknown; }>; /** * Toggle file active status */ toggleFileStatus(id: string): Observable; /** * 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; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } 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: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } 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; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } interface ConfirmationRequest { id: string; title: string; message: string; type: 'danger' | 'warning' | 'info' | 'success'; icon?: string; confirmText?: string; cancelText?: string; customTemplate?: TemplateRef; customData?: T; resolve: (value: boolean | T) => void; reject: (reason?: unknown) => void; } interface ConfirmationOptions { title: string; message: string; type?: 'danger' | 'warning' | 'info' | 'success'; icon?: string; confirmText?: string; cancelText?: string; customTemplate?: TemplateRef; customData?: T; } declare class ConfirmationService implements OnDestroy { private readonly confirmationQueue; private readonly currentRequest; readonly hasActiveConfirmation: _angular_core.Signal; readonly queueLength: _angular_core.Signal; constructor(); ngOnDestroy(): void; /** * Ask for confirmation with a simple yes/no dialog */ ask(options: ConfirmationOptions): Promise; /** * Ask for confirmation with custom template and return custom data */ askWithTemplate(options: ConfirmationOptions & { customTemplate: TemplateRef; }): Promise; /** * Quick confirmation for dangerous actions */ confirmDelete(itemName?: string): Promise; /** * Quick confirmation for permanent actions */ confirmPermanentAction(action: string, itemName?: string): Promise; /** * Quick confirmation for safe actions */ confirmSafeAction(action: string, itemName?: string): Promise; private addToQueue; private processQueue; confirmCurrentRequest(data?: unknown): void; cancelCurrentRequest(): void; private removeCurrentRequest; private generateId; private getDefaultIcon; getCurrentRequest(): _angular_core.WritableSignal | null>; getHasActiveConfirmation(): _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } interface PortalPosition { top: number; left: number; maxHeight?: number; maxWidth?: number; minWidth?: number; } interface PortalConfig { triggerElement: HTMLElement; content: string; className?: string; position?: 'bottom' | 'top' | 'auto'; align?: 'left' | 'right' | 'center' | 'auto'; offsetX?: number; offsetY?: number; maxHeight?: number; minWidth?: number; closeOnClickOutside?: boolean; closeOnEscape?: boolean; } interface TemplatePortalConfig { triggerElement: HTMLElement; template: TemplateRef; viewContainerRef: ViewContainerRef; context?: any; className?: string; position?: 'bottom' | 'top' | 'auto'; align?: 'left' | 'right' | 'center' | 'auto'; offsetX?: number; offsetY?: number; maxHeight?: number; minWidth?: number; closeOnClickOutside?: boolean; closeOnEscape?: boolean; } declare class PortalService { private portals; private templatePortals; private boundClickOutsideHandler; private boundEscapeHandler; private closeCallbacks; constructor(); /** * Create a portal with the given configuration */ createPortal(id: string, config: PortalConfig): HTMLElement; /** * Create a template-based portal with Angular template */ createTemplatePortal(id: string, config: TemplatePortalConfig): HTMLElement; /** * Update portal content */ updatePortal(id: string, content: string): void; /** * Update portal position */ updatePortalPosition(id: string, config: PortalConfig): void; /** * Destroy a portal */ destroyPortal(id: string): void; /** * Destroy all portals */ destroyAllPortals(): void; /** * Register a close callback for a portal */ registerCloseCallback(id: string, callback: () => void): void; /** * Get portal element by ID */ getPortal(id: string): HTMLElement | undefined; /** * Check if portal exists */ hasPortal(id: string): boolean; private calculatePosition; private adjustPosition; private setupEventListeners; private cleanupEventListeners; private handleClickOutside; private handleEscape; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } type CideTheme = 'light' | 'dark' | 'auto'; interface CideThemeConfig { /** * Initial theme to use * @default 'light' */ theme?: CideTheme; /** * Target element to apply theme * If not provided, will use document.documentElement (html tag) * @default document.documentElement */ targetElement?: HTMLElement; /** * Persist theme preference to localStorage * @default true */ persistPreference?: boolean; /** * LocalStorage key for theme preference * @default 'cide-theme' */ storageKey?: string; /** * Use data-theme attribute instead of class * @default true */ useDataAttribute?: boolean; /** * Use class name for theme * @default true */ useClassName?: boolean; } declare class CideThemeService { private platformId; private isBrowser; private currentTheme$; private effectiveTheme$; private config; constructor(); /** * Initialize the theme service with configuration * This should be called once in the application, typically in main.ts or app config */ initialize(config?: CideThemeConfig): void; /** * Set the current theme */ setTheme(theme: CideTheme): void; /** * Get the current theme preference */ getCurrentTheme(): CideTheme; /** * Get the effective theme (actual theme being displayed) */ getEffectiveTheme(): 'light' | 'dark'; /** * Observable for current theme changes */ getCurrentTheme$(): Observable; /** * Observable for effective theme changes */ getEffectiveTheme$(): Observable<'light' | 'dark'>; /** * Toggle between light and dark themes */ toggleTheme(): void; /** * Check if dark mode is currently active */ isDarkMode(): boolean; /** * Apply theme to target element */ private applyTheme; /** * Get system theme preference */ private getSystemTheme; /** * Listen to system theme changes */ private listenToSystemTheme; /** * Save theme preference to localStorage */ private saveThemePreference; /** * Load theme preference from localStorage */ private loadThemePreference; /** * Clear saved theme preference */ clearThemePreference(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Currency Service * * Manages global currency configuration with support for: * - Loading from financial config data (app must fetch data first) * - Override capabilities * - App state persistence * - Reactive updates using Angular Signals * - Default currency: Indian Rupees (INR, ₹) * * Note: This service does NOT call APIs. The app must fetch financial config * data and pass it to loadFromFinancialConfigData() method. * * @example * ```typescript * // In app initialization (e.g., after login) * // First, fetch financial config from your app's service * const response = await financialConfigService.getFinancialConfigById(...).toPromise(); * if (response?.success && response?.data) { * currencyService.loadFromFinancialConfigData(response.data); * } * * // In component * const formatted = currencyService.format(1000); // "₹1,000.00" * * // Override for specific use case * const formatted = currencyService.format(1000, { currencySymbol: '$' }); * ``` */ declare class CurrencyService { private readonly configSignal; private readonly overrideSignal; readonly loading: _angular_core.WritableSignal; readonly error: _angular_core.WritableSignal; readonly config: _angular_core.Signal; readonly currencySymbol: _angular_core.Signal; readonly currencyCode: _angular_core.Signal; constructor(); /** * Set currency configuration * @param config - Currency configuration to set */ setConfig(config: CurrencyConfig): void; /** * Update currency configuration (partial update) * @param updates - Partial currency configuration */ updateConfig(updates: Partial): void; /** * Set temporary override (takes precedence over base config) * @param override - Partial currency configuration to override */ setOverride(override: Partial | null): void; /** * Clear override (revert to base config) */ clearOverride(): void; /** * Load currency configuration from financial config data * This method accepts financial config data that should be fetched by the app * The app is responsible for calling the API and passing the data here * * @param financialConfigData - Financial config data object from accounts library * @example * ```typescript * // In your app, fetch financial config first * const financialConfig = await financialConfigService.getFinancialConfigById(...); * // Then pass it to currency service * currencyService.loadFromFinancialConfigData(financialConfig.data); * ``` */ loadFromFinancialConfigData(financialConfigData: any): void; /** * Map financial config data to currency config * This method expects the financial config data structure from accounts library */ private mapFinancialConfigToCurrencyConfig; /** * Get locale based on currency code */ private getLocaleFromCurrency; /** * Format a number as currency * @param value - Number to format * @param override - Optional override configuration * @returns Formatted currency string */ format(value: number | string | null | undefined, override?: Partial): string; /** * Format number with currency configuration */ private formatNumber; /** * Load configuration from localStorage */ private loadFromLocalStorage; /** * Save configuration to localStorage */ private saveToLocalStorage; /** * Reset to default configuration */ reset(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Directive to display images from file manager by ID * Usage: */ 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; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class CideFormFieldErrorComponent implements OnInit, OnChanges { control: AbstractControl; formGroup: FormGroup; fieldName: string; customMessages: { [key: string]: string; }; private fieldLabelsMap; private elementService; formErrors: _angular_core.WritableSignal; ngOnInit(): void; ngOnChanges(changes: SimpleChanges): void; private setupFormChangeListener; private updateFormErrors; private loadFormErrors; isFormGroupMode(): boolean; getFormGroupErrors(): Promise; private buildFieldLabelsMap; getFormGroupErrorMessage(): string; getControlErrorMessage(control: AbstractControl, fieldName: string): string; getErrorMessage(): string; private getFieldDisplayName; private convertToDisplayName; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CideEleConfirmationModalComponent implements OnInit, OnDestroy { private readonly confirmationService; readonly hasActiveConfirmation: _angular_core.Signal; readonly currentRequest: _angular_core.WritableSignal | null>; readonly customData: _angular_core.WritableSignal; ngOnInit(): void; ngOnDestroy(): void; readonly getHeaderClass: _angular_core.Signal; readonly getIconClass: _angular_core.Signal; readonly getConfirmButtonClass: _angular_core.Signal; onBackdropClick(event: Event): void; onCancel(): void; onConfirm(): void; updateCustomData(data: unknown): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CideEleGlobalNotificationsComponent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CideEleToastNotificationComponent { private notificationService; activeNotifications: _angular_core.Signal; getToastClass(notification: NotificationItem): string; getIconClass(type: string): string; removeNotification(id: string): void; executeUndo(id: string): void; trackByNotification(index: number, notification: NotificationItem): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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; dataValueGetter?: string; formatter?: GridFormatter; actions?: GridAction[]; statusConfig?: StatusConfig; filterable?: boolean; filterType?: 'text' | 'number' | 'date' | 'select' | 'custom'; filterOptions?: Array<{ label: string; value: unknown; }>; filterRenderer?: string; groupable?: boolean; aggregatable?: boolean; aggregationType?: 'sum' | 'avg' | 'count' | 'min' | 'max'; resizable?: boolean; hideable?: boolean; hidden?: boolean; } 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 GridColumnMenuConfig { enabled: boolean; showSort?: boolean; showFilter?: boolean; showAutosize?: boolean; showGroupBy?: boolean; showManageColumns?: boolean; showResetColumns?: boolean; showHideColumn?: boolean; showAggregation?: boolean; } interface ColumnFilter { columnKey: string; value: unknown; operator?: 'equals' | 'contains' | 'startsWith' | 'endsWith' | 'gt' | 'lt' | 'gte' | 'lte' | 'in'; } interface ColumnSort { columnKey: string; direction: 'asc' | 'desc'; } interface ColumnGroup> { columnKey: string; groups: Map; } interface GridConfiguration> { 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; columnMenu?: GridColumnMenuConfig; 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> { currentPage: number; pageSize: number; totalItems: number; totalPages: number; searchQuery: string; sortColumn?: string; sortDirection?: 'asc' | 'desc'; loading: boolean; isRefreshing: boolean; selectedRows: T[]; } interface GridEvent> { type: 'rowClick' | 'sort' | 'pageChange' | 'search' | 'refresh' | 'export' | 'action' | 'rowReorder' | 'columnFilter' | 'columnSort' | 'columnAutosize' | 'columnGroupBy' | 'columnHide' | 'columnShow' | 'columnReset' | 'columnAggregation' | 'manageColumns'; data: T | T[] | string | number | null | { sourceItem: T; sourceIndex: number; targetItem: T; targetIndex: number; newOrder: T[]; allOrders?: T[]; } | ColumnFilter | ColumnFilter[] | ColumnSort | { columnKey: string; aggregationType: string; }; column?: GridColumn; action?: GridAction; filters?: ColumnFilter[]; sorts?: ColumnSort[]; } declare const DEFAULT_GRID_CONFIG: Partial; type GridEventHandler> = (event: GridEvent) => void; type GridCustomRenderer> = (value: unknown, row: T, column: GridColumn) => string; type GridCustomFormatter = (value: unknown, format?: string) => string; interface TemplateContext> { $implicit: unknown; row: T; value: unknown; column: GridColumn; } type TemplateRenderer> = TemplateRef>; declare class CideEleDataGridComponent> implements OnInit, OnChanges, OnDestroy { config: GridConfiguration; templateRenderers: Record; customFormatters: Record string>; actionHandlers: Record void>; serverSidePagination: boolean; totalServerItems: number; currentServerPage: number; currentServerPageSize: number; dragDropEnabled: boolean; gridEvent: EventEmitter>; private internalData; private filteredData; currentPage: _angular_core.WritableSignal; pageSize: _angular_core.WritableSignal; totalItems: _angular_core.WritableSignal; totalPages: _angular_core.WritableSignal; searchQuery: _angular_core.WritableSignal; loading: _angular_core.WritableSignal; isRefreshing: _angular_core.WritableSignal; pageChangeLoading: _angular_core.WritableSignal; jumpToPage: number; isDragOverRow: number | null; isDragging: _angular_core.WritableSignal; hasOrderChanged: _angular_core.WritableSignal; private originalOrderIds; private initialDataOrderIds; private rowOrderMap; private localReorderedData; private searchDebounceTimer?; private isDataUpdate; openColumnMenu: _angular_core.WritableSignal; columnFilters: _angular_core.WritableSignal; columnSorts: _angular_core.WritableSignal; hiddenColumns: _angular_core.WritableSignal; showFilterPanel: _angular_core.WritableSignal; filterSearchTerm: _angular_core.WritableSignal; showManageColumnsModal: _angular_core.WritableSignal; groupedColumns: _angular_core.WritableSignal; expandedGroups: _angular_core.WritableSignal>; private hasAutoExpandedGroups; showExportMenu: _angular_core.WritableSignal; showFilterDropdown: _angular_core.WritableSignal; private exportService; hasNextPage: _angular_core.Signal; hasPreviousPage: _angular_core.Signal; mergedConfig: _angular_core.WritableSignal>; visibleColumns: _angular_core.Signal; ngOnInit(): void; ngOnDestroy(): void; private handleKeyDown; private handleGlobalClick; 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; /** * Initialize default grouping for columns with groupable: true * Only groups visible columns (not hidden ones) */ private initializeDefaultGrouping; /** * Check if groups should be auto-expanded (only on initial load) */ private shouldAutoExpandGroups; /** * 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; /** * Apply sorting to filtered data */ private applySortsToData; /** * 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 */ 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; /** * Flatten tree structure for grouping while preserving parent-child relationships */ private flattenTreeForGrouping; /** * Restore tree structure within grouped data * This method processes grouped data and restores parent-child relationships */ private restoreTreeStructureInGroups; /** * 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 | string[]): 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) * 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) */ 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; toggleColumnMenu(columnKey: string, event?: Event): void; closeColumnMenu(): void; isColumnMenuOpen(columnKey: string): boolean; onColumnSort(column: GridColumn, direction: 'asc' | 'desc'): void; onColumnFilter(column: GridColumn, value: unknown, operator?: ColumnFilter['operator']): void; onColumnAutosize(column: GridColumn): void; onColumnGroupBy(column: GridColumn): void; toggleGroupExpansion(groupKey: string): void; isGroupExpanded(groupKey: string): boolean; private expandAllGroupsForColumn; onColumnHide(column: GridColumn): void; onColumnShow(columnKey: string): void; onColumnReset(): void; onColumnAggregation(column: GridColumn, aggregationType: 'sum' | 'avg' | 'count' | 'min' | 'max'): void; onManageColumns(): void; closeManageColumnsModal(): void; toggleColumnVisibility(columnKey: string): void; isColumnHidden(columnKey: string): boolean; getColumnFilterValue(columnKey: string): unknown; getColumnSortDirection(columnKey: string): 'asc' | 'desc' | null; isColumnFiltered(columnKey: string): boolean; getActiveFilterCount(columnKey: string): number; toggleFilterPanel(columnKey: string, event?: Event): void; closeFilterPanel(): void; isFilterPanelOpen(columnKey: string): boolean; getUniqueColumnValues(column: GridColumn): Array<{ value: unknown; label: string; count: number; checked: boolean; }>; /** * Extract value from row for template columns when column.key doesn't exist * Tries common field patterns based on column key */ private extractValueFromRowForTemplateColumn; /** * Get a stable key for filter value comparison * Handles objects by using trackBy/primaryKey or JSON stringification */ getFilterValueKey(value: unknown): string; formatFilterValue(value: unknown, column: GridColumn): string; toggleFilterValue(column: GridColumn, value: unknown, checked: boolean): void; selectAllFilterValues(column: GridColumn): void; deselectAllFilterValues(column: GridColumn): void; applyFiltersToData(data?: T[]): 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; /** * Extract ID from foreign key value generically * Handles both string IDs and nested objects (e.g., { _id: "...", name: "..." }) * @param foreignKeyValue - The foreign key value (can be string, object, or null/undefined) * @param primaryKey - The primary key field name (from tree config or defaults to trackBy or '_id') * @returns The extracted ID as a string, or empty string if not found */ private extractIdFromForeignKey; /** * 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; isTemplateRenderer(rendererKey: string): boolean; getTemplateRenderer(rendererKey: string): TemplateRenderer | null; getTemplateContext(value: unknown, row: T, column: GridColumn): TemplateContext; getColumnWidthClass(width?: ColumnWidth): string; getColumnMaxWidthClass(width?: ColumnWidth): string; getColumnWidthStyle(width?: ColumnWidth): string | null; getColumnMaxWidthStyle(width?: ColumnWidth): string | null; 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[]; /** * Group data by specified columns (supports nested grouping) */ private getGroupedData; /** * Recursively group data by columns (nested grouping support) */ private groupDataRecursive; /** * Get the group value for a row (helper for checking if parent and children are in same group) */ private getGroupValueForRow; /** * Get the group path for nested grouping display (internal method) */ private buildGroupPath; getGroupValue(columnKey: string): unknown; isGroupHeader(row: T): boolean; getGroupRowCount(row: T): number; getGroupColumnKey(row: T): string; getGroupLevel(row: T): number; getGroupKey(item: T): string; getGroupColumn(item: T): GridColumn | null; getGroupColumnHeader(item: T): string; getGroupValueDisplay(item: T): string; getGroupPath(item: T): unknown[]; 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; /** * Toggle export menu visibility */ toggleExportMenu(event?: Event): void; /** * Close export menu */ closeExportMenu(): void; /** * Toggle filter dropdown visibility */ toggleFilterDropdown(event?: Event): void; /** * Clear all filters */ clearAllFilters(): void; /** * Get column header by key */ getColumnHeader(columnKey: string): string; /** * Remove a specific filter */ removeFilter(columnKey: string): void; /** * Check if value is an array (helper for template) */ isArray(value: unknown): boolean; /** * Get array length (helper for template) */ getArrayLength(value: unknown): number; /** * Handle export format selection */ exportData(format: 'csv' | 'excel' | 'pdf'): void; /** * Format value for export - extracts display text from objects */ private formatExportValue; static ɵfac: _angular_core.ɵɵFactoryDeclaration, never>; static ɵcmp: _angular_core.ɵɵComponentDeclaration, "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 { 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; minWidth?: number; usePortal?: boolean; } 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 portalService; private viewContainerRef; private dropdownId; private portalId; dropdownContainer: _angular_core.Signal>; dropdownMenu: _angular_core.Signal | undefined>; dropdownMenuTemplate: _angular_core.Signal | undefined>; set items(value: DropdownItem[]); get items(): DropdownItem[]; private _items; config: DropdownConfig; triggerTemplate?: TemplateRef<{ $implicit: boolean; }>; menuTemplate?: TemplateRef<{ $implicit: DropdownItem[]; }>; itemClick: EventEmitter; dropdownToggle: EventEmitter; isOpen: _angular_core.WritableSignal; currentPosition: _angular_core.WritableSignal; ngOnInit(): 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; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface FloatingContainerConfig { id: string; title: string; icon?: string; backdrop?: boolean; 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]: Signal; }; outputs?: { [key: string]: (event: Signal) => void; }; }; } declare class CideEleFloatingContainerComponent implements AfterViewInit, OnDestroy { config: _angular_core.WritableSignal; isMinimized: Signal; isMaximized: Signal; isVisible: Signal; zIndex: Signal; closeEvent: EventEmitter; minimizeEvent: EventEmitter; maximizeEvent: EventEmitter; clickEvent: EventEmitter; containerRef: ElementRef; position: _angular_core.WritableSignal<{ x: number; y: number; }>; isDragging: _angular_core.WritableSignal; isResizing: _angular_core.WritableSignal; computedConfig: Signal; 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; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface FloatingComponentConfig { componentId: string; componentType?: Type; 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; minimizedContainers: _angular_core.Signal; maximizedContainers: _angular_core.Signal; 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): void; /** * Unregister a component */ unregisterComponent(componentId: string): void; /** * Get registered component type */ getComponentType(componentId: string): Type | 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 | 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; /** * Get minimized signal for a container */ getMinimizedSignal(containerId: string): _angular_core.Signal; /** * Get maximized signal for a container */ getMaximizedSignal(containerId: string): _angular_core.Signal; getZIndexSignal(containerId: string): _angular_core.Signal; /** * 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; /** * Get component config for dynamic loading */ getComponentConfig(config: FloatingContainerConfig): { componentId: string; inputs: { [key: string]: _angular_core.Signal; } | undefined; outputs: { [key: string]: (event: _angular_core.Signal) => 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; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class CideEleFloatingContainerManagerComponent { containerService: CideEleFloatingContainerService; visibleContainers: _angular_core.Signal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } 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): 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): string; showMultipleInstances(componentId: string, titlePrefix: string, count: number, config?: Partial): 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; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } 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; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } 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: _angular_core.WritableSignal; showCharacterCount: boolean; config: JsonEditorConfig; configSignal: _angular_core.WritableSignal; valueChange: EventEmitter; objectChange: EventEmitter; errorsChange: EventEmitter; validChange: EventEmitter; jsonTextarea: _angular_core.Signal>; private destroyRef; jsonString: _angular_core.WritableSignal; jsonObject: _angular_core.WritableSignal; errors: _angular_core.WritableSignal; editorId: string; hasErrors: _angular_core.Signal; isValid: _angular_core.Signal; lineNumbers: _angular_core.Signal; containerClass: _angular_core.Signal; 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: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class CideEleSkeletonLoaderComponent { width: string; height: string; borderRadius: string; count: number; circle: boolean; animation: 'pulse' | 'wave' | 'none'; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } export { CapitalizePipe, CideCoreFileManagerService, CideEleBreadcrumbComponent, CideEleButtonComponent, CideEleConfirmationModalComponent, CideEleDataGridComponent, CideEleDropdownComponent, CideEleFileImageDirective, CideEleFileInputComponent, CideEleFileManagerService, CideEleFloatingContainerComponent, CideEleFloatingContainerDynamicDirective, CideEleFloatingContainerManagerComponent, CideEleFloatingContainerService, CideEleFloatingFeaturesService, CideEleFloatingFileUploaderComponent, CideEleFloatingFileUploaderService, CideEleGlobalNotificationsComponent, CideEleJsonEditorComponent, CideEleResizerDirective, CideEleSkeletonLoaderComponent, CideEleTabComponent, CideEleThemeToggleComponent, CideEleToastNotificationComponent, CideElementsService, CideFormFieldErrorComponent, CideIconComponent, CideInputComponent, CideSelectComponent, CideSelectOptionComponent, CideSpinnerComponent, CideTextareaComponent, CideThemeService, ConfirmationService, CoreFileManagerInsertUpdatePayload, CurrencyPipe, CurrencyService, DEFAULT_CURRENCY_CONFIG, DEFAULT_GRID_CONFIG, DropdownManagerService, ExportService, ICoreCyfmSave, KeyboardShortcutService, MFileManager, NotificationApiService, NotificationService, PortalService, TooltipDirective, WebSocketNotificationService, cidePath, hostManagerRoutesUrl, notificationRoutesUrl }; export type { BreadcrumbConfig, BreadcrumbDropdownOption, BreadcrumbItem, BreadcrumbSeparator, BreadcrumbStyle, ButtonElevation, ButtonShape, ButtonSize, ButtonType, ButtonVariant, CideEleResizerDirection, CideEleResizerDirectionTo, CideTheme, CideThemeConfig, ColumnFilter, ColumnGroup, ColumnSort, ColumnType, ColumnWidth, ConfirmationOptions, ConfirmationRequest, ConnectionStatus, CoreFileManagerInsertUpdateResponse, CreateNotificationDto, CurrencyConfig, CurrencyDisplayFormat, DropdownConfig, DropdownInstance, DropdownItem, DropdownPosition, ErrorValidationStatus, FileUploadData, FileUploadOptions, FileUploaderData, FloatingComponentConfig, FloatingContainerConfig, FloatingContainerInstance, FloatingFileUploaderData, GridAction, GridColumn, GridColumnMenuConfig, 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, NotificationListResponse, NotificationOptions, NotificationPayload, NotificationResponse, PortalConfig, PortalPosition, SelectOption, SelectOptionObject, ServerNotification, ServiceState, ShortcutOverride, StatusConfig, TabItem, TemplateContext, TemplatePortalConfig, TemplateRenderer, TextAlign, TooltipPlacement, TooltipType, UnreadCountResponse, UploadProgress, ValidationStatus, controllerResponse, fileManagerControllerResponse, fileManagerResponseData, mongooseObjectIdCreateControllerResponse };