cloud-ide-element 0.0.1 → 1.0.0

package/lib/components/confirmation-modal/confirmation-modal.component.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+export declare class CideEleConfirmationModalComponent {
+    private confirmationService;
+    hasActiveConfirmation: import("@angular/core").Signal<boolean>;
+    currentRequest: import("@angular/core").WritableSignal<import("../../services/confirmation.service").ConfirmationRequest<unknown> | null>;
+    customData: import("@angular/core").WritableSignal<unknown>;
+    getHeaderClass: import("@angular/core").Signal<string>;
+    getIconClass: import("@angular/core").Signal<"success" | "danger" | "warning" | "info">;
+    getConfirmButtonClass: import("@angular/core").Signal<string>;
+    onBackdropClick(event: Event): void;
+    onCancel(): void;
+    onConfirm(): void;
+    updateCustomData(data: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleConfirmationModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleConfirmationModalComponent, "cide-ele-confirmation-modal", never, {}, {}, never, never, true, never>;
+}

package/lib/components/data-grid/data-grid.component.d.ts

@@ -0,0 +1,244 @@
+import { EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges, TemplateRef } from '@angular/core';
+import { GridConfiguration, GridColumn, GridEvent, GridAction, ColumnWidth, StatusConfig } from './data-grid.types';
+import { inputType } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+export interface TemplateContext<T = Record<string, unknown>> {
+    $implicit: unknown;
+    row: T;
+    value: unknown;
+    column: GridColumn;
+}
+export type TemplateRenderer<T = Record<string, unknown>> = TemplateRef<TemplateContext<T>>;
+export type StringRenderer<T = Record<string, unknown>> = (value: unknown, row: T) => string;
+export type Renderer<T = Record<string, unknown>> = StringRenderer<T> | TemplateRenderer<T>;
+export declare class CideEleDataGridComponent<T = Record<string, unknown>> implements OnInit, OnChanges, OnDestroy {
+    config: GridConfiguration<T>;
+    customRenderers: Record<string, StringRenderer<T>>;
+    templateRenderers: Record<string, unknown>;
+    customFormatters: Record<string, (value: unknown, format?: string) => string>;
+    actionHandlers: Record<string, (data: T, action?: GridAction) => void>;
+    serverSidePagination: boolean;
+    totalServerItems: number;
+    currentServerPage: number;
+    currentServerPageSize: number;
+    dragDropEnabled: boolean;
+    gridEvent: EventEmitter<GridEvent<T>>;
+    private internalData;
+    private filteredData;
+    currentPage: import("@angular/core").WritableSignal<number>;
+    pageSize: import("@angular/core").WritableSignal<number>;
+    totalItems: import("@angular/core").WritableSignal<number>;
+    totalPages: import("@angular/core").WritableSignal<number>;
+    searchQuery: import("@angular/core").WritableSignal<string>;
+    loading: import("@angular/core").WritableSignal<boolean>;
+    isRefreshing: import("@angular/core").WritableSignal<boolean>;
+    pageChangeLoading: import("@angular/core").WritableSignal<boolean>;
+    jumpToPage: number;
+    isDragOverRow: number | null;
+    isDragging: import("@angular/core").WritableSignal<boolean>;
+    hasOrderChanged: import("@angular/core").WritableSignal<boolean>;
+    private originalOrderIds;
+    private initialDataOrderIds;
+    private rowOrderMap;
+    private localReorderedData;
+    private searchDebounceTimer?;
+    private isDataUpdate;
+    hasNextPage: import("@angular/core").Signal<boolean>;
+    hasPreviousPage: import("@angular/core").Signal<boolean>;
+    mergedConfig: import("@angular/core").WritableSignal<GridConfiguration<T>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Check if the config change is only a data update
+     */
+    private isDataOnlyUpdate;
+    /**
+     * Update only the data without triggering full grid re-initialization
+     * This prevents the search input and other UI state from being reset
+     */
+    private updateDataOnly;
+    private mergeConfigWithDefaults;
+    private initializeGrid;
+    /**
+     * Get the unique identifier for an item
+     */
+    private getItemId;
+    /**
+     * Get the order value for an item from the config
+     */
+    private getItemOrder;
+    /**
+     * Initialize the original order for drag and drop
+     */
+    private initializeOriginalOrder;
+    /**
+     * Refresh order tracking with current data (called when data updates)
+     */
+    private refreshOrderTracking;
+    private applyFilters;
+    /**
+     * Transform flat data to tree structure based on foreign key relationships
+     */
+    private transformToTree;
+    /**
+     * Recursively calculate item level in hierarchy for unlimited depth support
+     */
+    private calculateItemLevel;
+    /**
+     * Flatten tree structure for display, respecting expansion state with unlimited nesting
+     */
+    private flattenTreeForDisplay;
+    /**
+     * Toggle expand/collapse state of a tree item with unlimited nesting support
+     */
+    private toggleTreeExpand;
+    private updatePaginationState;
+    onPageChange(page: number | string): void;
+    onPageSizeChange(): void;
+    updatePageSize(value: string | number): void;
+    previousPage(): void;
+    nextPage(): void;
+    onJumpToPage(): void;
+    getEnhancedPageNumbers(): (number | string)[];
+    updateSearchQuery(value: inputType): void;
+    onSearch(): void;
+    onRefresh(): void;
+    setRefreshing(isRefreshing: boolean): void;
+    clearPageChangeLoading(): void;
+    /**
+     * Check if tree view is enabled
+     */
+    isTreeEnabled(): boolean;
+    /**
+     * Get tree configuration
+     */
+    getTreeConfig(): import("./data-grid.types").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(): import("./data-grid.types").GridDragDropConfig | undefined;
+    /**
+     * Handle drag start event
+     */
+    onDragStart(event: DragEvent, item: T, index: number): void;
+    /**
+     * Handle drag over event
+     */
+    onDragOver(event: DragEvent): void;
+    /**
+     * Handle drag leave event
+     */
+    onDragLeave(event: DragEvent): void;
+    /**
+     * Handle drop event
+     */
+    onDrop(event: DragEvent, targetItem: T, targetIndex: number): void;
+    /**
+     * Handle drag end event
+     */
+    onDragEnd(event: DragEvent): void;
+    /**
+     * Calculate new order after reordering
+     */
+    private getNewOrder;
+    /**
+     * Get the current order number for a specific item
+     */
+    getCurrentOrderNumber(item: T): number;
+    /**
+     * Update the row order map with new positions after reordering
+     */
+    private updateRowOrderMap;
+    /**
+     * Check if any row has changed position by comparing old vs new positions
+     */
+    private checkIfOrderChanged;
+    /**
+     * Reset the row order map to original positions (for reset action)
+     */
+    private resetRowOrderMap;
+    /**
+     * Update the row order map baseline to current positions (for save action)
+     */
+    private updateRowOrderMapBaseline;
+    /**
+     * Get the current order array from the row order map
+     */
+    private getCurrentOrderFromMap;
+    /**
+     * Update local data order for visual reordering (LOCAL ONLY)
+     */
+    private updateLocalDataOrder;
+    /**
+     * Check if the current order has changed from the initial order
+     */
+    private checkOrderChanged;
+    onRowClick(item: T): void;
+    onActionClick(item: T, action: GridAction): void;
+    private emitEvent;
+    /**
+     * Get nested value from an object
+     * @param obj - The object to get the nested value from
+     * @param path - The path to the nested value (e.g., 'contact.email')
+     * @returns The nested value or undefined if not found
+     * @example
+     * const obj = { contact: { email: 'test@example.com' } };
+     * const value = getNestedValue(obj, 'contact.email');
+     * // value === 'test@example.com'
+     */
+    getNestedValue(obj: T, path: string): unknown;
+    formatValue(value: unknown, column: GridColumn): string;
+    private formatDate;
+    private formatCurrency;
+    private formatPercentage;
+    renderCustomCell(value: unknown, row: T, column: GridColumn): string;
+    isTemplateRenderer(rendererKey: string): boolean;
+    isStringRenderer(rendererKey: string): boolean;
+    getTemplateRenderer(rendererKey: string): TemplateRenderer<T> | null;
+    getStringRenderer(rendererKey: string): StringRenderer<T> | null;
+    getTemplateContext(value: unknown, row: T, column: GridColumn): TemplateContext<T>;
+    getColumnWidthClass(width?: ColumnWidth): string;
+    getColumnMaxWidthClass(width?: ColumnWidth): string;
+    getStatusClass(value: unknown, statusConfig?: StatusConfig): string;
+    getStatusText(value: unknown, statusConfig?: StatusConfig): string;
+    getItemRangeText(): string;
+    getPageSizeOptions(): {
+        value: number;
+        label: string;
+    }[];
+    trackByFn(index: number, item: T): unknown;
+    getSkeletonArray(): number[];
+    get displayedData(): T[];
+    get columns(): GridColumn[];
+    get paginationConfig(): import("./data-grid.types").GridPaginationConfig;
+    get searchConfig(): import("./data-grid.types").GridSearchConfig;
+    get loadingConfig(): import("./data-grid.types").GridLoadingConfig;
+    get scrollConfig(): import("./data-grid.types").GridScrollConfig | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleDataGridComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleDataGridComponent<any>, "cide-ele-data-grid", never, { "config": { "alias": "config"; "required": false; }; "customRenderers": { "alias": "customRenderers"; "required": false; }; "templateRenderers": { "alias": "templateRenderers"; "required": false; }; "customFormatters": { "alias": "customFormatters"; "required": false; }; "actionHandlers": { "alias": "actionHandlers"; "required": false; }; "serverSidePagination": { "alias": "serverSidePagination"; "required": false; }; "totalServerItems": { "alias": "totalServerItems"; "required": false; }; "currentServerPage": { "alias": "currentServerPage"; "required": false; }; "currentServerPageSize": { "alias": "currentServerPageSize"; "required": false; }; "dragDropEnabled": { "alias": "dragDropEnabled"; "required": false; }; }, { "gridEvent": "gridEvent"; }, never, never, true, never>;
+}

package/lib/components/data-grid/data-grid.types.d.ts

@@ -0,0 +1,146 @@
+export type ColumnType = 'text' | 'number' | 'date' | 'boolean' | 'status' | 'actions' | 'custom' | 'order';
+export type ColumnWidth = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto' | string;
+export type TextAlign = 'left' | 'center' | 'right';
+export interface GridColumn {
+    key: string;
+    header: string;
+    type: ColumnType;
+    width?: ColumnWidth;
+    sortable?: boolean;
+    searchable?: boolean;
+    truncate?: boolean;
+    align?: TextAlign;
+    renderer?: string;
+    valueGetter?: string;
+    formatter?: GridFormatter;
+    actions?: GridAction[];
+    statusConfig?: StatusConfig;
+}
+export interface GridFormatter {
+    type: 'date' | 'currency' | 'percentage' | 'custom';
+    format?: string;
+    customFunction?: string;
+}
+export interface StatusConfig {
+    activeValue: string | number | boolean;
+    activeLabel: string;
+    inactiveLabel: string;
+    activeClass: string;
+    inactiveClass: string;
+}
+export interface GridAction {
+    key: string;
+    label: string;
+    icon: string;
+    variant: 'ghost' | 'primary' | 'outline' | 'danger';
+    tooltip?: string;
+    condition?: string;
+    onClick: string;
+}
+export interface GridPaginationConfig {
+    enabled: boolean;
+    pageSize: number;
+    pageSizeOptions: number[];
+    showQuickJump: boolean;
+    showPageInfo: boolean;
+    showRefresh: boolean;
+}
+export interface GridSearchConfig {
+    enabled: boolean;
+    placeholder: string;
+    searchableColumns: string[];
+    debounceMs?: number;
+}
+export interface GridExportConfig {
+    enabled: boolean;
+    formats: ('csv' | 'excel' | 'pdf')[];
+    filename?: string;
+}
+export interface GridLoadingConfig {
+    useDefer: boolean;
+    skeletonRows: number;
+    showOverlay: boolean;
+}
+export interface GridScrollConfig {
+    enabled: boolean;
+    maxHeight?: string;
+    minHeight?: string;
+    stickyHeader?: boolean;
+    virtualScroll?: boolean;
+    rowHeight?: number;
+}
+export interface GridTreeConfig {
+    enabled: boolean;
+    primaryKey: string;
+    foreignKey: string;
+    childrenKey?: string;
+    levelKey?: string;
+    expandedKey?: string;
+    hasChildrenKey?: string;
+}
+export interface GridDragDropConfig {
+    enabled: boolean;
+    dragHandle?: string;
+    orderField?: string;
+    dragClass?: string;
+    dropClass?: string;
+}
+export interface GridConfiguration<T = Record<string, unknown>> {
+    id: string;
+    title?: string;
+    subtitle?: string;
+    columns: GridColumn[];
+    data: T[];
+    trackBy?: string;
+    pagination: GridPaginationConfig;
+    search: GridSearchConfig;
+    export?: GridExportConfig;
+    loading: GridLoadingConfig;
+    scroll?: GridScrollConfig;
+    tree?: GridTreeConfig;
+    dragDrop?: GridDragDropConfig;
+    responsive: boolean;
+    striped?: boolean;
+    bordered?: boolean;
+    compact?: boolean;
+    fullHeight?: boolean;
+    onRowClick?: string;
+    onSort?: string;
+    onPageChange?: string;
+    onSearch?: string;
+    onRefresh?: string;
+    onExport?: string;
+    onRowReorder?: string;
+    tableClass?: string;
+    headerClass?: string;
+    rowClass?: string;
+    cellClass?: string;
+}
+export interface GridState<T = Record<string, unknown>> {
+    currentPage: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+    searchQuery: string;
+    sortColumn?: string;
+    sortDirection?: 'asc' | 'desc';
+    loading: boolean;
+    isRefreshing: boolean;
+    selectedRows: T[];
+}
+export interface GridEvent<T = Record<string, unknown>> {
+    type: 'rowClick' | 'sort' | 'pageChange' | 'search' | 'refresh' | 'export' | 'action' | 'rowReorder';
+    data: T | T[] | string | number | null | {
+        sourceItem: T;
+        sourceIndex: number;
+        targetItem: T;
+        targetIndex: number;
+        newOrder: T[];
+    };
+    column?: GridColumn;
+    action?: GridAction;
+}
+export declare const DEFAULT_GRID_CONFIG: Partial<GridConfiguration>;
+export type GridEventHandler<T = Record<string, unknown>> = (event: GridEvent<T>) => void;
+export type GridCustomRenderer<T = Record<string, unknown>> = (value: unknown, row: T, column: GridColumn) => string;
+export type GridCustomFormatter = (value: unknown, format?: string) => string;

package/lib/components/dropdown/dropdown.component.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter, TemplateRef, ElementRef, OnInit, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface DropdownItem {
+    id: string;
+    label: string;
+    icon?: string;
+    iconColor?: string;
+    textColor?: string;
+    hoverBgColor?: string;
+    disabled?: boolean;
+    divider?: boolean;
+}
+export 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;
+}
+export interface DropdownPosition {
+    vertical: 'top' | 'bottom';
+    horizontal: 'left' | 'right';
+    spaceAvailable: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+}
+export declare class CideEleDropdownComponent implements OnInit, OnDestroy {
+    private destroyRef;
+    private dropdownManager;
+    private dropdownId;
+    dropdownContainer: import("@angular/core").Signal<ElementRef<any>>;
+    dropdownMenu: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    set items(value: DropdownItem[]);
+    get items(): DropdownItem[];
+    private _items;
+    config: DropdownConfig;
+    triggerTemplate?: TemplateRef<{
+        $implicit: boolean;
+    }>;
+    menuTemplate?: TemplateRef<{
+        $implicit: DropdownItem[];
+    }>;
+    itemClick: EventEmitter<DropdownItem>;
+    dropdownToggle: EventEmitter<boolean>;
+    isOpen: import("@angular/core").WritableSignal<boolean>;
+    currentPosition: import("@angular/core").WritableSignal<DropdownPosition>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getTriggerClasses(): string;
+    getTriggerIconClasses(): string;
+    getMenuClasses(): string;
+    getMenuStyles(): string;
+    calculatePosition(): DropdownPosition;
+    private getMenuWidth;
+    private getEstimatedMenuHeight;
+    toggleDropdown(event: Event): void;
+    private openDropdown;
+    testMouseDown(item: DropdownItem): void;
+    onItemClick(item: DropdownItem, event: Event): void;
+    closeDropdown(): void;
+    getItemClasses(item: DropdownItem): string;
+    onWindowResize(): void;
+    onWindowScroll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleDropdownComponent, "cide-ele-dropdown", never, { "items": { "alias": "items"; "required": false; }; "config": { "alias": "config"; "required": false; }; "triggerTemplate": { "alias": "triggerTemplate"; "required": false; }; "menuTemplate": { "alias": "menuTemplate"; "required": false; }; }, { "itemClick": "itemClick"; "dropdownToggle": "dropdownToggle"; }, never, never, true, never>;
+}

