ng-magary 0.0.5 → 0.0.7

package/types/ng-magary.d.ts

@@ -0,0 +1,2557 @@
+import * as _angular_core from '@angular/core';
+import { OnChanges, SimpleChanges, TemplateRef, EventEmitter, OnDestroy, ElementRef, AfterViewInit, OnInit, Renderer2, NgZone, ChangeDetectorRef } from '@angular/core';
+import * as i1 from '@angular/common';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { SafeUrl } from '@angular/platform-browser';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1$1 from 'lucide-angular';
+import * as i3 from '@angular/router';
+import * as ng_magary from 'ng-magary';
+import { AnimationEvent } from '@angular/animations';
+import * as rxjs from 'rxjs';
+import { GridStackOptions, GridStack } from 'gridstack';
+
+type ButtonSeverity = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'help';
+type ButtonVariant = 'solid' | 'text' | 'outlined';
+type ButtonSize = 'small' | 'normal' | 'large';
+type IconPosition = 'left' | 'right';
+type ShadowLevel$1 = 0 | 1 | 2 | 3 | 4 | 5;
+declare class MagaryButton {
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly shadow: _angular_core.InputSignal<ShadowLevel$1>;
+    readonly rounded: _angular_core.InputSignal<boolean>;
+    readonly customBackgroundColor: _angular_core.InputSignal<string | undefined>;
+    readonly iconPos: _angular_core.InputSignal<IconPosition>;
+    readonly severity: _angular_core.InputSignal<ButtonSeverity | undefined>;
+    readonly iconSize: _angular_core.InputSignal<number | undefined>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
+    readonly size: _angular_core.InputSignal<ButtonSize>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly buttonClick: _angular_core.OutputEmitterRef<Event>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    readonly buttonClasses: _angular_core.Signal<string[]>;
+    readonly buttonStyles: _angular_core.Signal<{
+        'border-radius': string;
+        background: string | undefined;
+    }>;
+    readonly effectiveAriaLabel: _angular_core.Signal<string>;
+    onButtonClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryButton, "magary-button", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "customBackgroundColor": { "alias": "customBackgroundColor"; "required": false; "isSignal": true; }; "iconPos": { "alias": "iconPos"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+
+declare class MagaryButtonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryButtonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryButtonModule, never, [typeof i1.CommonModule, typeof MagaryButton], [typeof MagaryButton]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryButtonModule>;
+}
+
+interface SpeedDialItem {
+    readonly icon: string;
+    readonly tooltip?: string;
+    readonly command?: (event?: Event) => void;
+    readonly id?: string;
+    readonly ariaLabel?: string;
+    readonly backgroundColor?: string;
+    readonly disabled?: boolean;
+}
+
+type SpeedDialType = 'linear' | 'circle' | 'semicircle' | 'quartercircle';
+type SpeedDialDirection = 'up' | 'down' | 'left' | 'right' | 'up-left' | 'up-right' | 'down-left' | 'down-right';
+declare class MagarySpeedDial {
+    private readonly elementRef;
+    readonly items: _angular_core.InputSignal<SpeedDialItem[]>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly activeIcon: _angular_core.InputSignal<string>;
+    readonly type: _angular_core.InputSignal<SpeedDialType>;
+    readonly direction: _angular_core.InputSignal<SpeedDialDirection | undefined>;
+    readonly radius: _angular_core.InputSignal<number>;
+    readonly showMask: _angular_core.InputSignal<boolean>;
+    readonly background: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly speedDialToggle: _angular_core.OutputEmitterRef<boolean>;
+    readonly itemSelect: _angular_core.OutputEmitterRef<{
+        item: SpeedDialItem;
+        event: Event;
+    }>;
+    readonly itemCount: _angular_core.Signal<number>;
+    readonly containerClasses: _angular_core.Signal<string[]>;
+    readonly triggerStyles: _angular_core.Signal<{
+        '--trigger-bg': string | null;
+    } | null>;
+    readonly itemsStyles: _angular_core.Signal<{
+        '--item-count': string;
+        '--radius': string;
+    }>;
+    readonly currentIcon: _angular_core.Signal<string>;
+    toggleSpeedDial(event: Event): void;
+    onItemClick(event: Event, item: SpeedDialItem): void;
+    closeMask(): void;
+    trackByItem(index: number, item: SpeedDialItem): string;
+    onDocumentClick(event: Event): void;
+    onEscapeKeydown(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySpeedDial, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySpeedDial, "magary-speed-dial", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "activeIcon": { "alias": "activeIcon"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "showMask": { "alias": "showMask"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "speedDialToggle": "speedDialToggle"; "itemSelect": "itemSelect"; }, never, never, true, never>;
+}
+
+declare class MagarySpeedDialModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySpeedDialModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagarySpeedDialModule, never, [typeof i1.CommonModule, typeof MagarySpeedDial], [typeof MagarySpeedDial]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagarySpeedDialModule>;
+}
+
+interface MenuItem {
+    label?: string;
+    icon?: string;
+    command?: (event?: any) => void;
+    url?: string;
+    routerLink?: any;
+    queryParams?: {
+        [k: string]: any;
+    };
+    items?: MenuItem[];
+    expanded?: boolean;
+    disabled?: boolean;
+    visible?: boolean;
+    target?: string;
+    separator?: boolean;
+    id?: string;
+    children?: MenuItem[];
+    badge?: string;
+    badgeSeverity?: 'success' | 'info' | 'warning' | 'danger' | 'contrast';
+    iconSize?: number;
+    styleClass?: string;
+    iconClass?: string;
+    route?: string;
+    metadata?: any;
+}
+
+declare class MagarySplitButton {
+    private readonly elementRef;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly iconSize: _angular_core.InputSignal<number>;
+    readonly model: _angular_core.InputSignal<MenuItem[]>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly styleClass: _angular_core.InputSignal<string>;
+    readonly onClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly onDropdownClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    toggleDropdown(event: MouseEvent): void;
+    onDefaultClick(event: MouseEvent): void;
+    onItemClick(event: MouseEvent, item: MenuItem): void;
+    onDocumentClick(event: Event): void;
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySplitButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySplitButton, "magary-split-button", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; "onDropdownClick": "onDropdownClick"; }, never, never, true, never>;
+}
+
+interface PaginatorState {
+    page: number;
+    first: number;
+    rows: number;
+    pageCount: number;
+}
+/**
+ * MagaryPaginator
+ *
+ * A component to handle data pagination.
+ *
+ * @example
+ * <magary-paginator [rows]="10" [totalRecords]="100" (onPageChange)="paginate($event)"></magary-paginator>
+ */
+declare class MagaryPaginator implements OnChanges {
+    /** Total number of records. */
+    totalRecords: _angular_core.InputSignal<number>;
+    /** Number of rows to display per page. */
+    rows: _angular_core.InputSignal<number>;
+    /** Index of the first record to display. */
+    first: _angular_core.InputSignal<number>;
+    /** Array of integers representing available options for rows per page. */
+    rowsPerPageOptions: _angular_core.InputSignal<number[]>;
+    /** Whether to show page links. */
+    showPageLinks: _angular_core.InputSignal<boolean>;
+    /** Number of page links to display. */
+    pageLinkSize: _angular_core.InputSignal<number>;
+    /** Event triggered when page changes. */
+    onPageChange: _angular_core.OutputEmitterRef<PaginatorState>;
+    /** Current page index (0-based). */
+    getPage: _angular_core.Signal<number>;
+    /** Total number of pages. */
+    getPageCount: _angular_core.Signal<number>;
+    /** Whether the first page is currently active. */
+    isFirstPage: _angular_core.Signal<boolean>;
+    /** Whether the last page is currently active. */
+    isLastPage: _angular_core.Signal<boolean>;
+    /** Calculate page links. */
+    getPageLinks: _angular_core.Signal<number[]>;
+    changePage(p: number): void;
+    changePageToFirst(event: Event): void;
+    changePageToPrev(event: Event): void;
+    changePageToNext(event: Event): void;
+    changePageToLast(event: Event): void;
+    onRppChange(event: any): void;
+    onPageLinkClick(event: Event, page: number): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryPaginator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryPaginator, "magary-paginator", never, { "totalRecords": { "alias": "totalRecords"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "first": { "alias": "first"; "required": false; "isSignal": true; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; "isSignal": true; }; "showPageLinks": { "alias": "showPageLinks"; "required": false; "isSignal": true; }; "pageLinkSize": { "alias": "pageLinkSize"; "required": false; "isSignal": true; }; }, { "onPageChange": "onPageChange"; }, never, [".left-content", ".right-content"], true, never>;
+}
+
+interface MagaryTableColumn {
+    field: string;
+    header: string;
+    type?: 'text' | 'avatar' | 'badge' | 'date' | 'currency';
+    sortable?: boolean;
+    width?: string;
+}
+declare class MagaryTable {
+    value: _angular_core.InputSignal<any[]>;
+    columns: _angular_core.InputSignal<MagaryTableColumn[]>;
+    paginator: _angular_core.InputSignal<boolean>;
+    rows: _angular_core.InputSignal<number>;
+    globalFilterFields: _angular_core.InputSignal<string[]>;
+    title: _angular_core.InputSignal<string>;
+    loading: _angular_core.InputSignal<boolean>;
+    responsiveLayout: _angular_core.InputSignal<boolean>;
+    rowsPerPageOptions: _angular_core.InputSignal<number[]>;
+    onPageChange: _angular_core.OutputEmitterRef<any>;
+    first: _angular_core.WritableSignal<number>;
+    searchTerm: _angular_core.WritableSignal<string>;
+    currentRows: _angular_core.WritableSignal<number>;
+    processedData: _angular_core.Signal<any[]>;
+    totalRecords: _angular_core.Signal<number>;
+    paginatedData: _angular_core.Signal<any[]>;
+    constructor();
+    onSearch(value: string): void;
+    onPaginatorChange(event: PaginatorState): void;
+    resolveFieldData(data: any, field: string): any;
+    getAvatarLabel(row: any): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTable, "magary-table", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "globalFilterFields": { "alias": "globalFilterFields"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "responsiveLayout": { "alias": "responsiveLayout"; "required": false; "isSignal": true; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; "isSignal": true; }; }, { "onPageChange": "onPageChange"; }, never, never, true, never>;
+}
+
+declare class MagaryTableModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTableModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryTableModule, never, [typeof MagaryTable], [typeof MagaryTable]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryTableModule>;
+}
+
+interface MagaryTreeNode {
+    label?: string;
+    header?: string;
+    data?: any;
+    icon?: string;
+    expandedIcon?: string;
+    collapsedIcon?: string;
+    children?: MagaryTreeNode[];
+    leaf?: boolean;
+    expanded?: boolean;
+    type?: string;
+    parent?: MagaryTreeNode;
+    partialSelected?: boolean;
+    styleClass?: string;
+    draggable?: boolean;
+    droppable?: boolean;
+    selectable?: boolean;
+    key?: string;
+}
+
+declare class MagaryTree {
+    value: _angular_core.InputSignal<MagaryTreeNode[]>;
+    selectionMode: _angular_core.InputSignal<"checkbox" | "single" | "multiple" | null>;
+    selection: _angular_core.InputSignal<any>;
+    filter: _angular_core.InputSignal<boolean>;
+    filterPlaceholder: _angular_core.InputSignal<string>;
+    filterMode: _angular_core.InputSignal<"lenient" | "strict">;
+    draggable: _angular_core.InputSignal<boolean>;
+    droppable: _angular_core.InputSignal<boolean>;
+    validateDrop: _angular_core.InputSignal<boolean>;
+    onNodeSelect: _angular_core.OutputEmitterRef<any>;
+    onNodeUnselect: _angular_core.OutputEmitterRef<any>;
+    onNodeExpand: _angular_core.OutputEmitterRef<any>;
+    onNodeCollapse: _angular_core.OutputEmitterRef<any>;
+    onNodeDrop: _angular_core.OutputEmitterRef<any>;
+    filterValue: _angular_core.WritableSignal<string>;
+    filteredValue: _angular_core.Signal<MagaryTreeNode[]>;
+    filterTree(nodes: MagaryTreeNode[], term: string): MagaryTreeNode[];
+    isNodeMatching(node: MagaryTreeNode, term: string): boolean;
+    onFilterInput(event: Event): void;
+    handleNodeSelect(event: any): void;
+    handleNodeUnselect(event: any): void;
+    handleNodeExpand(event: any): void;
+    handleNodeCollapse(event: any): void;
+    handleDrop(event: CdkDragDrop<MagaryTreeNode[]>, parent: MagaryTreeNode | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTree, "magary-tree", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "droppable": { "alias": "droppable"; "required": false; "isSignal": true; }; "validateDrop": { "alias": "validateDrop"; "required": false; "isSignal": true; }; }, { "onNodeSelect": "onNodeSelect"; "onNodeUnselect": "onNodeUnselect"; "onNodeExpand": "onNodeExpand"; "onNodeCollapse": "onNodeCollapse"; "onNodeDrop": "onNodeDrop"; }, never, never, true, never>;
+}
+
+declare class MagaryUITreeNode {
+    node: _angular_core.InputSignal<MagaryTreeNode>;
+    selectionMode: _angular_core.InputSignal<string | null>;
+    selection: _angular_core.InputSignal<any>;
+    draggable: _angular_core.InputSignal<boolean>;
+    droppable: _angular_core.InputSignal<boolean>;
+    nodeSelect: _angular_core.OutputEmitterRef<any>;
+    nodeUnselect: _angular_core.OutputEmitterRef<any>;
+    nodeExpand: _angular_core.OutputEmitterRef<any>;
+    nodeCollapse: _angular_core.OutputEmitterRef<any>;
+    nodeDrop: _angular_core.OutputEmitterRef<any>;
+    get isExpanded(): boolean | undefined;
+    get isLeaf(): boolean;
+    isSelected: _angular_core.Signal<boolean>;
+    getIcon(): string;
+    toggle(event: Event): void;
+    onNodeClick(event: Event): void;
+    onCheckboxClick(event: Event): void;
+    onDrop(event: CdkDragDrop<MagaryTreeNode[]>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryUITreeNode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryUITreeNode, "magary-uitree-node", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "droppable": { "alias": "droppable"; "required": false; "isSignal": true; }; }, { "nodeSelect": "nodeSelect"; "nodeUnselect": "nodeUnselect"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; "nodeDrop": "nodeDrop"; }, never, never, true, never>;
+}
+
+declare class MagaryTimeline {
+    value: _angular_core.InputSignal<any[]>;
+    layout: _angular_core.InputSignal<"vertical" | "horizontal">;
+    align: _angular_core.InputSignal<"left" | "right" | "top" | "bottom" | "alternate">;
+    contentTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    oppositeTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    markerTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTimeline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTimeline, "magary-timeline", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, ["contentTemplate", "oppositeTemplate", "markerTemplate"], never, true, never>;
+}
+
+declare class MagaryOrganizationChart {
+    readonly value: _angular_core.InputSignal<MagaryTreeNode[]>;
+    readonly selectionMode: _angular_core.InputSignal<string | null>;
+    readonly selection: _angular_core.InputSignal<any>;
+    readonly collapsible: _angular_core.InputSignal<boolean>;
+    readonly template: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly onNodeSelect: _angular_core.OutputEmitterRef<any>;
+    readonly onNodeUnselect: _angular_core.OutputEmitterRef<any>;
+    readonly onNodeExpand: _angular_core.OutputEmitterRef<any>;
+    readonly onNodeCollapse: _angular_core.OutputEmitterRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryOrganizationChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryOrganizationChart, "magary-organization-chart", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; }, { "onNodeSelect": "onNodeSelect"; "onNodeUnselect": "onNodeUnselect"; "onNodeExpand": "onNodeExpand"; "onNodeCollapse": "onNodeCollapse"; }, ["template"], never, true, never>;
+}
+
+declare class MagaryOrganizationChartNode {
+    readonly node: _angular_core.InputSignal<MagaryTreeNode>;
+    readonly selectionMode: _angular_core.InputSignal<string | null>;
+    readonly selection: _angular_core.InputSignal<any>;
+    readonly collapsible: _angular_core.InputSignal<boolean>;
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<any> | null | undefined>;
+    readonly template: _angular_core.Signal<TemplateRef<any> | null | undefined>;
+    readonly nodeSelect: _angular_core.OutputEmitterRef<any>;
+    readonly nodeUnselect: _angular_core.OutputEmitterRef<any>;
+    readonly nodeExpand: _angular_core.OutputEmitterRef<any>;
+    readonly nodeCollapse: _angular_core.OutputEmitterRef<any>;
+    internalExpanded: _angular_core.WritableSignal<boolean>;
+    constructor();
+    ngOnInit(): void;
+    isLeaf: _angular_core.Signal<boolean>;
+    colspan: _angular_core.Signal<number>;
+    isSelected: _angular_core.Signal<boolean>;
+    onNodeClick(event: Event): void;
+    toggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryOrganizationChartNode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryOrganizationChartNode, "[magary-organizationchart-node]", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; }, { "nodeSelect": "nodeSelect"; "nodeUnselect": "nodeUnselect"; "nodeExpand": "nodeExpand"; "nodeCollapse": "nodeCollapse"; }, never, never, true, never>;
+}
+
+declare class MagaryPickList {
+    sourceHeader: string;
+    targetHeader: string;
+    sourceStyle: {
+        [klass: string]: any;
+    } | null;
+    targetStyle: {
+        [klass: string]: any;
+    } | null;
+    showSourceControls: boolean;
+    showTargetControls: boolean;
+    source: _angular_core.ModelSignal<any[]>;
+    target: _angular_core.ModelSignal<any[]>;
+    selectedSource: _angular_core.WritableSignal<any[]>;
+    selectedTarget: _angular_core.WritableSignal<any[]>;
+    itemTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    onMoveToTarget: EventEmitter<any>;
+    onMoveToSource: EventEmitter<any>;
+    onMoveAllToTarget: EventEmitter<any>;
+    onMoveAllToSource: EventEmitter<any>;
+    moveRight(): void;
+    moveAllRight(): void;
+    moveLeft(): void;
+    moveAllLeft(): void;
+    onSourceItemClick(event: MouseEvent, item: any): void;
+    onTargetItemClick(event: MouseEvent, item: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryPickList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryPickList, "magary-pick-list", never, { "sourceHeader": { "alias": "sourceHeader"; "required": false; }; "targetHeader": { "alias": "targetHeader"; "required": false; }; "sourceStyle": { "alias": "sourceStyle"; "required": false; }; "targetStyle": { "alias": "targetStyle"; "required": false; }; "showSourceControls": { "alias": "showSourceControls"; "required": false; }; "showTargetControls": { "alias": "showTargetControls"; "required": false; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; }, { "source": "sourceChange"; "target": "targetChange"; "onMoveToTarget": "onMoveToTarget"; "onMoveToSource": "onMoveToSource"; "onMoveAllToTarget": "onMoveAllToTarget"; "onMoveAllToSource": "onMoveAllToSource"; }, ["itemTemplate"], never, true, never>;
+}
+
+declare class MagaryOrderList {
+    header: string | null;
+    listStyle: {
+        [klass: string]: any;
+    } | null;
+    value: _angular_core.ModelSignal<any[]>;
+    selection: _angular_core.ModelSignal<any[]>;
+    itemTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    onReorder: EventEmitter<any>;
+    onSelectionChange: EventEmitter<any>;
+    onItemClick(event: MouseEvent, item: any, index: number): void;
+    moveUp(): void;
+    moveTop(): void;
+    moveDown(): void;
+    moveBottom(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryOrderList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryOrderList, "magary-order-list", never, { "header": { "alias": "header"; "required": false; }; "listStyle": { "alias": "listStyle"; "required": false; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selection": "selectionChange"; "onReorder": "onReorder"; "onSelectionChange": "onSelectionChange"; }, ["itemTemplate"], never, true, never>;
+}
+
+declare class MagaryDataView {
+    listItemTemplate: TemplateRef<any>;
+    gridItemTemplate: TemplateRef<any>;
+    headerTemplate: TemplateRef<any>;
+    footerTemplate: TemplateRef<any>;
+    set value(val: any[]);
+    set layout(val: 'list' | 'grid');
+    get layout(): "list" | "grid";
+    paginator: boolean;
+    rows: number;
+    totalRecords: number;
+    pageLinks: number;
+    rowsPerPageOptions: number[];
+    emptyMessage: string;
+    sortField: string | null;
+    sortOrder: number | null;
+    loading: boolean;
+    trackBy: any;
+    onPage: EventEmitter<PaginatorState>;
+    _value: _angular_core.WritableSignal<any[]>;
+    _layout: _angular_core.WritableSignal<"list" | "grid">;
+    first: _angular_core.WritableSignal<number>;
+    _rows: _angular_core.WritableSignal<number>;
+    constructor();
+    processedData: _angular_core.Signal<any[]>;
+    dataToRender: _angular_core.Signal<any[]>;
+    onPageChange(event: PaginatorState): void;
+    getTotalRecords(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryDataView, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryDataView, "magary-dataview", never, { "value": { "alias": "value"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "paginator": { "alias": "paginator"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "totalRecords": { "alias": "totalRecords"; "required": false; }; "pageLinks": { "alias": "pageLinks"; "required": false; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "sortField": { "alias": "sortField"; "required": false; }; "sortOrder": { "alias": "sortOrder"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; }, { "onPage": "onPage"; }, ["listItemTemplate", "gridItemTemplate", "headerTemplate", "footerTemplate"], never, true, never>;
+}
+
+interface UploadEvent {
+    originalEvent: Event;
+    files: File[];
+}
+interface UploadedFile {
+    file: File;
+    objectURL?: SafeUrl;
+    status?: 'pending' | 'uploading' | 'completed' | 'error';
+    progress?: number;
+}
+declare class MagaryUpload implements OnDestroy {
+    mode: _angular_core.InputSignal<"basic" | "advanced">;
+    multiple: _angular_core.InputSignal<boolean>;
+    accept: _angular_core.InputSignal<string>;
+    maxFileSize: _angular_core.InputSignal<number | null>;
+    url: _angular_core.InputSignal<string>;
+    name: _angular_core.InputSignal<string>;
+    chooseLabel: _angular_core.InputSignal<string>;
+    chooseIcon: _angular_core.InputSignal<string>;
+    uploadLabel: _angular_core.InputSignal<string>;
+    uploadIcon: _angular_core.InputSignal<string>;
+    cancelLabel: _angular_core.InputSignal<string>;
+    cancelIcon: _angular_core.InputSignal<string>;
+    withCredentials: _angular_core.InputSignal<boolean>;
+    onUpload: _angular_core.OutputEmitterRef<UploadEvent>;
+    onSelect: _angular_core.OutputEmitterRef<UploadEvent>;
+    onClear: _angular_core.OutputEmitterRef<void>;
+    onError: _angular_core.OutputEmitterRef<{
+        error: string;
+    }>;
+    files: _angular_core.WritableSignal<UploadedFile[]>;
+    uploading: _angular_core.WritableSignal<boolean>;
+    progress: _angular_core.WritableSignal<number>;
+    isDragOver: boolean;
+    private http;
+    fileInput: ElementRef;
+    private sanitizer;
+    constructor();
+    onFileSelect(event: Event): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    handleFiles(files: File[], event: Event): void;
+    removeFile(file: UploadedFile): void;
+    clear(): void;
+    upload(): void;
+    private intervalId;
+    private uploadSubscription;
+    ngOnDestroy(): void;
+    private clearUploadState;
+    private simulateUpload;
+    private uploadWithHttp;
+    private updateFilesProgress;
+    private markFilesAsCompleted;
+    private markFilesAsError;
+    isImage(file: File): boolean;
+    formatSize(bytes: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryUpload, "magary-upload", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "url": { "alias": "url"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "chooseLabel": { "alias": "chooseLabel"; "required": false; "isSignal": true; }; "chooseIcon": { "alias": "chooseIcon"; "required": false; "isSignal": true; }; "uploadLabel": { "alias": "uploadLabel"; "required": false; "isSignal": true; }; "uploadIcon": { "alias": "uploadIcon"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "cancelIcon": { "alias": "cancelIcon"; "required": false; "isSignal": true; }; "withCredentials": { "alias": "withCredentials"; "required": false; "isSignal": true; }; }, { "onUpload": "onUpload"; "onSelect": "onSelect"; "onClear": "onClear"; "onError": "onError"; }, never, never, true, never>;
+}
+
+declare class MagaryUploadModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryUploadModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryUploadModule, never, [typeof MagaryUpload], [typeof MagaryUpload]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryUploadModule>;
+}
+
+declare class MagaryCascadeSelect implements ControlValueAccessor {
+    private elementRef;
+    options: _angular_core.InputSignal<any[]>;
+    optionLabel: _angular_core.InputSignal<string>;
+    optionValue: _angular_core.InputSignal<string | null>;
+    optionGroupLabel: _angular_core.InputSignal<string | string[] | null>;
+    optionGroupChildren: _angular_core.InputSignal<string[]>;
+    placeholder: _angular_core.InputSignal<string>;
+    protected disabledInput: _angular_core.InputSignal<boolean>;
+    width: _angular_core.InputSignal<string>;
+    optionGroupSelectable: _angular_core.InputSignal<boolean>;
+    private _disabled;
+    disabled: _angular_core.Signal<boolean>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    value: _angular_core.WritableSignal<any>;
+    activeOption: _angular_core.WritableSignal<any>;
+    private onChange;
+    private onTouched;
+    selectedLabel: _angular_core.Signal<string>;
+    getOptionLabel(option: any): string;
+    getOptionValue(option: any): any;
+    getOptionChildren(option: any): any[] | null;
+    isOptionGroup(option: any): boolean;
+    toggle(): void;
+    selectOption(option: any, event: Event): void;
+    onDocumentClick(event: Event): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryCascadeSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryCascadeSelect, "magary-cascade-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "optionGroupLabel": { "alias": "optionGroupLabel"; "required": false; "isSignal": true; }; "optionGroupChildren": { "alias": "optionGroupChildren"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "optionGroupSelectable": { "alias": "optionGroupSelectable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryCascadeSelectModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryCascadeSelectModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryCascadeSelectModule, never, [typeof i1.CommonModule, typeof MagaryCascadeSelect], [typeof MagaryCascadeSelect]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryCascadeSelectModule>;
+}
+
+type InputType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search';
+type InputSize = 'small' | 'normal' | 'large';
+type InputVariant = 'filled' | 'outlined' | 'underlined';
+declare class MagaryInput {
+    value: _angular_core.ModelSignal<string>;
+    placeholder: _angular_core.InputSignal<string>;
+    type: _angular_core.InputSignal<InputType>;
+    size: _angular_core.InputSignal<InputSize>;
+    variant: _angular_core.InputSignal<InputVariant>;
+    disabled: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignal<boolean>;
+    loading: _angular_core.InputSignal<boolean>;
+    error: _angular_core.InputSignal<string>;
+    success: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string>;
+    helpText: _angular_core.InputSignal<string>;
+    prefixIcon: _angular_core.InputSignal<string>;
+    suffixIcon: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string>;
+    maxLength: _angular_core.InputSignal<number | undefined>;
+    inputFocus: _angular_core.OutputEmitterRef<Event>;
+    inputBlur: _angular_core.OutputEmitterRef<Event>;
+    iconClick: _angular_core.OutputEmitterRef<"prefix" | "suffix">;
+    private _internalError;
+    effectiveError: _angular_core.Signal<string>;
+    private focused;
+    private showPassword;
+    private readonly uniqueId;
+    inputClasses: _angular_core.Signal<string>;
+    containerClasses: _angular_core.Signal<string>;
+    inputStyles: _angular_core.Signal<{
+        width: string;
+    }>;
+    actualType: _angular_core.Signal<InputType>;
+    passwordIcon: _angular_core.Signal<"eye-off" | "eye">;
+    onInput(event: Event): void;
+    onFocus(event: Event): void;
+    onBlur(event: Event): void;
+    private validateEmail;
+    onPrefixIconClick(): void;
+    onSuffixIconClick(): void;
+    togglePasswordVisibility(): void;
+    getId(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryInput, "magary-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "success": { "alias": "success"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helpText": { "alias": "helpText"; "required": false; "isSignal": true; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; "isSignal": true; }; "suffixIcon": { "alias": "suffixIcon"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "inputFocus": "inputFocus"; "inputBlur": "inputBlur"; "iconClick": "iconClick"; }, never, never, true, never>;
+}
+
+declare class MagaryInputModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryInputModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryInputModule, never, [typeof i1.CommonModule, typeof MagaryInput], [typeof MagaryInput]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryInputModule>;
+}
+
+declare class MagaryCheckbox {
+    checked: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    required: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<any>;
+    color: _angular_core.InputSignal<"primary" | "success" | "info" | "warning" | "danger">;
+    change: _angular_core.OutputEmitterRef<boolean>;
+    focused: _angular_core.WritableSignal<boolean>;
+    uniqueId: string;
+    containerClasses: _angular_core.Signal<string>;
+    onChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryCheckbox, "magary-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, never, true, never>;
+}
+
+declare class MagaryCheckboxModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryCheckboxModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryCheckboxModule, never, [typeof MagaryCheckbox], [typeof MagaryCheckbox]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryCheckboxModule>;
+}
+
+declare class MagarySwitch {
+    checked: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string>;
+    color: _angular_core.InputSignal<"primary" | "success" | "info" | "warning" | "danger">;
+    change: _angular_core.OutputEmitterRef<boolean>;
+    focused: _angular_core.WritableSignal<boolean>;
+    uniqueId: string;
+    containerClasses: _angular_core.Signal<string>;
+    onChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySwitch, "magary-switch", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, never, true, never>;
+}
+
+declare class MagarySwitchModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySwitchModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagarySwitchModule, never, [typeof MagarySwitch], [typeof MagarySwitch]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagarySwitchModule>;
+}
+
+declare class MagarySelect implements ControlValueAccessor {
+    private elementRef;
+    readonly options: _angular_core.InputSignal<any[]>;
+    readonly optionLabel: _angular_core.InputSignal<string | undefined>;
+    readonly optionValue: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showClear: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly focused: _angular_core.WritableSignal<boolean>;
+    readonly value: _angular_core.WritableSignal<any>;
+    readonly filterValue: _angular_core.WritableSignal<string>;
+    private onChange;
+    private onTouched;
+    constructor(elementRef: ElementRef);
+    readonly visibleOptions: _angular_core.Signal<any[]>;
+    readonly selectedLabel: _angular_core.Signal<string>;
+    readonly hasValue: _angular_core.Signal<boolean>;
+    toggleOverlay(): void;
+    selectOption(option: any): void;
+    isSelected(option: any): boolean;
+    getLabel(option: any): string;
+    getValue(option: any): any;
+    onFilterInput(event: Event): void;
+    clear(event: Event): void;
+    onDocumentClick(event: MouseEvent): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySelect, "magary-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagarySelectModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySelectModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagarySelectModule, never, [typeof MagarySelect], [typeof MagarySelect]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagarySelectModule>;
+}
+
+declare class MagaryRadioButton implements ControlValueAccessor {
+    inputElement: ElementRef;
+    readonly value: _angular_core.InputSignal<any>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly focused: _angular_core.WritableSignal<boolean>;
+    readonly modelValue: _angular_core.WritableSignal<any>;
+    readonly checked: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    select(event: Event): void;
+    updateModel(): void;
+    onInputChange(event: Event): void;
+    onInputFocus(): void;
+    onInputBlur(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryRadioButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryRadioButton, "magary-radio", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryRadioGroup implements ControlValueAccessor {
+    readonly options: _angular_core.InputSignal<any[]>;
+    readonly layout: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly optionLabel: _angular_core.InputSignal<string | undefined>;
+    readonly optionValue: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.WritableSignal<any>;
+    private onChange;
+    private onTouched;
+    onRadioChange(val: any): void;
+    getOptionLabel(option: any): string;
+    getOptionValue(option: any): any;
+    readonly generatedName: string;
+    readonly groupName: _angular_core.Signal<string>;
+    writeValue(val: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryRadioGroup, "magary-radio-group", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "optionLabel": { "alias": "optionLabel"; "required": false; "isSignal": true; }; "optionValue": { "alias": "optionValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryRadioButtonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryRadioButtonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryRadioButtonModule, never, [typeof MagaryRadioButton, typeof MagaryRadioGroup], [typeof MagaryRadioButton, typeof MagaryRadioGroup]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryRadioButtonModule>;
+}
+
+declare class MagaryTextArea implements ControlValueAccessor, AfterViewInit {
+    textarea: ElementRef<HTMLTextAreaElement>;
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly cols: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly maxlength: _angular_core.InputSignalWithTransform<any, unknown>;
+    readonly showCounter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.WritableSignal<string>;
+    readonly length: _angular_core.Signal<number>;
+    private onChange;
+    private onTouched;
+    ngAfterViewInit(): void;
+    onInput(event: Event): void;
+    onBlur(): void;
+    onFocus(): void;
+    resize(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTextArea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTextArea, "magary-textarea", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "cols": { "alias": "cols"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "showCounter": { "alias": "showCounter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryTextAreaModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTextAreaModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryTextAreaModule, never, [typeof MagaryTextArea], [typeof MagaryTextArea]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryTextAreaModule>;
+}
+
+declare class MagaryDatePicker implements ControlValueAccessor, OnInit, OnDestroy {
+    private elementRef;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly minDate: _angular_core.InputSignal<Date | undefined>;
+    readonly maxDate: _angular_core.InputSignal<Date | undefined>;
+    readonly selectionMode: _angular_core.InputSignal<"single" | "range">;
+    readonly onSelect: _angular_core.OutputEmitterRef<any>;
+    readonly weekDays: string[];
+    readonly monthNames: string[];
+    readonly value: _angular_core.WritableSignal<any>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly viewDate: _angular_core.WritableSignal<Date>;
+    readonly currentView: _angular_core.WritableSignal<"day" | "month" | "year">;
+    onInput(event: Event): void;
+    readonly formattedValue: _angular_core.Signal<string | null>;
+    readonly currentMonthName: _angular_core.Signal<string>;
+    readonly currentYear: _angular_core.Signal<number>;
+    readonly calendarDays: _angular_core.Signal<(Date | null)[]>;
+    private onChange;
+    private onTouched;
+    private documentClickListener;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    toggle(): void;
+    open(): void;
+    close(): void;
+    onContainerClick(event: Event): void;
+    prev(): void;
+    next(): void;
+    switchView(): void;
+    selectMonth(monthIndex: number): void;
+    selectYear(year: number): void;
+    readonly years: _angular_core.Signal<number[]>;
+    selectDate(date: Date | null): void;
+    isToday(date: Date | null): boolean;
+    isSelected(date: Date | null): boolean;
+    isRangeStart(date: Date | null): boolean;
+    isRangeEnd(date: Date | null): boolean;
+    isInRange(date: Date | null): boolean;
+    private isSameDay;
+    isDisabledDate(date: Date | null): boolean;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryDatePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryDatePicker, "magary-datepicker", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+}
+
+declare class MagaryDatePickerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryDatePickerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryDatePickerModule, never, [typeof MagaryDatePicker], [typeof MagaryDatePicker]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryDatePickerModule>;
+}
+
+declare const INPUTNUMBER_VALUE_ACCESSOR: any;
+declare class MagaryInputNumber implements OnInit, ControlValueAccessor {
+    value: _angular_core.ModelSignal<number | null>;
+    format: _angular_core.InputSignal<boolean>;
+    showButtons: _angular_core.InputSignal<boolean>;
+    buttonLayout: _angular_core.InputSignal<"vertical" | "horizontal" | "stacked">;
+    incrementButtonClass: _angular_core.InputSignal<string>;
+    decrementButtonClass: _angular_core.InputSignal<string>;
+    incrementButtonIcon: _angular_core.InputSignal<string>;
+    decrementButtonIcon: _angular_core.InputSignal<string>;
+    locale: _angular_core.InputSignal<string>;
+    localeMatcher: _angular_core.InputSignal<"lookup" | "best fit">;
+    mode: _angular_core.InputSignal<"currency" | "decimal" | "percent">;
+    currency: _angular_core.InputSignal<string>;
+    currencyDisplay: _angular_core.InputSignal<"symbol" | "name" | "narrowSymbol" | "code">;
+    useGrouping: _angular_core.InputSignal<boolean>;
+    minFractionDigits: _angular_core.InputSignal<number | undefined>;
+    maxFractionDigits: _angular_core.InputSignal<number | undefined>;
+    prefix: _angular_core.InputSignal<string>;
+    suffix: _angular_core.InputSignal<string>;
+    min: _angular_core.InputSignal<number | null>;
+    max: _angular_core.InputSignal<number | null>;
+    step: _angular_core.InputSignal<number>;
+    allowEmpty: _angular_core.InputSignal<boolean>;
+    inputStyle: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    inputStyleClass: _angular_core.InputSignal<string>;
+    style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    styleClass: _angular_core.InputSignal<string>;
+    placeholder: _angular_core.InputSignal<string>;
+    size: _angular_core.InputSignal<number | null>;
+    maxlength: _angular_core.InputSignal<number | null>;
+    tabindex: _angular_core.InputSignal<number | null>;
+    disabled: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignal<boolean>;
+    name: _angular_core.InputSignal<string>;
+    inputId: _angular_core.InputSignal<string>;
+    onInput: EventEmitter<any>;
+    onFocus: EventEmitter<any>;
+    onBlur: EventEmitter<any>;
+    onKeyDown: EventEmitter<any>;
+    inputElement: ElementRef;
+    focused: _angular_core.WritableSignal<boolean>;
+    formattedValue: _angular_core.WritableSignal<string>;
+    onModelChange: Function;
+    onModelTouched: Function;
+    ngOnInit(): void;
+    getFormatter(): Intl.NumberFormat;
+    formatValue(val: number): string;
+    parseValue(text: string): number | null;
+    getDecimalSeparator(): string;
+    onUserInput(event: Event): void;
+    onInputFocus(event: FocusEvent): void;
+    onInputBlur(event: FocusEvent): void;
+    onInputKeyDown(event: KeyboardEvent): void;
+    spin(event: Event, dir: number): void;
+    updateModel(val: number | null): void;
+    updateInput(val: number | null, updateView: boolean): void;
+    writeValue(value: number): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState(val: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryInputNumber, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryInputNumber, "magary-input-number", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "buttonLayout": { "alias": "buttonLayout"; "required": false; "isSignal": true; }; "incrementButtonClass": { "alias": "incrementButtonClass"; "required": false; "isSignal": true; }; "decrementButtonClass": { "alias": "decrementButtonClass"; "required": false; "isSignal": true; }; "incrementButtonIcon": { "alias": "incrementButtonIcon"; "required": false; "isSignal": true; }; "decrementButtonIcon": { "alias": "decrementButtonIcon"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "localeMatcher": { "alias": "localeMatcher"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "currencyDisplay": { "alias": "currencyDisplay"; "required": false; "isSignal": true; }; "useGrouping": { "alias": "useGrouping"; "required": false; "isSignal": true; }; "minFractionDigits": { "alias": "minFractionDigits"; "required": false; "isSignal": true; }; "maxFractionDigits": { "alias": "maxFractionDigits"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; "isSignal": true; }; "inputStyle": { "alias": "inputStyle"; "required": false; "isSignal": true; }; "inputStyleClass": { "alias": "inputStyleClass"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onInput": "onInput"; "onFocus": "onFocus"; "onBlur": "onBlur"; "onKeyDown": "onKeyDown"; }, never, never, true, never>;
+}
+
+declare const SLIDER_VALUE_ACCESSOR: any;
+declare class MagarySlider implements ControlValueAccessor, OnDestroy {
+    min: _angular_core.InputSignal<number>;
+    max: _angular_core.InputSignal<number>;
+    step: _angular_core.InputSignal<number>;
+    range: _angular_core.InputSignal<boolean>;
+    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    disabled: _angular_core.InputSignal<boolean>;
+    style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    styleClass: _angular_core.InputSignal<string>;
+    onChange: EventEmitter<any>;
+    onSlideEnd: EventEmitter<any>;
+    sliderHandle: ElementRef;
+    sliderHandleStart: ElementRef;
+    sliderHandleEnd: ElementRef;
+    value: _angular_core.ModelSignal<number | number[] | null>;
+    dragging: _angular_core.WritableSignal<boolean>;
+    handleIndex: _angular_core.WritableSignal<number | null>;
+    private document;
+    private renderer;
+    private cdr;
+    private el;
+    private dragListener;
+    private upListener;
+    handle1Pos: _angular_core.Signal<number>;
+    handle2Pos: _angular_core.Signal<number>;
+    rangeStartPos: _angular_core.Signal<number>;
+    rangeWidth: _angular_core.Signal<number>;
+    onModelChange: Function;
+    onModelTouched: Function;
+    constructor();
+    calculatePos(val: number): number;
+    updateValue(val: number, handleIdx?: number): void;
+    calculateValueFromPos(pos: number): number;
+    onMouseDown(event: MouseEvent, index: number): void;
+    onBarClick(event: MouseEvent): void;
+    bindDragListeners(): void;
+    unbindDragListeners(): void;
+    onDrag(event: MouseEvent): void;
+    onDragEnd(event: MouseEvent): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySlider, "magary-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "onChange": "onChange"; "onSlideEnd": "onSlideEnd"; "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare const RATING_VALUE_ACCESSOR: any;
+declare class MagaryRating implements ControlValueAccessor {
+    disabled: _angular_core.InputSignal<boolean>;
+    readonly: _angular_core.InputSignal<boolean>;
+    stars: _angular_core.InputSignal<number>;
+    cancel: _angular_core.InputSignal<boolean>;
+    iconOn: _angular_core.InputSignal<string>;
+    iconOff: _angular_core.InputSignal<string>;
+    iconCancel: _angular_core.InputSignal<string>;
+    value: _angular_core.ModelSignal<number | null>;
+    onRate: EventEmitter<any>;
+    onCancel: EventEmitter<any>;
+    private cdr;
+    onModelChange: Function;
+    onModelTouched: Function;
+    constructor();
+    get starsArray(): number[];
+    rate(event: Event, i: number): void;
+    clear(event: Event): void;
+    writeValue(val: number | null): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState(val: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryRating, "magary-rating", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "stars": { "alias": "stars"; "required": false; "isSignal": true; }; "cancel": { "alias": "cancel"; "required": false; "isSignal": true; }; "iconOn": { "alias": "iconOn"; "required": false; "isSignal": true; }; "iconOff": { "alias": "iconOff"; "required": false; "isSignal": true; }; "iconCancel": { "alias": "iconCancel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onRate": "onRate"; "onCancel": "onCancel"; }, never, never, true, never>;
+}
+
+declare class MagaryImage implements OnDestroy {
+    private dialog;
+    src: _angular_core.InputSignal<string | undefined>;
+    alt: _angular_core.InputSignal<string | undefined>;
+    width: _angular_core.InputSignal<string | undefined>;
+    height: _angular_core.InputSignal<string | undefined>;
+    objectFit: _angular_core.InputSignal<"none" | "fill" | "cover" | "contain" | "scale-down">;
+    loading: _angular_core.InputSignal<"lazy" | "eager">;
+    preview: _angular_core.InputSignal<boolean>;
+    onLoad: _angular_core.OutputEmitterRef<Event>;
+    onError: _angular_core.OutputEmitterRef<Event>;
+    loaded: boolean;
+    error: boolean;
+    onImageLoad(event: Event): void;
+    onImageError(event: Event): void;
+    rotate: _angular_core.WritableSignal<number>;
+    scale: _angular_core.WritableSignal<number>;
+    onPreviewImageClick(event: Event): void;
+    closePreview(): void;
+    ngOnDestroy(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    rotateRight(): void;
+    rotateLeft(): void;
+    download(): void;
+    imagePreviewStyle: _angular_core.Signal<{
+        transform: string;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryImage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryImage, "magary-image", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "objectFit": { "alias": "objectFit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "preview": { "alias": "preview"; "required": false; "isSignal": true; }; }, { "onLoad": "onLoad"; "onError": "onError"; }, never, never, true, never>;
+}
+
+declare class MagaryImageModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryImageModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryImageModule, never, [typeof i1.CommonModule, typeof i1.NgStyle, typeof MagaryImage], [typeof MagaryImage]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryImageModule>;
+}
+
+interface GalleriaItem {
+    src: string;
+    alt?: string;
+    title?: string;
+    description?: string;
+    thumbnail?: string;
+    type?: 'image' | 'video';
+    videoUrl?: string;
+}
+interface GalleriaResponsiveOptions {
+    breakpoint: string;
+    numVisible: number;
+}
+declare class GalleriaIconsModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GalleriaIconsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<GalleriaIconsModule, never, [typeof i1$1.LucideAngularModule], [typeof i1$1.LucideAngularModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<GalleriaIconsModule>;
+}
+declare class MagaryGalleria implements OnInit, OnDestroy, AfterViewInit {
+    private platformId;
+    value: _angular_core.InputSignal<GalleriaItem[]>;
+    activeIndex: _angular_core.ModelSignal<number>;
+    responsiveOptions: _angular_core.InputSignal<GalleriaResponsiveOptions[]>;
+    showItemNavigators: _angular_core.InputSignal<boolean>;
+    showThumbnailNavigators: _angular_core.InputSignal<boolean>;
+    showItemNavigatorsOnHover: _angular_core.InputSignal<boolean>;
+    showThumbnails: _angular_core.InputSignal<boolean>;
+    thumbnailsPosition: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">;
+    showIndicators: _angular_core.InputSignal<boolean>;
+    showIndicatorsOnItem: _angular_core.InputSignal<boolean>;
+    indicatorPosition: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">;
+    circular: _angular_core.InputSignal<boolean>;
+    autoPlay: _angular_core.InputSignal<boolean>;
+    transitionInterval: _angular_core.InputSignal<number>;
+    changeItemOnIndicatorHover: _angular_core.InputSignal<boolean>;
+    showFullScreenButton: _angular_core.InputSignal<boolean>;
+    showDownloadButton: _angular_core.InputSignal<boolean>;
+    showShareButton: _angular_core.InputSignal<boolean>;
+    showProgressBar: _angular_core.InputSignal<boolean>;
+    showImageCounter: _angular_core.InputSignal<boolean>;
+    showPlayPauseButton: _angular_core.InputSignal<boolean>;
+    enableZoom: _angular_core.InputSignal<boolean>;
+    maxZoomLevel: _angular_core.InputSignal<number>;
+    enableSwipe: _angular_core.InputSignal<boolean>;
+    enableKeyboardNavigation: _angular_core.InputSignal<boolean>;
+    enableDoubleClickZoom: _angular_core.InputSignal<boolean>;
+    enablePinchZoom: _angular_core.InputSignal<boolean>;
+    transitionEffect: _angular_core.InputSignal<"fade" | "slide" | "zoom" | "flip">;
+    transitionDuration: _angular_core.InputSignal<number>;
+    lazyLoad: _angular_core.InputSignal<boolean>;
+    preloadRange: _angular_core.InputSignal<number>;
+    showLoadingSpinner: _angular_core.InputSignal<boolean>;
+    captionPosition: _angular_core.InputSignal<"bottom" | "overlay" | "outside">;
+    showCaption: _angular_core.InputSignal<boolean>;
+    allowPresentationMode: _angular_core.InputSignal<boolean>;
+    presentationAutoPlay: _angular_core.InputSignal<boolean>;
+    containerStyle: _angular_core.InputSignal<any>;
+    containerClass: _angular_core.InputSignal<string | undefined>;
+    theme: _angular_core.InputSignal<"auto" | "light" | "dark">;
+    accentColor: _angular_core.InputSignal<string>;
+    width: _angular_core.InputSignal<string | undefined>;
+    onImageClick: _angular_core.OutputEmitterRef<any>;
+    onFullScreenChange: _angular_core.OutputEmitterRef<boolean>;
+    onImageLoad: _angular_core.OutputEmitterRef<any>;
+    onImageError: _angular_core.OutputEmitterRef<any>;
+    onShare: _angular_core.OutputEmitterRef<any>;
+    onDownload: _angular_core.OutputEmitterRef<any>;
+    templates: _angular_core.Signal<readonly TemplateRef<any>[]>;
+    containerRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    currentImageRef: _angular_core.Signal<ElementRef<any> | undefined>;
+    itemTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    thumbnailTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    captionTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    isFullscreen: _angular_core.WritableSignal<boolean>;
+    isZoomed: _angular_core.WritableSignal<boolean>;
+    zoomLevel: _angular_core.WritableSignal<number>;
+    progressValue: _angular_core.WritableSignal<number>;
+    isHovering: _angular_core.WritableSignal<boolean>;
+    isPlaying: _angular_core.WritableSignal<boolean>;
+    presentationMode: _angular_core.WritableSignal<boolean>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    loadedImages: _angular_core.WritableSignal<Set<number>>;
+    private panX;
+    private panY;
+    private isPanning;
+    private lastPanX;
+    private lastPanY;
+    private touchStartX;
+    private touchEndX;
+    private touchStartY;
+    private touchEndY;
+    private minSwipeDistance;
+    private pinchDistance;
+    interval: any;
+    progressInterval: any;
+    constructor(platformId: Object);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    activeItem: _angular_core.Signal<GalleriaItem | undefined>;
+    imageCounter: _angular_core.Signal<string>;
+    canGoPrev: _angular_core.Signal<boolean>;
+    canGoNext: _angular_core.Signal<boolean>;
+    transformStyle: _angular_core.Signal<string>;
+    next(): void;
+    prev(): void;
+    navigateToIndex(index: number): void;
+    onThumbnailClick(index: number): void;
+    onIndicatorClick(index: number): void;
+    onItemClick(item: any): void;
+    startSlideShow(): void;
+    stopSlideShow(): void;
+    togglePlayPause(): void;
+    resetProgress(): void;
+    toggleFullScreen(): void;
+    togglePresentationMode(): void;
+    toggleZoom(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    resetZoom(): void;
+    resetPan(): void;
+    onImageDoubleClick(): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    onFullScreenChangeHandler(): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchMove(event: TouchEvent): void;
+    onTouchEnd(event: TouchEvent): void;
+    handleSwipe(): void;
+    shareImage(): Promise<void>;
+    downloadImage(): void;
+    copyToClipboard(text: string): void;
+    shouldLoadImage(index: number): boolean;
+    preloadNearbyImages(centerIndex: number): void;
+    onImageLoadSuccess(index: number): void;
+    onImageLoadError(index: number): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    applyTheme(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryGalleria, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryGalleria, "magary-galleria", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "responsiveOptions": { "alias": "responsiveOptions"; "required": false; "isSignal": true; }; "showItemNavigators": { "alias": "showItemNavigators"; "required": false; "isSignal": true; }; "showThumbnailNavigators": { "alias": "showThumbnailNavigators"; "required": false; "isSignal": true; }; "showItemNavigatorsOnHover": { "alias": "showItemNavigatorsOnHover"; "required": false; "isSignal": true; }; "showThumbnails": { "alias": "showThumbnails"; "required": false; "isSignal": true; }; "thumbnailsPosition": { "alias": "thumbnailsPosition"; "required": false; "isSignal": true; }; "showIndicators": { "alias": "showIndicators"; "required": false; "isSignal": true; }; "showIndicatorsOnItem": { "alias": "showIndicatorsOnItem"; "required": false; "isSignal": true; }; "indicatorPosition": { "alias": "indicatorPosition"; "required": false; "isSignal": true; }; "circular": { "alias": "circular"; "required": false; "isSignal": true; }; "autoPlay": { "alias": "autoPlay"; "required": false; "isSignal": true; }; "transitionInterval": { "alias": "transitionInterval"; "required": false; "isSignal": true; }; "changeItemOnIndicatorHover": { "alias": "changeItemOnIndicatorHover"; "required": false; "isSignal": true; }; "showFullScreenButton": { "alias": "showFullScreenButton"; "required": false; "isSignal": true; }; "showDownloadButton": { "alias": "showDownloadButton"; "required": false; "isSignal": true; }; "showShareButton": { "alias": "showShareButton"; "required": false; "isSignal": true; }; "showProgressBar": { "alias": "showProgressBar"; "required": false; "isSignal": true; }; "showImageCounter": { "alias": "showImageCounter"; "required": false; "isSignal": true; }; "showPlayPauseButton": { "alias": "showPlayPauseButton"; "required": false; "isSignal": true; }; "enableZoom": { "alias": "enableZoom"; "required": false; "isSignal": true; }; "maxZoomLevel": { "alias": "maxZoomLevel"; "required": false; "isSignal": true; }; "enableSwipe": { "alias": "enableSwipe"; "required": false; "isSignal": true; }; "enableKeyboardNavigation": { "alias": "enableKeyboardNavigation"; "required": false; "isSignal": true; }; "enableDoubleClickZoom": { "alias": "enableDoubleClickZoom"; "required": false; "isSignal": true; }; "enablePinchZoom": { "alias": "enablePinchZoom"; "required": false; "isSignal": true; }; "transitionEffect": { "alias": "transitionEffect"; "required": false; "isSignal": true; }; "transitionDuration": { "alias": "transitionDuration"; "required": false; "isSignal": true; }; "lazyLoad": { "alias": "lazyLoad"; "required": false; "isSignal": true; }; "preloadRange": { "alias": "preloadRange"; "required": false; "isSignal": true; }; "showLoadingSpinner": { "alias": "showLoadingSpinner"; "required": false; "isSignal": true; }; "captionPosition": { "alias": "captionPosition"; "required": false; "isSignal": true; }; "showCaption": { "alias": "showCaption"; "required": false; "isSignal": true; }; "allowPresentationMode": { "alias": "allowPresentationMode"; "required": false; "isSignal": true; }; "presentationAutoPlay": { "alias": "presentationAutoPlay"; "required": false; "isSignal": true; }; "containerStyle": { "alias": "containerStyle"; "required": false; "isSignal": true; }; "containerClass": { "alias": "containerClass"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "accentColor": { "alias": "accentColor"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "itemTemplateRef": { "alias": "itemTemplateRef"; "required": false; "isSignal": true; }; "thumbnailTemplateRef": { "alias": "thumbnailTemplateRef"; "required": false; "isSignal": true; }; "captionTemplateRef": { "alias": "captionTemplateRef"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; "onImageClick": "onImageClick"; "onFullScreenChange": "onFullScreenChange"; "onImageLoad": "onImageLoad"; "onImageError": "onImageError"; "onShare": "onShare"; "onDownload": "onDownload"; }, ["templates"], never, true, never>;
+}
+
+declare class CarouselIconsModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselIconsModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<CarouselIconsModule, never, [typeof i1$1.LucideAngularModule], [typeof i1$1.LucideAngularModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<CarouselIconsModule>;
+}
+/**
+ * Carousel responsive breakpoint options
+ */
+interface CarouselResponsiveOptions {
+    breakpoint: number | string;
+    numVisible?: number;
+    numScroll?: number;
+    spaceBetween?: number;
+    showNavigators?: boolean;
+    showIndicators?: boolean;
+}
+/**
+ * Item template context with enhanced data
+ */
+interface CarouselItemContext<T> {
+    $implicit: T;
+    index: number;
+    count: number;
+    isActive: boolean;
+    isVisible: boolean;
+    progress: number;
+}
+/**
+ * Carousel orientation
+ */
+type CarouselOrientation = 'horizontal' | 'vertical';
+/**
+ * Carousel transition effects
+ */
+type CarouselEffect = 'slide' | 'fade' | 'cube' | 'flip' | 'coverflow' | 'cards';
+/**
+ * Carousel indicator styles
+ */
+type CarouselIndicatorStyle = 'dots' | 'lines' | 'thumbnails' | 'fraction' | 'progress';
+/**
+ * Navigation button styles
+ */
+type CarouselNavStyle = 'default' | 'minimal' | 'large' | 'outside';
+/**
+ * Navigation button position
+ */
+type CarouselNavPosition = 'default' | 'top' | 'bottom' | 'center' | 'outside';
+/**
+ * Indicator position
+ */
+type CarouselIndicatorPosition = 'bottom' | 'top' | 'left' | 'right' | 'inside' | 'outside';
+/**
+ * Autoplay direction
+ */
+type CarouselAutoplayDirection = 'forward' | 'backward' | 'alternate';
+/**
+ * Preload strategy
+ */
+type CarouselPreloadStrategy = 'eager' | 'lazy' | 'none';
+/**
+ * Carousel event data
+ */
+interface CarouselSlideEvent<T> {
+    currentIndex: number;
+    previousIndex: number;
+    currentItem: T | null;
+    previousItem: T | null;
+    direction: 'forward' | 'backward';
+}
+/**
+ * MagaryCarousel v2.0 - Enterprise-grade carousel component
+ *
+ * @description
+ * Feature-complete carousel with 100+ improvements including:
+ * - Multiple transition effects (slide, fade, cube, flip, coverflow, cards)
+ * - Advanced autoplay with direction control and visual progress
+ * - Virtual scrolling for large datasets
+ * - Full keyboard navigation and accessibility
+ * - Responsive configuration per breakpoint
+ * - Touch gestures with momentum and resistance
+ * - ControlValueAccessor for forms integration
+ * - Multiple indicator styles (dots, lines, thumbnails, fraction, progress)
+ * - Lazy loading and prefetch strategies
+ * - RTL support
+ * - Dark mode theming
+ *
+ * @example
+ * ```html
+ * <magary-carousel
+ *   [(page)]="currentPage"
+ *   [value]="products"
+ *   [numVisible]="3"
+ *   [effect]="'coverflow'"
+ *   [autoplayInterval]="5000"
+ *   [showProgress]="true"
+ *   [loop]="true"
+ *   (slideChange)="onSlideChange($event)">
+ *
+ *   <ng-template #item let-product let-index="index">
+ *     <div class="product-card">
+ *       <img [src]="product.image" [alt]="product.name">
+ *       <h3>{{ product.name }}</h3>
+ *     </div>
+ *   </ng-template>
+ * </magary-carousel>
+ * ```
+ */
+declare class MagaryCarouselComponent<T> implements OnInit, AfterViewInit, ControlValueAccessor {
+    protected readonly Math: Math;
+    /** Array of items to display */
+    readonly value: _angular_core.InputSignal<T[]>;
+    /** Current page (two-way binding support with model) */
+    readonly page: _angular_core.ModelSignal<number>;
+    /** Initial slide to show on mount */
+    readonly initialSlide: _angular_core.InputSignal<number>;
+    /** Number of items visible at once */
+    readonly numVisible: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Number of items to scroll per navigation */
+    readonly numScroll: _angular_core.InputSignalWithTransform<number, string | number>;
+    /** Number of items to highlight as active */
+    readonly numActive: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Gap between items in pixels */
+    readonly spaceBetween: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Responsive configuration per breakpoint */
+    readonly responsiveOptions: _angular_core.InputSignal<CarouselResponsiveOptions[]>;
+    /** Carousel orientation */
+    readonly orientation: _angular_core.InputSignal<CarouselOrientation>;
+    /** Text direction (LTR/RTL) */
+    readonly direction: _angular_core.InputSignal<"ltr" | "rtl">;
+    /** Height for vertical carousels */
+    readonly verticalViewPortHeight: _angular_core.InputSignal<string>;
+    /** Width constraint */
+    readonly width: _angular_core.InputSignal<string | undefined>;
+    /** Custom CSS class for content wrapper */
+    readonly contentClass: _angular_core.InputSignal<string>;
+    /** Custom CSS class for indicators */
+    readonly indicatorsContentClass: _angular_core.InputSignal<string>;
+    /** Aria label for accessibility */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Theme variant */
+    readonly theme: _angular_core.InputSignal<"minimal" | "modern" | "classic" | "ios" | "material">;
+    /** Visual effect type */
+    readonly effect: _angular_core.InputSignal<CarouselEffect>;
+    /** Transition duration in milliseconds */
+    readonly transitionDuration: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Transition easing function */
+    readonly transitionTimingFunction: _angular_core.InputSignal<string>;
+    /** Enable free mode (no snapping) */
+    readonly freeMode: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Resistance ratio for edge bounce effect (0-1) */
+    readonly resistance: _angular_core.InputSignal<number>;
+    /** Enable will-change optimization during animation only */
+    readonly optimizePerformance: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable circular/infinite scrolling (jumps to start/end) */
+    readonly circular: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable true loop (duplicates items for seamless infinite scroll) */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Center the active slide */
+    readonly centerMode: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show partially next/previous slides (peek effect) */
+    readonly peekMode: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Peek amount in percentage */
+    readonly peekAmount: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show/hide navigation buttons */
+    readonly showNavigators: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Navigation button style */
+    readonly navStyle: _angular_core.InputSignal<CarouselNavStyle>;
+    /** Navigation button position */
+    readonly navPosition: _angular_core.InputSignal<CarouselNavPosition>;
+    /** Custom CSS class for previous button */
+    readonly prevButtonClass: _angular_core.InputSignal<string>;
+    /** Custom CSS class for next button */
+    readonly nextButtonClass: _angular_core.InputSignal<string>;
+    /** Show/hide page indicators */
+    readonly showIndicators: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Indicator style */
+    readonly indicatorStyle: _angular_core.InputSignal<CarouselIndicatorStyle>;
+    /** Indicator position */
+    readonly indicatorPosition: _angular_core.InputSignal<CarouselIndicatorPosition>;
+    /** Enable touch/mouse swipe */
+    readonly swipeable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Touch sensitivity ratio (1 = 1:1, 0.5 = half speed) */
+    readonly touchRatio: _angular_core.InputSignal<number>;
+    /** Minimum pixels to trigger swipe */
+    readonly threshold: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show grab cursor on hover */
+    readonly grabCursor: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable mousewheel navigation */
+    readonly mousewheel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable keyboard navigation */
+    readonly keyboard: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Allow momentum scrolling */
+    readonly momentum: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Momentum deceleration */
+    readonly momentumRatio: _angular_core.InputSignal<number>;
+    /** Enable haptic feedback on mobile (if supported) */
+    readonly hapticFeedback: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Autoplay interval in milliseconds (0 = disabled) */
+    readonly autoplayInterval: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Autoplay direction */
+    readonly autoplayDirection: _angular_core.InputSignal<CarouselAutoplayDirection>;
+    /** Pause autoplay on hover */
+    readonly pauseOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Pause autoplay on interaction */
+    readonly pauseOnInteraction: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show autoplay progress indicator */
+    readonly showProgress: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Progress indicator style: 'bar' | 'circular' */
+    readonly progressStyle: _angular_core.InputSignal<"bar" | "circular">;
+    /** Disable autoplay when carousel is not in viewport */
+    readonly autoplayOnlyInView: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Resume autoplay after interaction delay (ms) */
+    readonly autoplayResumeDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Enable virtual scrolling for large datasets */
+    readonly virtual: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Virtual buffer size (items to render outside viewport) */
+    readonly virtualBuffer: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Preload strategy for items */
+    readonly preloadStrategy: _angular_core.InputSignal<CarouselPreloadStrategy>;
+    /** Prefetch adjacent items */
+    readonly prefetchAdjacent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Respect prefers-reduced-motion */
+    readonly respectReducedMotion: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable hash navigation (URL sync) */
+    readonly hashNavigation: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Hash prefix for URL */
+    readonly hashPrefix: _angular_core.InputSignal<string>;
+    /** Enable browser history integration */
+    readonly history: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Track item view time for analytics */
+    readonly trackViewTime: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable zoom on item click */
+    readonly zoomOnClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Zoom scale factor */
+    readonly zoomScale: _angular_core.InputSignal<number>;
+    /** Watch slides progress for parallax effects */
+    readonly watchSlidesProgress: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly itemTemplate: _angular_core.Signal<TemplateRef<CarouselItemContext<T>> | undefined>;
+    readonly headerTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    readonly footerTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    readonly prevButtonTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    readonly nextButtonTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    readonly indicatorTemplate: _angular_core.Signal<TemplateRef<{
+        index: number;
+        active: boolean;
+    }> | undefined>;
+    readonly loadingTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    readonly emptyTemplate: _angular_core.Signal<TemplateRef<void> | undefined>;
+    readonly progressTemplate: _angular_core.Signal<TemplateRef<{
+        progress: number;
+    }> | undefined>;
+    readonly itemsContainer: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly carouselWrapper: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly trackElement: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    readonly itemElements: _angular_core.Signal<readonly ElementRef<HTMLDivElement>[]>;
+    /** Emitted when page changes */
+    readonly pageChange: _angular_core.OutputEmitterRef<number>;
+    /** Emitted before slide change (cancelable) */
+    readonly slideChange: _angular_core.OutputEmitterRef<CarouselSlideEvent<T>>;
+    /** Emitted after slide change completes */
+    readonly slideChanged: _angular_core.OutputEmitterRef<CarouselSlideEvent<T>>;
+    /** Emitted when reaching beginning */
+    readonly reachBeginning: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when reaching end */
+    readonly reachEnd: _angular_core.OutputEmitterRef<void>;
+    /** Emitted on scroll progress (0-1) */
+    readonly progressChange: _angular_core.OutputEmitterRef<number>;
+    /** Emitted when item is clicked */
+    readonly itemClick: _angular_core.OutputEmitterRef<{
+        item: T;
+        index: number;
+    }>;
+    /** Emitted when item comes into view */
+    readonly itemView: _angular_core.OutputEmitterRef<{
+        item: T;
+        index: number;
+        duration: number;
+    }>;
+    /** Autoplay lifecycle events */
+    readonly autoplayStart: _angular_core.OutputEmitterRef<void>;
+    readonly autoplayStop: _angular_core.OutputEmitterRef<void>;
+    readonly autoplayPause: _angular_core.OutputEmitterRef<void>;
+    readonly autoplayResume: _angular_core.OutputEmitterRef<void>;
+    /** Touch/Drag events */
+    readonly touchStart: _angular_core.OutputEmitterRef<MouseEvent | TouchEvent>;
+    readonly touchMove: _angular_core.OutputEmitterRef<MouseEvent | TouchEvent>;
+    readonly touchEnd: _angular_core.OutputEmitterRef<MouseEvent | TouchEvent>;
+    /** Swipe direction detected */
+    readonly swipeDirection: _angular_core.OutputEmitterRef<"left" | "right" | "up" | "down">;
+    protected readonly _currentPage: _angular_core.WritableSignal<number>;
+    protected readonly _activeNumVisible: _angular_core.WritableSignal<number>;
+    protected readonly _activeNumScroll: _angular_core.WritableSignal<number>;
+    protected readonly _activeSpaceBetween: _angular_core.WritableSignal<number>;
+    protected readonly _isAnimating: _angular_core.WritableSignal<boolean>;
+    protected readonly _isHovered: _angular_core.WritableSignal<boolean>;
+    protected readonly _isInView: _angular_core.WritableSignal<boolean>;
+    protected readonly _isDragging: _angular_core.WritableSignal<boolean>;
+    protected readonly _autoplayProgress: _angular_core.WritableSignal<number>;
+    protected readonly _itemViewTimes: _angular_core.WritableSignal<Map<number, number>>;
+    protected readonly _reducedMotion: _angular_core.WritableSignal<boolean>;
+    protected readonly _touchStart: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+        time: number;
+    } | null>;
+    protected readonly _touchCurrent: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    protected readonly _dragOffset: _angular_core.WritableSignal<number>;
+    protected readonly _momentum: _angular_core.WritableSignal<number>;
+    protected readonly _zoomedIndex: _angular_core.WritableSignal<number>;
+    protected readonly _slideProgress: _angular_core.WritableSignal<Map<number, number>>;
+    private autoplayTimer;
+    private autoplayProgressInterval;
+    private autoplayPaused;
+    private autoplayReversed;
+    private autoplayResumeTimer;
+    private intersectionObserver;
+    private momentumRAF;
+    private viewTimeStartMap;
+    private onChange;
+    private onTouched;
+    private disabled;
+    private readonly destroyRef;
+    private readonly platformId;
+    private readonly elementRef;
+    private readonly renderer;
+    readonly isVertical: _angular_core.Signal<boolean>;
+    readonly isRTL: _angular_core.Signal<boolean>;
+    readonly totalItems: _angular_core.Signal<number>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    readonly effectiveNumVisible: _angular_core.Signal<number>;
+    readonly totalPages: _angular_core.Signal<number>;
+    readonly pages: _angular_core.Signal<number[]>;
+    readonly canNavigateForward: _angular_core.Signal<boolean>;
+    readonly canNavigateBackward: _angular_core.Signal<boolean>;
+    readonly currentSlideInfo: _angular_core.Signal<{
+        page: number;
+        startIndex: number;
+        endIndex: number;
+        visibleCount: number;
+        total: number;
+    }>;
+    readonly transformStyle: _angular_core.Signal<{
+        transform: string;
+        transitionDuration?: undefined;
+        transitionTimingFunction?: undefined;
+    } | {
+        transform: string;
+        transitionDuration: string;
+        transitionTimingFunction: string;
+    }>;
+    readonly icons: {
+        ChevronLeft: i1$1.LucideIconData;
+        ChevronRight: i1$1.LucideIconData;
+    };
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * Navigate to next slide
+     */
+    next(event?: Event): void;
+    /**
+     * Navigate to previous slide
+     */
+    previous(event?: Event): void;
+    /**
+     * Navigate to specific page
+     * @param pageIndex Target page index
+     * @param emit Whether to emit events
+     * @param speed Optional custom transition speed
+     */
+    goToPage(pageIndex: number, emit?: boolean, speed?: number): void;
+    /**
+     * Navigate to specific slide with speed control
+     */
+    slideTo(index: number, speed?: number, runCallbacks?: boolean): void;
+    /**
+     * Navigate to next slide with speed control
+     */
+    slideNext(speed?: number): void;
+    /**
+     * Navigate to previous slide with speed control
+     */
+    slidePrev(speed?: number): void;
+    /**
+     * Update carousel (recalculate dimensions and state)
+     */
+    update(): void;
+    /**
+     * Destroy carousel and cleanup
+     */
+    destroy(): void;
+    /**
+     * Append slide dynamically
+     */
+    appendSlide(item: T): void;
+    /**
+     * Prepend slide dynamically
+     */
+    prependSlide(item: T): void;
+    /**
+     * Remove slide at index
+     */
+    removeSlide(index: number): void;
+    /**
+     * Detach all event listeners
+     */
+    detachEvents(): void;
+    /**
+     * Attach event listeners (re-enable after detaching)
+     */
+    attachEvents(): void;
+    onItemClick(item: T, index: number, event?: Event): void;
+    toggleZoom(index: number): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private handleNavigation;
+    private getItemAtPage;
+    private startAutoplay;
+    private stopAutoplay;
+    private pauseAutoplay;
+    private resumeAutoplay;
+    private resetAutoplay;
+    private scheduleAutoplayResume;
+    private startProgressAnimation;
+    private stopProgressAnimation;
+    private applyResponsiveOptions;
+    private setupEventListeners;
+    private setupTouchEvents;
+    private setupMousewheelEvents;
+    private onDragStart;
+    private onDragMove;
+    private onDragEnd;
+    private getEventPoint;
+    private applyMomentum;
+    private setupIntersectionObserver;
+    private checkReducedMotion;
+    private announceSlideChange;
+    private startViewTimeTracking;
+    private recordViewTime;
+    private initHashNavigation;
+    private updateHash;
+    getItemContext(item: T, index: number): CarouselItemContext<T>;
+    trackByIndex(index: number): number;
+    isItemActive(index: number): boolean;
+    isItemInVirtualRange(index: number): boolean;
+    shouldRenderItem(index: number): boolean;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryCarouselComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryCarouselComponent<any>, "magary-carousel", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "initialSlide": { "alias": "initialSlide"; "required": false; "isSignal": true; }; "numVisible": { "alias": "numVisible"; "required": false; "isSignal": true; }; "numScroll": { "alias": "numScroll"; "required": false; "isSignal": true; }; "numActive": { "alias": "numActive"; "required": false; "isSignal": true; }; "spaceBetween": { "alias": "spaceBetween"; "required": false; "isSignal": true; }; "responsiveOptions": { "alias": "responsiveOptions"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "verticalViewPortHeight": { "alias": "verticalViewPortHeight"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "contentClass": { "alias": "contentClass"; "required": false; "isSignal": true; }; "indicatorsContentClass": { "alias": "indicatorsContentClass"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "effect": { "alias": "effect"; "required": false; "isSignal": true; }; "transitionDuration": { "alias": "transitionDuration"; "required": false; "isSignal": true; }; "transitionTimingFunction": { "alias": "transitionTimingFunction"; "required": false; "isSignal": true; }; "freeMode": { "alias": "freeMode"; "required": false; "isSignal": true; }; "resistance": { "alias": "resistance"; "required": false; "isSignal": true; }; "optimizePerformance": { "alias": "optimizePerformance"; "required": false; "isSignal": true; }; "circular": { "alias": "circular"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "centerMode": { "alias": "centerMode"; "required": false; "isSignal": true; }; "peekMode": { "alias": "peekMode"; "required": false; "isSignal": true; }; "peekAmount": { "alias": "peekAmount"; "required": false; "isSignal": true; }; "showNavigators": { "alias": "showNavigators"; "required": false; "isSignal": true; }; "navStyle": { "alias": "navStyle"; "required": false; "isSignal": true; }; "navPosition": { "alias": "navPosition"; "required": false; "isSignal": true; }; "prevButtonClass": { "alias": "prevButtonClass"; "required": false; "isSignal": true; }; "nextButtonClass": { "alias": "nextButtonClass"; "required": false; "isSignal": true; }; "showIndicators": { "alias": "showIndicators"; "required": false; "isSignal": true; }; "indicatorStyle": { "alias": "indicatorStyle"; "required": false; "isSignal": true; }; "indicatorPosition": { "alias": "indicatorPosition"; "required": false; "isSignal": true; }; "swipeable": { "alias": "swipeable"; "required": false; "isSignal": true; }; "touchRatio": { "alias": "touchRatio"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "grabCursor": { "alias": "grabCursor"; "required": false; "isSignal": true; }; "mousewheel": { "alias": "mousewheel"; "required": false; "isSignal": true; }; "keyboard": { "alias": "keyboard"; "required": false; "isSignal": true; }; "momentum": { "alias": "momentum"; "required": false; "isSignal": true; }; "momentumRatio": { "alias": "momentumRatio"; "required": false; "isSignal": true; }; "hapticFeedback": { "alias": "hapticFeedback"; "required": false; "isSignal": true; }; "autoplayInterval": { "alias": "autoplayInterval"; "required": false; "isSignal": true; }; "autoplayDirection": { "alias": "autoplayDirection"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; "pauseOnInteraction": { "alias": "pauseOnInteraction"; "required": false; "isSignal": true; }; "showProgress": { "alias": "showProgress"; "required": false; "isSignal": true; }; "progressStyle": { "alias": "progressStyle"; "required": false; "isSignal": true; }; "autoplayOnlyInView": { "alias": "autoplayOnlyInView"; "required": false; "isSignal": true; }; "autoplayResumeDelay": { "alias": "autoplayResumeDelay"; "required": false; "isSignal": true; }; "virtual": { "alias": "virtual"; "required": false; "isSignal": true; }; "virtualBuffer": { "alias": "virtualBuffer"; "required": false; "isSignal": true; }; "preloadStrategy": { "alias": "preloadStrategy"; "required": false; "isSignal": true; }; "prefetchAdjacent": { "alias": "prefetchAdjacent"; "required": false; "isSignal": true; }; "respectReducedMotion": { "alias": "respectReducedMotion"; "required": false; "isSignal": true; }; "hashNavigation": { "alias": "hashNavigation"; "required": false; "isSignal": true; }; "hashPrefix": { "alias": "hashPrefix"; "required": false; "isSignal": true; }; "history": { "alias": "history"; "required": false; "isSignal": true; }; "trackViewTime": { "alias": "trackViewTime"; "required": false; "isSignal": true; }; "zoomOnClick": { "alias": "zoomOnClick"; "required": false; "isSignal": true; }; "zoomScale": { "alias": "zoomScale"; "required": false; "isSignal": true; }; "watchSlidesProgress": { "alias": "watchSlidesProgress"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; "pageChange": "pageChange"; "slideChange": "slideChange"; "slideChanged": "slideChanged"; "reachBeginning": "reachBeginning"; "reachEnd": "reachEnd"; "progressChange": "progressChange"; "itemClick": "itemClick"; "itemView": "itemView"; "autoplayStart": "autoplayStart"; "autoplayStop": "autoplayStop"; "autoplayPause": "autoplayPause"; "autoplayResume": "autoplayResume"; "touchStart": "touchStart"; "touchMove": "touchMove"; "touchEnd": "touchEnd"; "swipeDirection": "swipeDirection"; }, ["itemTemplate", "headerTemplate", "footerTemplate", "prevButtonTemplate", "nextButtonTemplate", "indicatorTemplate", "loadingTemplate", "emptyTemplate", "progressTemplate"], never, true, never>;
+}
+
+interface MenuItemClickEvent {
+    item: MenuItem;
+    level: number;
+    path: string[];
+}
+interface MenuToggleEvent {
+    isOpen: boolean;
+    menuTitle: string;
+}
+declare class MagaryPanelmenu {
+    title: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    iconClass: _angular_core.InputSignal<string>;
+    items: _angular_core.InputSignal<MenuItem[]>;
+    backgroundColor: _angular_core.InputSignal<string>;
+    textColor: _angular_core.InputSignal<string>;
+    borderRadius: _angular_core.InputSignal<string>;
+    shadow: _angular_core.InputSignal<number>;
+    width: _angular_core.InputSignal<string>;
+    hoverColor: _angular_core.InputSignal<string>;
+    allowMultipleExpanded: _angular_core.InputSignal<boolean>;
+    defaultOpen: _angular_core.InputSignal<boolean>;
+    collapsed: _angular_core.InputSignal<boolean>;
+    menuToggle: _angular_core.OutputEmitterRef<MenuToggleEvent>;
+    itemClick: _angular_core.OutputEmitterRef<MenuItemClickEvent>;
+    itemExpand: _angular_core.OutputEmitterRef<{
+        item: MenuItem;
+        expanded: boolean;
+    }>;
+    expandSidebar: _angular_core.OutputEmitterRef<void>;
+    isOpen: _angular_core.WritableSignal<boolean>;
+    hoveredItem: _angular_core.WritableSignal<string | null>;
+    hoveredHeader: _angular_core.WritableSignal<boolean>;
+    expandedItems: _angular_core.WritableSignal<Set<string>>;
+    panelStyles: _angular_core.Signal<{
+        '--panel-bg': string;
+        '--panel-text': string;
+        '--panel-hover': string;
+        '--panel-radius': string;
+        width: string;
+    }>;
+    constructor();
+    toggle(): void;
+    toggleSubItem(itemKey: string, item?: MenuItem): void;
+    onItemClick(item: MenuItem, level?: number, path?: string[]): void;
+    isSubItemExpanded(itemKey: string): boolean;
+    hasChildren(item: MenuItem): boolean;
+    onItemHover(itemId: string): void;
+    onItemLeave(): void;
+    onHeaderHover(isHovering: boolean): void;
+    getItemId(item: MenuItem, index: number, parentPath?: string): string;
+    getUniqueItemKey(item: MenuItem, parentPath?: string): string;
+    isItemHovered(itemId: string): boolean;
+    getIconName(icon: string | undefined | null): any;
+    isItemDisabled(item: MenuItem): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryPanelmenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryPanelmenu, "magary-panelmenu", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "textColor": { "alias": "textColor"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "hoverColor": { "alias": "hoverColor"; "required": false; "isSignal": true; }; "allowMultipleExpanded": { "alias": "allowMultipleExpanded"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "menuToggle": "menuToggle"; "itemClick": "itemClick"; "itemExpand": "itemExpand"; "expandSidebar": "expandSidebar"; }, never, never, true, never>;
+}
+
+declare class MagaryPanelMenuModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryPanelMenuModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryPanelMenuModule, never, [typeof i1.CommonModule, typeof MagaryPanelmenu, typeof i3.RouterModule], [typeof MagaryPanelmenu]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryPanelMenuModule>;
+}
+
+type AvatarShape = 'circle' | 'square';
+type AvatarSize = 'xsmall' | 'small' | 'normal' | 'large' | 'xlarge';
+type BadgeSeverity = 'info' | 'success' | 'warning' | 'danger';
+interface AvatarClickEvent {
+    type: 'avatar' | 'badge';
+    data?: any;
+}
+declare class MagaryAvatar {
+    label: _angular_core.InputSignal<string | undefined>;
+    image: _angular_core.InputSignal<string | undefined>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    shape: _angular_core.InputSignal<AvatarShape>;
+    size: _angular_core.InputSignal<AvatarSize>;
+    sizePixels: _angular_core.Signal<24 | 28 | 48 | 64 | 32>;
+    badgeValue: _angular_core.InputSignal<string | number | undefined>;
+    badgeSeverity: _angular_core.InputSignal<BadgeSeverity>;
+    customStyle: _angular_core.InputSignal<Record<string, any> | undefined>;
+    alt: _angular_core.InputSignal<string>;
+    clickable: _angular_core.InputSignal<boolean>;
+    loading: _angular_core.InputSignal<boolean>;
+    disabled: _angular_core.InputSignal<boolean>;
+    avatarClick: _angular_core.OutputEmitterRef<AvatarClickEvent>;
+    imageError: _angular_core.WritableSignal<boolean>;
+    displayLabel: _angular_core.Signal<string>;
+    avatarClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        clickable: boolean;
+        loading: boolean;
+        disabled: boolean;
+        'has-image': boolean;
+        'has-icon': boolean;
+        'has-label': boolean;
+    }>;
+    shouldShowImage: _angular_core.Signal<boolean | "" | undefined>;
+    shouldShowIcon: _angular_core.Signal<boolean>;
+    shouldShowLabel: _angular_core.Signal<boolean>;
+    onImageError(): void;
+    onImageLoad(): void;
+    onAvatarClick(): void;
+    onBadgeClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryAvatar, "magary-avatar", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "image": { "alias": "image"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "badgeValue": { "alias": "badgeValue"; "required": false; "isSignal": true; }; "badgeSeverity": { "alias": "badgeSeverity"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "avatarClick": "avatarClick"; }, never, never, true, never>;
+}
+
+interface SidebarSection {
+    title: string;
+    icon?: string;
+    items: MenuItem[];
+    backgroundColor?: string;
+    textColor?: string;
+    hoverColor?: string;
+    iconClass?: string;
+}
+type AvatarType = 'image' | 'label' | 'icon';
+interface AvatarConfig {
+    type: AvatarType;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    image?: string;
+    label?: string;
+    icon?: string;
+    badgeValue?: string;
+    badgeSeverity?: BadgeSeverity | undefined;
+}
+declare class Sidebar implements OnDestroy {
+    sections: _angular_core.InputSignal<SidebarSection[]>;
+    menu: _angular_core.InputSignal<MenuItem[]>;
+    menuTitle: _angular_core.InputSignal<string>;
+    showUserSection: _angular_core.InputSignal<boolean>;
+    userName: _angular_core.InputSignal<string>;
+    userEmail: _angular_core.InputSignal<string>;
+    avatarConfig: _angular_core.InputSignal<AvatarConfig>;
+    logoSrc: _angular_core.InputSignal<string>;
+    appTitle: _angular_core.InputSignal<string>;
+    appTitleClass: _angular_core.InputSignal<string>;
+    appTitleStyle: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    menuBackgroundColor: _angular_core.InputSignal<string>;
+    menuTextColor: _angular_core.InputSignal<string>;
+    menuHoverColor: _angular_core.InputSignal<string>;
+    collapsible: _angular_core.InputSignal<boolean>;
+    showToggle: _angular_core.InputSignal<boolean>;
+    showLogo: _angular_core.InputSignal<boolean>;
+    showBrandLogo: _angular_core.InputSignal<boolean>;
+    brandLogoSrc: _angular_core.InputSignal<string>;
+    brandLogoPosition: _angular_core.InputSignal<"top" | "bottom" | "center">;
+    logoWidth: _angular_core.InputSignal<number>;
+    logoHeight: _angular_core.InputSignal<number>;
+    brandLogoWidth: _angular_core.InputSignal<number>;
+    brandLogoHeight: _angular_core.InputSignal<number>;
+    isMobileOpen: _angular_core.WritableSignal<boolean>;
+    isCollapsed: _angular_core.WritableSignal<boolean>;
+    Logout: _angular_core.OutputEmitterRef<void>;
+    closeSidebar: _angular_core.OutputEmitterRef<void>;
+    toggleMobileSidebar(): void;
+    toggleCollapse(): void;
+    openSidebar(): void;
+    closeMobileSidebar(): void;
+    logout(): void;
+    private router;
+    private routerSubscription;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Sidebar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Sidebar, "magary-sidebar", never, { "sections": { "alias": "sections"; "required": false; "isSignal": true; }; "menu": { "alias": "menu"; "required": false; "isSignal": true; }; "menuTitle": { "alias": "menuTitle"; "required": false; "isSignal": true; }; "showUserSection": { "alias": "showUserSection"; "required": false; "isSignal": true; }; "userName": { "alias": "userName"; "required": false; "isSignal": true; }; "userEmail": { "alias": "userEmail"; "required": false; "isSignal": true; }; "avatarConfig": { "alias": "avatarConfig"; "required": false; "isSignal": true; }; "logoSrc": { "alias": "logoSrc"; "required": false; "isSignal": true; }; "appTitle": { "alias": "appTitle"; "required": false; "isSignal": true; }; "appTitleClass": { "alias": "appTitleClass"; "required": false; "isSignal": true; }; "appTitleStyle": { "alias": "appTitleStyle"; "required": false; "isSignal": true; }; "menuBackgroundColor": { "alias": "menuBackgroundColor"; "required": false; "isSignal": true; }; "menuTextColor": { "alias": "menuTextColor"; "required": false; "isSignal": true; }; "menuHoverColor": { "alias": "menuHoverColor"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "showToggle": { "alias": "showToggle"; "required": false; "isSignal": true; }; "showLogo": { "alias": "showLogo"; "required": false; "isSignal": true; }; "showBrandLogo": { "alias": "showBrandLogo"; "required": false; "isSignal": true; }; "brandLogoSrc": { "alias": "brandLogoSrc"; "required": false; "isSignal": true; }; "brandLogoPosition": { "alias": "brandLogoPosition"; "required": false; "isSignal": true; }; "logoWidth": { "alias": "logoWidth"; "required": false; "isSignal": true; }; "logoHeight": { "alias": "logoHeight"; "required": false; "isSignal": true; }; "brandLogoWidth": { "alias": "brandLogoWidth"; "required": false; "isSignal": true; }; "brandLogoHeight": { "alias": "brandLogoHeight"; "required": false; "isSignal": true; }; }, { "Logout": "Logout"; "closeSidebar": "closeSidebar"; }, never, never, true, never>;
+}
+
+declare class MagarySidebarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySidebarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagarySidebarModule, never, [typeof i1.CommonModule, typeof Sidebar, typeof i3.RouterModule], [typeof Sidebar]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagarySidebarModule>;
+}
+
+interface BreadcrumbItem {
+    label?: string;
+    icon?: string;
+    command?: (event?: {
+        originalEvent: Event;
+        item: BreadcrumbItem;
+    }) => void;
+    url?: string;
+    routerLink?: any;
+    queryParams?: {
+        [k: string]: any;
+    };
+    disabled?: boolean;
+    target?: string;
+    routerLinkActiveOptions?: any;
+    style?: any;
+    styleClass?: string;
+    fragment?: string;
+    preserveFragment?: boolean;
+    skipLocationChange?: boolean;
+    replaceUrl?: boolean;
+    state?: any;
+}
+declare class MagaryBreadcrumb {
+    readonly model: _angular_core.InputSignal<BreadcrumbItem[]>;
+    readonly home: _angular_core.InputSignal<BreadcrumbItem | undefined>;
+    readonly style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null | undefined>;
+    readonly styleClass: _angular_core.InputSignal<string | undefined>;
+    readonly onItemClick: _angular_core.OutputEmitterRef<{
+        originalEvent: Event;
+        item: BreadcrumbItem;
+    }>;
+    itemClick(event: Event, item: BreadcrumbItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryBreadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryBreadcrumb, "magary-breadcrumb", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "home": { "alias": "home"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, { "onItemClick": "onItemClick"; }, never, never, true, never>;
+}
+
+interface StepsItem {
+    label: string;
+    icon?: string;
+    command?: (event?: {
+        originalEvent: Event;
+        item: StepsItem;
+        index: number;
+    }) => void;
+    url?: string;
+    routerLink?: any;
+    queryParams?: {
+        [k: string]: any;
+    };
+    disabled?: boolean;
+    target?: string;
+    routerLinkActiveOptions?: any;
+    style?: any;
+    styleClass?: string;
+}
+declare class MagarySteps {
+    readonly model: _angular_core.InputSignal<StepsItem[]>;
+    readonly activeIndex: _angular_core.InputSignal<number>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null | undefined>;
+    readonly styleClass: _angular_core.InputSignal<string | undefined>;
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly template: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly activeIndexChange: _angular_core.OutputEmitterRef<number>;
+    readonly rootClass: _angular_core.Signal<{
+        [x: string]: boolean;
+        'magary-steps': boolean;
+        'magary-steps-vertical': boolean;
+        'magary-steps-horizontal': boolean;
+    }>;
+    onItemClick(event: Event, item: StepsItem, i: number): void;
+    isStepActive(index: number): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySteps, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySteps, "magary-steps", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "activeIndexChange": "activeIndexChange"; }, ["template"], never, true, never>;
+}
+
+declare class TieredMenuItemDirective {
+    private el;
+    private renderer;
+    item: _angular_core.InputSignal<MenuItem>;
+    parent: _angular_core.InputSignal<MagaryTieredMenu>;
+    constructor(el: ElementRef, renderer: Renderer2);
+    onMouseEnter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TieredMenuItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TieredMenuItemDirective, "[appTieredMenuItem]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MagaryTieredMenu implements OnDestroy {
+    model: _angular_core.InputSignal<MenuItem[]>;
+    popup: _angular_core.InputSignal<boolean>;
+    style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    styleClass: _angular_core.InputSignal<string>;
+    visible: _angular_core.WritableSignal<boolean>;
+    target: any;
+    processedModel: _angular_core.Signal<MenuItem[]>;
+    private documentClickListener;
+    private renderer;
+    private el;
+    constructor();
+    toggle(event: Event): void;
+    show(event: Event): void;
+    hide(): void;
+    onMouseLeave(): void;
+    resetExpansion(items: MenuItem[]): void;
+    onItemClick(event: Event, item: MenuItem): void;
+    onItemHover(item: MenuItem): void;
+    handleHover(items: MenuItem[], targetItem: MenuItem): boolean;
+    isParentOf(parent: MenuItem, child: MenuItem): boolean;
+    onContainerClick(event: Event): void;
+    bindDocumentClickListener(): void;
+    unbindDocumentClickListener(): void;
+    positionOverlay(event: Event): void;
+    containerClass(): {
+        [x: string]: boolean;
+        'magary-tieredmenu': boolean;
+    };
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTieredMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTieredMenu, "magary-tiered-menu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "popup": { "alias": "popup"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryContextMenu implements AfterViewInit, OnDestroy {
+    private el;
+    private renderer;
+    model: _angular_core.InputSignal<MenuItem[]>;
+    style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    styleClass: _angular_core.InputSignal<string | null>;
+    global: _angular_core.InputSignal<boolean>;
+    target: _angular_core.InputSignal<any>;
+    visible: _angular_core.WritableSignal<boolean>;
+    x: _angular_core.WritableSignal<number>;
+    y: _angular_core.WritableSignal<number>;
+    containerViewChild: ElementRef;
+    private documentClickListener;
+    private documentResizeListener;
+    private contextMenuListener;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    bindGlobalListeners(): void;
+    bindTargetListeners(): void;
+    getTargetElement(): HTMLElement | null;
+    private document;
+    show(event: MouseEvent): void;
+    hide(): void;
+    bindDocumentClickListener(): void;
+    unbindDocumentClickListener(): void;
+    bindDocumentResizeListener(): void;
+    unbindDocumentResizeListener(): void;
+    unbindListeners(): void;
+    onItemClick(event: Event, item: MenuItem): void;
+    processedModel: _angular_core.Signal<MenuItem[]>;
+    resetExpansion(items: MenuItem[]): void;
+    closeSiblings(activeItem: MenuItem, parentItems: MenuItem[]): void;
+    containerClass(): {
+        [x: string]: boolean;
+        'magary-contextmenu': boolean;
+    };
+    onItemMouseEnter(item: MenuItem, parentItems: MenuItem[]): void;
+    onMouseLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryContextMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryContextMenu, "magary-context-menu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "global": { "alias": "global"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MenubarItemDirective {
+    private el;
+    item: _angular_core.InputSignal<MenuItem>;
+    parent: _angular_core.InputSignal<MagaryMenubar>;
+    constructor(el: ElementRef);
+    onMouseEnter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenubarItemDirective, "[appMenubarItem]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MagaryMenubar implements OnDestroy {
+    model: _angular_core.InputSignal<MenuItem[]>;
+    style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    styleClass: _angular_core.InputSignal<string>;
+    processedModel: _angular_core.Signal<MenuItem[]>;
+    private documentClickListener;
+    private renderer;
+    private el;
+    constructor();
+    onItemClick(event: Event, item: MenuItem): void;
+    onItemHover(item: MenuItem): void;
+    handleHover(items: MenuItem[], targetItem: MenuItem): boolean;
+    isParentOf(parent: MenuItem, child: MenuItem): boolean;
+    resetExpansion(items: MenuItem[]): void;
+    bindDocumentClickListener(): void;
+    unbindDocumentClickListener(): void;
+    containerClass(): {
+        [x: string]: boolean;
+        'magary-menubar': boolean;
+    };
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryMenubar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryMenubar, "magary-menubar", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MegaMenuItemDirective {
+    item: _angular_core.InputSignal<MenuItem>;
+    parent: _angular_core.InputSignal<MagaryMegaMenu>;
+    onMouseEnter(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MegaMenuItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MegaMenuItemDirective, "[appMegaMenuItem]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MagaryMegaMenu implements OnDestroy {
+    model: _angular_core.InputSignal<MenuItem[]>;
+    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    styleClass: _angular_core.InputSignal<string>;
+    processedModel: _angular_core.Signal<MenuItem[]>;
+    private documentClickListener;
+    private renderer;
+    el: ElementRef<any>;
+    private cdr;
+    constructor();
+    onItemClick(event: Event, item: MenuItem): void;
+    onItemHover(item: MenuItem): void;
+    resetExpansion(items: MenuItem[]): void;
+    bindDocumentClickListener(): void;
+    unbindDocumentClickListener(): void;
+    containerClass(): {
+        [x: string]: boolean;
+        'magary-megamenu': boolean;
+        'magary-megamenu-horizontal': boolean;
+        'magary-megamenu-vertical': boolean;
+    };
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryMegaMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryMegaMenu, "magary-megamenu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagarySlideMenu {
+    model: _angular_core.InputSignal<MenuItem[]>;
+    style: _angular_core.InputSignal<{
+        [klass: string]: any;
+    } | null>;
+    styleClass: _angular_core.InputSignal<string>;
+    menuWidth: _angular_core.InputSignal<string | number>;
+    viewportHeight: _angular_core.InputSignal<string | number>;
+    viewStack: _angular_core.WritableSignal<MenuItem[][]>;
+    currentIndex: _angular_core.WritableSignal<number>;
+    private cdr;
+    constructor();
+    get currentItems(): MenuItem[];
+    headerStack: _angular_core.WritableSignal<string[]>;
+    get currentHeader(): string;
+    onItemClick(event: Event, item: MenuItem): void;
+    goBack(): void;
+    containerStyle(): {
+        width: string | number;
+        height: string | number;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySlideMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySlideMenu, "magary-slidemenu", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "menuWidth": { "alias": "menuWidth"; "required": false; "isSignal": true; }; "viewportHeight": { "alias": "viewportHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryToast {
+    private toastService;
+    position: _angular_core.InputSignal<"center" | "top-right" | "top-left" | "bottom-right" | "bottom-left" | "top-center" | "bottom-center">;
+    baseZIndex: _angular_core.InputSignal<number>;
+    get toasts(): ng_magary.Toast[];
+    onToastClose(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryToast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryToast, "magary-toast", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "baseZIndex": { "alias": "baseZIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface Toast {
+    id?: string;
+    type?: 'success' | 'info' | 'warning' | 'error';
+    title?: string;
+    message?: string;
+    icon?: string;
+    duration?: number;
+    life?: number;
+    sticky?: boolean;
+    data?: any;
+}
+declare class MagaryToastService {
+    private _toasts;
+    readonly toasts: _angular_core.Signal<Toast[]>;
+    add(toast: Toast): void;
+    remove(id: string): void;
+    clear(): void;
+    private generateId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MagaryToastService>;
+}
+
+declare class MagaryToastItem {
+    toast: _angular_core.InputSignal<Toast>;
+    onClose: _angular_core.OutputEmitterRef<string>;
+    iconClass: _angular_core.Signal<string>;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryToastItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryToastItem, "magary-toast-item", never, { "toast": { "alias": "toast"; "required": true; "isSignal": true; }; }, { "onClose": "onClose"; }, never, never, true, never>;
+}
+
+declare class MagaryToastModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryToastModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryToastModule, never, [typeof MagaryToast, typeof MagaryToastItem], [typeof MagaryToast, typeof MagaryToastItem]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryToastModule>;
+}
+
+declare class MagaryMessage implements OnInit {
+    severity: _angular_core.InputSignal<"secondary" | "success" | "info" | "contrast" | "error" | "warn">;
+    text: _angular_core.InputSignal<string | undefined>;
+    detail: _angular_core.InputSignal<string | undefined>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    closable: _angular_core.InputSignal<boolean>;
+    life: _angular_core.InputSignal<number | undefined>;
+    onClose: _angular_core.OutputEmitterRef<Event>;
+    visible: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    iconClass: _angular_core.Signal<string>;
+    close(event: Event | null): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryMessage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryMessage, "magary-message", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "detail": { "alias": "detail"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "life": { "alias": "life"; "required": false; "isSignal": true; }; }, { "onClose": "onClose"; }, never, never, true, never>;
+}
+
+declare class MagaryMessageModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryMessageModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryMessageModule, never, [typeof MagaryMessage], [typeof MagaryMessage]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryMessageModule>;
+}
+
+declare class MagaryAvatarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryAvatarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryAvatarModule, never, [typeof i1.CommonModule, typeof MagaryAvatar], [typeof MagaryAvatar]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryAvatarModule>;
+}
+
+declare class MagarySkeleton {
+    shape: _angular_core.InputSignal<"circle" | "rectangle">;
+    size: _angular_core.InputSignal<string | null>;
+    width: _angular_core.InputSignal<string>;
+    height: _angular_core.InputSignal<string>;
+    borderRadius: _angular_core.InputSignal<string>;
+    animation: _angular_core.InputSignal<"shimmer" | "none">;
+    styleClass: _angular_core.InputSignal<string>;
+    readonly styles: _angular_core.Signal<{
+        width: string;
+        height: string;
+        'border-radius': string;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagarySkeleton, "magary-skeleton", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagarySkeletonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagarySkeletonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagarySkeletonModule, never, [typeof i1.CommonModule, typeof MagarySkeleton], [typeof MagarySkeleton]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagarySkeletonModule>;
+}
+
+type DividerLayout = 'horizontal' | 'vertical';
+type DividerAlign = 'left' | 'center' | 'right' | 'top' | 'bottom';
+type DividerType = 'solid' | 'dashed' | 'dotted';
+declare class MagaryDivider {
+    layout: _angular_core.InputSignal<DividerLayout>;
+    align: _angular_core.InputSignal<DividerAlign>;
+    type: _angular_core.InputSignal<DividerType>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryDivider, "magary-divider", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type TagSeverity = 'success' | 'info' | 'warning' | 'danger' | 'secondary' | 'contrast';
+declare class MagaryTag {
+    severity: _angular_core.InputSignal<TagSeverity>;
+    value: _angular_core.InputSignal<string | undefined>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    rounded: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTag, "magary-tag", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MagaryTooltip implements OnDestroy {
+    private el;
+    private renderer;
+    private zone;
+    private document;
+    text: _angular_core.InputSignal<string | undefined>;
+    tooltipPosition: _angular_core.InputSignal<"left" | "right" | "top" | "bottom">;
+    private tooltipElement;
+    private scrollUnlisten;
+    private resizeUnlisten;
+    constructor(el: ElementRef, renderer: Renderer2, zone: NgZone, document: Document);
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    show(): void;
+    hide(): void;
+    create(): void;
+    align(): void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MagaryTooltip, "[magaryTooltip]", never, { "text": { "alias": "magaryTooltip"; "required": false; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryTooltipModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTooltipModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryTooltipModule, never, [typeof MagaryTooltip], [typeof MagaryTooltip]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryTooltipModule>;
+}
+
+declare class MagaryDialog {
+    visible: _angular_core.ModelSignal<boolean>;
+    header: _angular_core.InputSignal<string | undefined>;
+    draggable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    resizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeOnEscape: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    dismissableMask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    maximizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    style: _angular_core.InputSignal<any>;
+    contentStyle: _angular_core.InputSignal<any>;
+    styleClass: _angular_core.InputSignal<string | undefined>;
+    appendTo: _angular_core.InputSignal<"body" | "local">;
+    width: _angular_core.InputSignal<string | undefined>;
+    height: _angular_core.InputSignal<string | undefined>;
+    position: _angular_core.InputSignal<"left" | "right" | "top" | "bottom" | "center" | "top-right" | "top-left" | "bottom-right" | "bottom-left">;
+    backgroundColor: _angular_core.InputSignal<string | undefined>;
+    glass: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    onShow: _angular_core.OutputEmitterRef<AnimationEvent>;
+    onHide: _angular_core.OutputEmitterRef<AnimationEvent>;
+    containerViewChild: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    contentViewChild: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    headerViewChild: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    maximized: _angular_core.WritableSignal<boolean>;
+    resizing: _angular_core.WritableSignal<boolean>;
+    dragging: _angular_core.WritableSignal<boolean>;
+    private lastPageX;
+    private lastPageY;
+    private startWidth;
+    private startHeight;
+    private startX;
+    private startY;
+    private documentMouseMoveListener;
+    private documentMouseUpListener;
+    el: ElementRef<any>;
+    renderer: Renderer2;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    close(event: Event): void;
+    maximize(event: Event): void;
+    onMaskClick(event: MouseEvent): void;
+    initDrag(event: MouseEvent): void;
+    onDrag(event: MouseEvent): void;
+    endDrag(): void;
+    initResize(event: MouseEvent): void;
+    onResize(event: MouseEvent): void;
+    endResize(): void;
+    private bindGlobalListeners;
+    private unbindGlobalListeners;
+    private blockBodyScroll;
+    private unblockBodyScroll;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryDialog, "magary-dialog", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "dismissableMask": { "alias": "dismissableMask"; "required": false; "isSignal": true; }; "maximizable": { "alias": "maximizable"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; "contentStyle": { "alias": "contentStyle"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "appendTo": { "alias": "appendTo"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "glass": { "alias": "glass"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "onShow": "onShow"; "onHide": "onHide"; }, never, ["*", "[slot=footer]", "p-footer"], true, never>;
+}
+
+declare class MagaryDialogModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryDialogModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryDialogModule, never, [typeof MagaryDialog], [typeof MagaryDialog]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryDialogModule>;
+}
+
+declare class MagaryOverlayPanel implements OnDestroy {
+    dismissable: _angular_core.WritableSignal<boolean>;
+    showCloseIcon: _angular_core.WritableSignal<boolean>;
+    set _dismissable(val: boolean);
+    set _showCloseIcon(val: boolean);
+    onShow: EventEmitter<any>;
+    onHide: EventEmitter<any>;
+    container: ElementRef | undefined;
+    visible: _angular_core.WritableSignal<boolean>;
+    target: any;
+    documentClickListener: any;
+    scrollListener: any;
+    cd: ChangeDetectorRef;
+    renderer: Renderer2;
+    el: ElementRef<any>;
+    document: Document;
+    toggle(event: Event, target?: any): void;
+    show(event: Event, target?: any): void;
+    hide(): void;
+    alignWithTarget(): void;
+    bindScrollListener(): void;
+    unbindScrollListener(): void;
+    bindDocumentClickListener(): void;
+    unbindDocumentClickListener(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryOverlayPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryOverlayPanel, "magary-overlaypanel", never, { "_dismissable": { "alias": "dismissable"; "required": false; }; "_showCloseIcon": { "alias": "showCloseIcon"; "required": false; }; }, { "onShow": "onShow"; "onHide": "onHide"; }, never, ["*"], true, never>;
+}
+
+interface Confirmation {
+    message?: string;
+    key?: string;
+    icon?: string;
+    header?: string;
+    accept?: Function;
+    reject?: Function;
+    acceptLabel?: string;
+    rejectLabel?: string;
+    acceptVisible?: boolean;
+    rejectVisible?: boolean;
+    acceptButtonStyleClass?: string;
+    rejectButtonStyleClass?: string;
+    style?: any;
+    styleClass?: string;
+    defaultFocus?: 'accept' | 'reject' | 'none';
+}
+declare class MagaryConfirmationService {
+    private requireConfirmationSource;
+    private acceptConfirmationSource;
+    requireConfirmation$: rxjs.Observable<Confirmation>;
+    acceptConfirmation$: rxjs.Observable<Confirmation>;
+    confirm(confirmation: Confirmation): this;
+    close(): this;
+    onAccept(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryConfirmationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MagaryConfirmationService>;
+}
+
+declare class MagaryConfirmDialog implements OnDestroy {
+    header: _angular_core.InputSignal<string | undefined>;
+    icon: _angular_core.InputSignal<string | undefined>;
+    message: _angular_core.InputSignal<string | undefined>;
+    key: _angular_core.InputSignal<string | undefined>;
+    acceptLabel: _angular_core.InputSignal<string>;
+    rejectLabel: _angular_core.InputSignal<string>;
+    acceptIcon: _angular_core.InputSignal<string | undefined>;
+    rejectIcon: _angular_core.InputSignal<string | undefined>;
+    acceptVisible: _angular_core.InputSignal<boolean>;
+    rejectVisible: _angular_core.InputSignal<boolean>;
+    dismissableMask: _angular_core.InputSignal<boolean>;
+    closeOnEscape: _angular_core.InputSignal<boolean>;
+    visible: _angular_core.WritableSignal<boolean>;
+    confirmation: _angular_core.WritableSignal<Confirmation | null>;
+    private subscription;
+    private confirmationService;
+    constructor();
+    accept(): void;
+    reject(): void;
+    hide(): void;
+    effectiveHeader: _angular_core.Signal<string | undefined>;
+    effectiveMessage: _angular_core.Signal<string | undefined>;
+    effectiveIcon: _angular_core.Signal<string | undefined>;
+    effectiveAcceptLabel: _angular_core.Signal<string>;
+    effectiveRejectLabel: _angular_core.Signal<string>;
+    effectiveAcceptVisible: _angular_core.Signal<boolean | undefined>;
+    effectiveRejectVisible: _angular_core.Signal<boolean | undefined>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryConfirmDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryConfirmDialog, "magary-confirm-dialog", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": false; "isSignal": true; }; "acceptLabel": { "alias": "acceptLabel"; "required": false; "isSignal": true; }; "rejectLabel": { "alias": "rejectLabel"; "required": false; "isSignal": true; }; "acceptIcon": { "alias": "acceptIcon"; "required": false; "isSignal": true; }; "rejectIcon": { "alias": "rejectIcon"; "required": false; "isSignal": true; }; "acceptVisible": { "alias": "acceptVisible"; "required": false; "isSignal": true; }; "rejectVisible": { "alias": "rejectVisible"; "required": false; "isSignal": true; }; "dismissableMask": { "alias": "dismissableMask"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MagaryConfirmDialogModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryConfirmDialogModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MagaryConfirmDialogModule, never, [typeof MagaryConfirmDialog], [typeof MagaryConfirmDialog]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MagaryConfirmDialogModule>;
+}
+
+type ImagePosition = 'left' | 'right' | 'top' | 'bottom';
+type ShadowLevel = 0 | 1 | 2 | 3 | 4 | 5;
+type CardVariant = 'elevated' | 'outlined' | 'filled';
+declare class MagaryCard {
+    readonly img: _angular_core.InputSignal<string | undefined>;
+    readonly positionImage: _angular_core.InputSignal<ImagePosition>;
+    readonly shadow: _angular_core.InputSignal<ShadowLevel>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly padding: _angular_core.InputSignal<string>;
+    readonly gap: _angular_core.InputSignal<string>;
+    readonly borderRadius: _angular_core.InputSignal<string>;
+    readonly imageSize: _angular_core.InputSignal<string>;
+    readonly backgroundColor: _angular_core.InputSignal<string | undefined>;
+    readonly responsive: _angular_core.InputSignal<boolean>;
+    readonly altText: _angular_core.InputSignal<string>;
+    readonly imageFit: _angular_core.InputSignal<"none" | "fill" | "cover" | "contain" | "scale-down">;
+    readonly clickable: _angular_core.InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly variant: _angular_core.InputSignal<CardVariant>;
+    readonly loadingText: _angular_core.InputSignal<string>;
+    readonly hoverEffect: _angular_core.InputSignal<boolean>;
+    readonly badge: _angular_core.InputSignal<string | undefined>;
+    readonly badgeColor: _angular_core.InputSignal<string>;
+    readonly border: _angular_core.InputSignal<string | undefined>;
+    readonly cardClasses: _angular_core.Signal<string[]>;
+    readonly cardStyles: _angular_core.Signal<{
+        cursor: string;
+        opacity: string;
+        'pointer-events': string;
+        border?: string | undefined;
+        width: string;
+        height: string;
+        '--card-bg': string;
+        '--card-radius': string;
+        '--card-gap': string;
+        '--card-padding': string;
+        '--img-size': string;
+        '--badge-color': string;
+    }>;
+    readonly imageStyles: _angular_core.Signal<{
+        'object-fit': "none" | "fill" | "cover" | "contain" | "scale-down";
+    }>;
+    readonly hasImage: _angular_core.Signal<boolean>;
+    readonly isHorizontalLayout: _angular_core.Signal<boolean>;
+    readonly isInteractive: _angular_core.Signal<boolean>;
+    readonly showLoadingOverlay: _angular_core.Signal<boolean>;
+    onCardClick(event: Event): void;
+    onCardKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryCard, "magary-card", never, { "img": { "alias": "img"; "required": false; "isSignal": true; }; "positionImage": { "alias": "positionImage"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "imageSize": { "alias": "imageSize"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "altText": { "alias": "altText"; "required": false; "isSignal": true; }; "imageFit": { "alias": "imageFit"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "hoverEffect": { "alias": "hoverEffect"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "badgeColor": { "alias": "badgeColor"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; }, {}, never, ["[slot='header']", "*", "[slot='footer']"], true, never>;
+}
+
+declare class MagaryFieldset {
+    legend: _angular_core.InputSignal<string>;
+    toggleable: _angular_core.InputSignal<boolean>;
+    collapsed: _angular_core.ModelSignal<boolean>;
+    onBeforeToggle: _angular_core.OutputEmitterRef<any>;
+    onAfterToggle: _angular_core.OutputEmitterRef<any>;
+    toggle(event: Event): void;
+    expand(event: Event): void;
+    collapse(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryFieldset, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryFieldset, "magary-fieldset", never, { "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; "onBeforeToggle": "onBeforeToggle"; "onAfterToggle": "onAfterToggle"; }, never, ["*"], true, never>;
+}
+
+declare class MagaryTab {
+    label: _angular_core.InputSignal<string>;
+    active: _angular_core.WritableSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTab, "magary-tab", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class MagaryTabs implements OnInit {
+    tabs: _angular_core.Signal<readonly MagaryTab[]>;
+    headersRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    buttonsRef: _angular_core.Signal<readonly ElementRef<HTMLElement>[]>;
+    activeIndex: _angular_core.WritableSignal<number>;
+    backgroundLine: _angular_core.InputSignal<string>;
+    positionContent: _angular_core.InputSignal<string>;
+    background: _angular_core.InputSignal<string>;
+    padding: _angular_core.InputSignal<string>;
+    heightLine: _angular_core.InputSignal<string>;
+    private resizeObserver;
+    private el;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    selectTab(index: number): void;
+    private updateUnderlinePosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryTabs, "magary-tabs", never, { "backgroundLine": { "alias": "backgroundLine"; "required": false; "isSignal": true; }; "positionContent": { "alias": "positionContent"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "heightLine": { "alias": "heightLine"; "required": false; "isSignal": true; }; }, {}, ["tabs"], ["*"], true, never>;
+}
+
+declare class MagaryToolbar {
+    style: _angular_core.InputSignal<any>;
+    styleClass: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryToolbar, "magary-toolbar", never, { "style": { "alias": "style"; "required": false; "isSignal": true; }; "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; }, {}, never, ["[start]", "[center]", "[end]", "*"], true, never>;
+}
+
+declare class MagaryAccordionTab {
+    header: _angular_core.InputSignal<string | undefined>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    selected: _angular_core.ModelSignal<boolean>;
+    accordion: MagaryAccordion | undefined;
+    toggle(event: Event): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryAccordionTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryAccordionTab, "magary-accordion-tab", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, never, ["[header]", "*"], true, never>;
+}
+
+declare class MagaryAccordion {
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    tabs: _angular_core.Signal<readonly MagaryAccordionTab[]>;
+    onClose: _angular_core.OutputEmitterRef<any>;
+    onOpen: _angular_core.OutputEmitterRef<any>;
+    constructor();
+    handleTabChange(changedTab: MagaryAccordionTab, isSelected: boolean): void;
+    findTabIndex(tab: MagaryAccordionTab): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryAccordion, "magary-accordion", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; }, { "onClose": "onClose"; "onOpen": "onOpen"; }, ["tabs"], ["*"], true, never>;
+}
+
+type Theme = 'light' | 'dark' | 'purple' | 'green';
+declare class MagaryThemeService {
+    private readonly platformId;
+    readonly currentTheme: _angular_core.WritableSignal<Theme>;
+    constructor();
+    private initializeTheme;
+    private applyTheme;
+    toggleTheme(): void;
+    setTheme(theme: Theme): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MagaryThemeService>;
+}
+
+declare class MagaryGrid implements AfterViewInit, OnDestroy {
+    gridStackContainer: ElementRef;
+    options: _angular_core.InputSignal<GridStackOptions>;
+    change: _angular_core.OutputEmitterRef<any>;
+    added: _angular_core.OutputEmitterRef<any>;
+    removed: _angular_core.OutputEmitterRef<any>;
+    private grid?;
+    ngAfterViewInit(): void;
+    private bindEvents;
+    ngOnDestroy(): void;
+    getGridInstance(): GridStack | undefined;
+    registerWidget(element: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryGrid, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryGrid, "magary-grid", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, { "change": "change"; "added": "added"; "removed": "removed"; }, never, ["*"], true, never>;
+}
+
+declare class MagaryGridItem implements OnInit {
+    private el;
+    x: _angular_core.InputSignal<number | undefined>;
+    y: _angular_core.InputSignal<number | undefined>;
+    w: _angular_core.InputSignal<number | undefined>;
+    h: _angular_core.InputSignal<number | undefined>;
+    id: _angular_core.InputSignal<string | undefined>;
+    noResize: _angular_core.InputSignal<boolean>;
+    noMove: _angular_core.InputSignal<boolean>;
+    locked: _angular_core.InputSignal<boolean>;
+    private parentGrid;
+    constructor(el: ElementRef);
+    ngOnInit(): void;
+    private updateAttribute;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MagaryGridItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MagaryGridItem, "magary-grid-item", never, { "x": { "alias": "x"; "required": false; "isSignal": true; }; "y": { "alias": "y"; "required": false; "isSignal": true; }; "w": { "alias": "w"; "required": false; "isSignal": true; }; "h": { "alias": "h"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "noResize": { "alias": "noResize"; "required": false; "isSignal": true; }; "noMove": { "alias": "noMove"; "required": false; "isSignal": true; }; "locked": { "alias": "locked"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const MAGARY_VERSION = "0.0.7";
+
+export { CarouselIconsModule, GalleriaIconsModule, INPUTNUMBER_VALUE_ACCESSOR, MAGARY_VERSION, MagaryAccordion, MagaryAccordionTab, MagaryAvatar, MagaryAvatarModule, MagaryBreadcrumb, MagaryButton, MagaryButtonModule, MagaryCard, MagaryCarouselComponent as MagaryCarousel, MagaryCarouselComponent, MagaryCascadeSelect, MagaryCascadeSelectModule, MagaryCheckbox, MagaryCheckboxModule, MagaryConfirmDialog, MagaryConfirmDialogModule, MagaryConfirmationService, MagaryContextMenu, MagaryDataView, MagaryDatePicker, MagaryDatePickerModule, MagaryDialog, MagaryDialogModule, MagaryDivider, MagaryFieldset, MagaryGalleria, MagaryGrid, MagaryGridItem, MagaryImage, MagaryImageModule, MagaryInput, MagaryInputModule, MagaryInputNumber, MagaryMegaMenu, MagaryMenubar, MagaryMessage, MagaryMessageModule, MagaryOrderList, MagaryOrganizationChart, MagaryOrganizationChartNode, MagaryOverlayPanel, MagaryPaginator, MagaryPanelMenuModule, MagaryPanelmenu, MagaryPickList, MagaryRadioButton, MagaryRadioButtonModule, MagaryRadioGroup, MagaryRating, MagarySelect, MagarySelectModule, MagarySidebarModule, MagarySkeleton, MagarySkeletonModule, MagarySlideMenu, MagarySlider, MagarySpeedDial, MagarySpeedDialModule, MagarySplitButton, MagarySteps, MagarySwitch, MagarySwitchModule, MagaryTab, MagaryTable, MagaryTableModule, MagaryTabs, MagaryTag, MagaryTextArea, MagaryTextAreaModule, MagaryThemeService, MagaryTieredMenu, MagaryTimeline, MagaryToast, MagaryToastItem, MagaryToastModule, MagaryToastService, MagaryToolbar, MagaryTooltip, MagaryTooltipModule, MagaryTree, MagaryUITreeNode, MagaryUpload, MagaryUploadModule, MegaMenuItemDirective, MenubarItemDirective, RATING_VALUE_ACCESSOR, SLIDER_VALUE_ACCESSOR, Sidebar, TieredMenuItemDirective };
+export type { AvatarClickEvent, AvatarShape, AvatarSize, BadgeSeverity, BreadcrumbItem, CarouselAutoplayDirection, CarouselEffect, CarouselIndicatorPosition, CarouselIndicatorStyle, CarouselItemContext, CarouselNavPosition, CarouselNavStyle, CarouselOrientation, CarouselPreloadStrategy, CarouselResponsiveOptions, CarouselSlideEvent, Confirmation, DividerAlign, DividerLayout, DividerType, GalleriaItem, GalleriaResponsiveOptions, InputSize, InputType, InputVariant, MagaryTableColumn, MagaryTreeNode, MenuItem, MenuItemClickEvent, MenuToggleEvent, PaginatorState, SpeedDialItem, StepsItem, TagSeverity, Theme, Toast, UploadEvent };