package/lib/components/global-notifications/global-notifications.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class CideEleGlobalNotificationsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleGlobalNotificationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleGlobalNotificationsComponent, "cide-ele-global-notifications", never, {}, {}, never, never, true, never>;
+}

package/lib/components/json-editor/json-editor.component.d.ts

@@ -0,0 +1,116 @@
+import { EventEmitter, OnInit, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export 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;
+}
+export interface JsonEditorError {
+    line: number;
+    column: number;
+    message: string;
+    type: 'syntax' | 'validation';
+}
+export declare class CideEleJsonEditorComponent implements OnInit, ControlValueAccessor {
+    label?: string;
+    helperText?: string;
+    required: boolean;
+    disabled: import("@angular/core").WritableSignal<boolean>;
+    showCharacterCount: boolean;
+    config: JsonEditorConfig;
+    configSignal: import("@angular/core").WritableSignal<JsonEditorConfig>;
+    valueChange: EventEmitter<string>;
+    objectChange: EventEmitter<object | null>;
+    errorsChange: EventEmitter<JsonEditorError[]>;
+    validChange: EventEmitter<boolean>;
+    jsonTextarea: import("@angular/core").Signal<ElementRef<HTMLTextAreaElement>>;
+    private destroyRef;
+    jsonString: import("@angular/core").WritableSignal<string>;
+    jsonObject: import("@angular/core").WritableSignal<object | null>;
+    errors: import("@angular/core").WritableSignal<JsonEditorError[]>;
+    editorId: string;
+    hasErrors: import("@angular/core").Signal<boolean>;
+    isValid: import("@angular/core").Signal<boolean>;
+    lineNumbers: import("@angular/core").Signal<number[]>;
+    containerClass: import("@angular/core").Signal<string>;
+    private defaultConfig;
+    ngOnInit(): void;
+    /**
+     * Handle input changes
+     */
+    onInput(event: Event): void;
+    /**
+     * Handle blur event
+     */
+    onBlur(): void;
+    /**
+     * Parse JSON string and emit object
+     */
+    private parseJson;
+    /**
+     * Validate JSON and update errors
+     */
+    private validateJson;
+    /**
+     * Format JSON with proper indentation
+     */
+    formatJson(): void;
+    /**
+     * Check if there's an error on a specific line
+     */
+    hasErrorOnLine(line: number): boolean;
+    /**
+     * Get error ID for accessibility
+     */
+    errorId(): string;
+    /**
+     * Focus the editor
+     */
+    focus(): void;
+    /**
+     * Clear the editor
+     */
+    clear(): void;
+    /**
+     * Get current JSON object
+     */
+    getValue(): object | null;
+    /**
+     * Get current JSON string
+     */
+    getStringValue(): string;
+    /**
+     * Check if JSON is valid
+     */
+    isValidJson(): boolean;
+    /**
+     * Get validation errors
+     */
+    getErrors(): JsonEditorError[];
+    writeValue(value: string | object | null | undefined): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private onChange;
+    private onTouched;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleJsonEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleJsonEditorComponent, "cide-ele-json-editor", never, { "label": { "alias": "label"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showCharacterCount": { "alias": "showCharacterCount"; "required": false; }; "config": { "alias": "config"; "required": false; }; }, { "valueChange": "valueChange"; "objectChange": "objectChange"; "errorsChange": "errorsChange"; "validChange": "validChange"; }, never, never, true, never>;
+}

package/lib/components/skeleton-loader/skeleton-loader.component.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class CideEleSkeletonLoaderComponent {
+    width: string;
+    height: string;
+    borderRadius: string;
+    count: number;
+    circle: boolean;
+    animation: 'pulse' | 'wave' | 'none';
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleSkeletonLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleSkeletonLoaderComponent, "cide-ele-skeleton-loader", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "borderRadius": { "alias": "borderRadius"; "required": false; }; "count": { "alias": "count"; "required": false; }; "circle": { "alias": "circle"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/components/toast-notification/toast-notification.component.d.ts

@@ -0,0 +1,13 @@
+import { NotificationItem } from '../../services/notification.service';
+import * as i0 from "@angular/core";
+export declare class CideEleToastNotificationComponent {
+    private notificationService;
+    activeNotifications: import("@angular/core").Signal<NotificationItem[]>;
+    getToastClass(notification: NotificationItem): string;
+    getIconClass(type: string): string;
+    removeNotification(id: string): void;
+    executeUndo(id: string): void;
+    trackByNotification(index: number, notification: NotificationItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CideEleToastNotificationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CideEleToastNotificationComponent, "cide-ele-toast-notification", never, {}, {}, never, never, true, never>;
+}