import * as _angular_core from '@angular/core'; import { EventEmitter, TemplateRef, InjectionToken, OnDestroy, OnInit, ElementRef, Signal, ViewContainerRef, Injector, Binding, Type, ComponentRef, AfterViewInit, EnvironmentProviders, OnChanges, SimpleChanges, NgZone, QueryList, TrackByFunction, KeyValueChangeRecord, OutputEmitterRef, WritableSignal, AfterContentInit, PipeTransform } from '@angular/core'; import * as rxjs from 'rxjs'; import { Observable, Subject } from 'rxjs'; import { DialogPosition, MatDialogRef, MatDialogState } from '@angular/material/dialog'; import { ScrollStrategy } from '@angular/cdk/overlay'; import * as _acontplus_ng_components from '@acontplus/ng-components'; import { FormControl, ControlValueAccessor, FormGroup } from '@angular/forms'; import { SelectOption, IconDefinition, ButtonVariant, ButtonType, MaterialButtonStyle, REPORT_FORMAT } from '@acontplus/ui-kit'; import { SafeHtml } from '@angular/platform-browser'; import { MatChipInputEvent, MatChipEditedEvent } from '@angular/material/chips'; import { LiveAnnouncer, FocusOrigin } from '@angular/cdk/a11y'; import { Tabulator } from 'tabulator-tables'; import { MatTable, MatRowDef, MatHeaderRowDef, MatFooterRowDef, MatTableDataSource } from '@angular/material/table'; import { MatPaginator, PageEvent } from '@angular/material/paginator'; import { SortDirection, MatSort, Sort } from '@angular/material/sort'; import { SelectionModel } from '@angular/cdk/collections'; import { MatBadgePosition, MatBadgeSize } from '@angular/material/badge'; import { MatButtonAppearance } from '@angular/material/button'; import { ThemePalette } from '@angular/material/core'; import { TooltipPosition, TooltipTouchGestures } from '@angular/material/tooltip'; import { CdkDragDrop } from '@angular/cdk/drag-drop'; import { MatMenu, MatMenuTrigger } from '@angular/material/menu'; import { NgxDatexLocale, NgxDatexTheme, NgxDatexValue } from 'ngx-datex'; export { MATERIAL_LIGHT_THEME, NgxDatex, NgxDatexConfig, NgxDatexLocale, NgxDatexRange, NgxDatexTheme, NgxDatexValue, SPANISH_LOCALE } from 'ngx-datex'; import { ComponentType } from '@angular/cdk/portal'; import { Direction } from '@angular/cdk/bidi'; import { DialogRole, CdkDialogContainer, DialogRef } from '@angular/cdk/dialog'; import { DateRange, MatCalendar } from '@angular/material/datepicker'; import { MatCheckbox, MatCheckboxChange } from '@angular/material/checkbox'; import { MatSidenav, MatSidenavContent } from '@angular/material/sidenav'; import { RouterLinkActive } from '@angular/router'; type AcpAlertType = 'default' | 'info' | 'success' | 'warning' | 'danger'; declare class AcpAlert { private _changeDetectorRef; get hostClassList(): string; /** The alert's type. Can be `default`, `info`, `success`, `warning` or `danger`. */ type: AcpAlertType; /** Whether to display an inline close button. */ dismissible: boolean; /** The alert's elevation (0~24). */ elevation: number; /** Event emitted when the alert closed. */ closed: EventEmitter; _onClosed(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; static ngAcceptInputType_dismissible: unknown; } type AcpBadgeColor = 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger' | 'info' | 'neutral' | 'custom'; type AcpBadgeVariant = 'filled' | 'outlined' | 'soft' | 'tonal' | 'text'; type AcpBadgeSize = 'xs' | 'sm' | 'md' | 'lg'; type AcpBadgeShape = 'rounded' | 'pill' | 'square'; type AcpBadgeTrend = 'up' | 'down' | 'neutral' | 'none'; interface AcpBadgeTrendConfig { value: string; icon: string; color: AcpBadgeColor; } declare class AcpBadge { label: _angular_core.InputSignal; value: _angular_core.InputSignal; variant: _angular_core.InputSignal; color: _angular_core.InputSignal; size: _angular_core.InputSignal; shape: _angular_core.InputSignal; icon: _angular_core.InputSignal; trailingIcon: _angular_core.InputSignal; svgIcon: _angular_core.InputSignal; trailingSvgIcon: _angular_core.InputSignal; trend: _angular_core.InputSignal; clickable: _angular_core.InputSignalWithTransform; disabled: _angular_core.InputSignalWithTransform; loading: _angular_core.InputSignalWithTransform; selected: _angular_core.InputSignalWithTransform; highlighted: _angular_core.InputSignalWithTransform; removable: _angular_core.InputSignalWithTransform; routerLink: _angular_core.InputSignal; href: _angular_core.InputSignal; ariaLabelOverride: _angular_core.InputSignal; clicked: _angular_core.OutputEmitterRef; removed: _angular_core.OutputEmitterRef; iconTemplate: _angular_core.Signal | undefined>; trailingIconTemplate: _angular_core.Signal | undefined>; private isTrending; private trendConfig; effectiveColor: _angular_core.Signal; effectiveIcon: _angular_core.Signal; effectiveSvgIcon: _angular_core.Signal; effectiveTrailingIcon: _angular_core.Signal; effectiveTrailingSvgIcon: _angular_core.Signal; effectiveValue: _angular_core.Signal; isLink: _angular_core.Signal; isInteractive: _angular_core.Signal; isDisabled: _angular_core.Signal; isHighlighted: _angular_core.Signal; chipClasses: _angular_core.Signal; hostClasses: _angular_core.Signal; ariaLabel: _angular_core.Signal; onChipClick(event: MouseEvent): void; onRemove(_event: any): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare const ACP_BADGE_COLORS: AcpBadgeColor[]; declare const ACP_BADGE_VARIANTS: AcpBadgeVariant[]; declare const ACP_BADGE_SIZES: AcpBadgeSize[]; declare const ACP_BADGE_SHAPES: AcpBadgeShape[]; declare const TREND_CONFIGS: Record; /** * A versatile card component that wraps Angular Material's mat-card with additional functionality * and customization options. This component provides a consistent card layout with configurable * header, content, and action areas. */ declare class DynamicCard { /** * The title text to display in the card header. * @default null */ cardTitle: _angular_core.InputSignal; /** * The subtitle text to display in the card header. * @default null */ cardSubtitle: _angular_core.InputSignal; /** * URL for the avatar image to display in the card header. * @default null */ avatarImageUrl: _angular_core.InputSignal; /** * Whether to show the card header section. * @default false */ isHeaderVisible: _angular_core.InputSignalWithTransform; /** * CSS padding value for the card content area. * @default '1rem' */ contentPadding: _angular_core.InputSignal; /** * Whether to show a divider between the header and content sections. * @default false */ hasDivider: _angular_core.InputSignalWithTransform; /** * Whether to show the action buttons section. * @default false */ areActionsVisible: _angular_core.InputSignalWithTransform; /** * Text for the primary action button. * @default 'Confirm' */ primaryButtonText: _angular_core.InputSignal; /** * Text for the secondary action button. * @default 'Cancel' */ secondaryButtonText: _angular_core.InputSignal; /** * Material icon name for the primary button. * @default null */ primaryButtonIcon: _angular_core.InputSignal; /** * Material icon name for the secondary button. * @default null */ secondaryButtonIcon: _angular_core.InputSignal; /** * Alignment of the action buttons. * @default 'end' */ buttonsPosition: _angular_core.InputSignal<"start" | "end">; /** * Event emitted when the primary button is clicked. */ primaryButtonClicked: _angular_core.OutputEmitterRef; /** * Event emitted when the secondary button is clicked. */ secondaryButtonClicked: _angular_core.OutputEmitterRef; /** * Event emitted when the card is clicked. */ cardClicked: _angular_core.OutputEmitterRef; /** * Event emitted when a key is pressed down on the card. */ keyDown: _angular_core.OutputEmitterRef; /** * Event emitted when a key is released on the card. */ keyUp: _angular_core.OutputEmitterRef; /** * Event emitted when a key is pressed on the card. */ keyPress: _angular_core.OutputEmitterRef; /** * Handles the primary button click event. * Stops event propagation and emits the primaryButtonClicked event. * @param event The click event */ handlePrimaryButtonClick(event: Event): void; /** * Handles the secondary button click event. * Stops event propagation and emits the secondaryButtonClicked event. * @param event The click event */ handleSecondaryButtonClick(event: Event): void; /** * Handles the card click event. * Emits the cardClicked event with the original event. * @param event The click event */ handleCardClick(event: Event): void; /** * Handles the key down event on the card. * Emits the keyDown event with the original keyboard event. * @param event The keyboard event */ handleKeyDown(event: KeyboardEvent): void; /** * Handles the key up event on the card. * Emits the keyUp event with the original keyboard event. * @param event The keyboard event */ handleKeyUp(event: KeyboardEvent): void; /** * Handles the key press event on the card. * Emits the keyPress event with the original keyboard event. * @param event The keyboard event */ handleKeyPress(event: KeyboardEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Context Menu Types and Interfaces * Defines the API contract for the ContextMenu component */ /** * Represents a single item in the context menu */ interface AcpContextMenuItem { /** Unique identifier for the menu item */ id?: string; /** Display label for the menu item (not required for separators) */ label?: string; /** Material Icon name or SVG icon identifier */ icon?: string; /** Badge text or number to display */ badge?: string | number; /** Keyboard shortcut text to display (e.g., 'Ctrl+S') */ shortcut?: string; /** Whether the menu item is disabled */ disabled?: boolean; /** Whether the menu item is visible */ visible?: boolean; /** Whether this is a separator line (ignores other properties) */ separator?: boolean; /** Nested menu items for submenu support */ children?: AcpContextMenuItem[]; /** Callback function when item is clicked */ command?: (context: AcpContextMenuItemContext) => void; /** Router link for navigation */ routerLink?: any; /** External URL to navigate to */ url?: string; /** Target for URL navigation (_blank, _self, etc) */ target?: string; /** Whether this is a dangerous action (e.g., delete) */ danger?: boolean; /** Whether the item is in loading state */ loading?: boolean; /** Tooltip text for the menu item */ tooltip?: string; /** Custom data associated with the menu item */ data?: unknown; /** CSS class to apply to the menu item */ class?: string; /** Whether to close menu after executing command */ closeOnClick?: boolean; } /** * Context passed to the command callback */ interface AcpContextMenuItemContext { /** The menu item that was clicked */ item: AcpContextMenuItem; /** The event that triggered the action */ event: MouseEvent | KeyboardEvent; /** The element that triggered the context menu */ element?: HTMLElement; /** Custom data passed to the context menu */ data?: unknown; /** Row data (for DataGrid integration) */ row?: unknown; /** Column data (for DataGrid integration) */ column?: unknown; /** Row index (for DataGrid integration) */ index?: number; } /** * Configuration for opening a context menu */ interface AcpContextMenuOpenConfig { /** X coordinate for menu position */ x: number; /** Y coordinate for menu position */ y: number; /** Element to position relative to (if not using x/y) */ element?: HTMLElement; /** Custom data to pass to menu items */ data?: unknown; /** Close menu when clicking outside */ closeOnOutsideClick?: boolean; /** Close menu when pressing Escape */ closeOnEscape?: boolean; /** Custom CSS classes for the menu panel */ panelClass?: string | string[]; /** Z-index for the menu overlay */ zIndex?: number; } /** * Configuration for the context menu trigger */ interface AcpContextMenuTriggerConfig { /** Trigger on right-click (contextmenu event) */ rightClick?: boolean; /** Trigger on left-click */ leftClick?: boolean; /** Trigger on hover */ hover?: boolean; /** Delay before opening on hover (ms) */ hoverDelay?: number; /** Delay before closing on hover leave (ms) */ hoverLeaveDelay?: number; /** Custom data to pass to menu items */ data?: unknown; /** Close menu when clicking outside */ closeOnOutsideClick?: boolean; /** Close menu when pressing Escape */ closeOnEscape?: boolean; } /** * Position strategy for the context menu */ type AcpContextMenuPosition = 'auto' | 'above' | 'below' | 'left' | 'right'; /** * Reference to an open context menu */ interface AcpContextMenuRef { /** Close the context menu */ close(): void; /** Update menu items */ updateItems(items: AcpContextMenuItem[]): void; /** Get current menu items */ getItems(): AcpContextMenuItem[]; /** Update context data */ updateData(data: unknown): void; /** Get current context data */ getData(): unknown; /** Check if menu is open */ isOpen(): boolean; } declare const CONTEXT_MENU_ITEMS: InjectionToken; declare const CONTEXT_MENU_DATA: InjectionToken; /** * Service to manage context menu instances * Handles overlay creation, positioning, and lifecycle management */ declare class AcpContextMenuService { private readonly overlay; private readonly ngZone; private readonly document; private readonly injector; private readonly openMenuRef; private readonly menuItems; private readonly contextData; private readonly itemSelected$; constructor(); /** * Open a context menu at the specified position */ open(items: AcpContextMenuItem[], config: AcpContextMenuOpenConfig): Promise; /** * Close all open context menus */ closeAll(): void; /** * Check if any menu is open */ isOpen(): boolean; /** * Get the item selection subject */ getItemSelected$(): rxjs.Observable; /** * Emit item selection */ selectItem(context: AcpContextMenuItemContext): void; /** * Create overlay reference with position strategy */ private createOverlay; /** * Create position strategy for the overlay */ private createPositionStrategy; /** * Create injector for the menu component */ private createInjector; /** * Create menu reference object */ private createMenuRef; /** * Setup handler for closing menu on outside click */ private setupOutsideClickHandler; /** * Check if click is inside the menu */ private isClickInsideMenu; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Directive to attach a context menu to any element * * @example * ```html *

* Right-click me *

* ``` * * @example * ```html *

* Left-click me *

* ``` */ declare class AcpContextMenuDirective implements OnDestroy { private readonly elementRef; private readonly contextMenuService; private destroy$; private menuRef; private hoverTimeout; /** Menu items to display */ acpContextMenu: AcpContextMenuItem[]; /** Custom data to pass to menu items */ contextMenuData?: unknown; /** Trigger configuration */ contextMenuTrigger: AcpContextMenuTriggerConfig; /** Emitted when a menu item is selected */ contextMenuItemSelected: EventEmitter; /** Emitted when menu is opened */ contextMenuOpened: EventEmitter; /** Emitted when menu is closed */ contextMenuClosed: EventEmitter; constructor(); ngOnDestroy(): void; /** * Handle right-click */ onContextMenu(event: MouseEvent): void; /** * Handle left-click */ onClick(event: MouseEvent): void; /** * Handle mouse enter for hover trigger */ onMouseEnter(): void; /** * Handle mouse leave for hover trigger */ onMouseLeave(): void; /** * Open the context menu */ openMenu(x: number, y: number, _event: MouseEvent | KeyboardEvent, rowData?: unknown): void; /** * Close the context menu */ closeMenu(): void; /** * Update menu items */ updateItems(items: AcpContextMenuItem[]): void; /** * Update context data */ updateData(data: unknown): void; /** * Check if menu is open */ isOpen(): boolean; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** * Internal component that renders the context menu panel * Not meant to be used directly - use ContextMenuService or ngContextMenu directive */ declare class AcpContextMenuPanel implements OnInit, OnDestroy { private readonly contextMenuService; private readonly ngZone; private readonly elementRef; menuContainer?: ElementRef; items: _angular_core.WritableSignal; contextData: _angular_core.WritableSignal; selectedIndex: _angular_core.WritableSignal; expandedIndex: _angular_core.WritableSignal; private destroy$; visibleItems: _angular_core.Signal; ngOnInit(): void; ngOnDestroy(): void; /** * Handle keyboard navigation */ onKeyDown(event: KeyboardEvent): void; /** * Handle item click */ onItemClick(item: AcpContextMenuItem, event: MouseEvent): void; /** * Handle item hover */ onItemHover(index: number): void; /** * Check if item has children */ hasChildren(item: AcpContextMenuItem): boolean; /** * Get item classes */ getItemClasses(item: AcpContextMenuItem, index: number): Record; /** * Select next item */ private selectNext; /** * Select previous item */ private selectPrevious; /** * Select first item */ private selectFirst; /** * Select last item */ private selectLast; /** * Expand selected item */ private expandSelected; /** * Collapse selected item */ private collapseSelected; /** * Activate selected item */ private activateSelected; /** * Track by function for items */ trackByIndex(index: number): number; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Declarative context menu component * * @example * ```html *

Right-click here

* * * * ``` * * @example * ```html * * * * ``` */ declare class AcpContextMenu implements OnDestroy { private readonly contextMenuService; private destroy$; private menuRef; /** Menu items to display */ readonly model: _angular_core.InputSignal; /** Target element to attach the context menu to */ readonly target: _angular_core.InputSignal; /** Emitted when menu is hidden/closed */ readonly hide: _angular_core.OutputEmitterRef; /** Emitted when a menu item is selected */ readonly itemSelected: _angular_core.OutputEmitterRef; constructor(); ngOnDestroy(): void; /** * Show the context menu at the specified position * * @param event - Mouse event or custom event with clientX/clientY * @param data - Optional data to pass to menu items (e.g., row data) */ show(event: MouseEvent | { clientX: number; clientY: number; }, data?: unknown): void; /** * Show the context menu positioned relative to an element * * @param element - Element to position the menu relative to * @param data - Optional data to pass to menu items */ showForElement(element: HTMLElement, data?: unknown): void; /** * Close the context menu */ close(): void; /** * Check if the menu is currently open */ isOpen(): boolean; /** * Update the menu items */ updateItems(items: AcpContextMenuItem[]): void; /** * Update the context data */ updateData(data: unknown): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Declarative dialog structure wrapper. Use it inside a dialog content template * to group the titlebar, body and actions sections. * * @example * ```html * * * *

Dialog body

* * * * * * * ``` */ declare class AcpDialog { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Declarative dialog content body. Use it inside `` or any dialog * content template to mark the scrollable body section. * * @example * ```html * *

Dialog body

* * ``` */ declare class AcpDialogContent { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** Layout direction for a dialog's content. Mirrors `Direction` from `@angular/cdk/bidi`. */ type AcpDialogDirection = 'ltr' | 'rtl'; /** * Focus restoration behavior. Mirrors `RestoreFocusValue` from `@angular/cdk/dialog`. * - `boolean`: restore focus to the previously-focused element. * - `string`: restore focus to the first element matching the CSS selector. * - `HTMLElement`: restore focus to the specific element. */ type AcpDialogRestoreFocus = boolean | string | HTMLElement; /** * Named width presets for dialogs opened through {@link AcpDialogService}. * `full` forces a full-screen dialog regardless of the viewport. */ type AcpDialogSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'full'; /** * Header configuration. When `header` is present in {@link AcpDialogConfig}, * the content is rendered inside the branded shell: a draggable * title bar with an optional icon and a close button. * * As a shortcut, {@link AcpDialogConfig.title} can be used instead of * `header.title`. */ interface AcpDialogHeaderConfig { /** Title text shown in the header. */ title: string; /** Optional subtitle shown below the title. */ subtitle?: string; /** Optional Material icon name displayed before the title. */ icon?: string; /** Whether the header shows a close button. @default true */ closable?: boolean; /** Accessible label for the close button. @default 'Close dialog' */ closeLabel?: string; /** Whether the dialog can be dragged by its header. @default true */ draggable?: boolean; /** Predefined color theme for the header. */ color?: AcpButtonColor$1; /** Additional CSS class names to apply to the header for custom styling. */ colorClass?: string; /** Color of the close icon. Defaults to a contrasting value based on `color`. */ closeColor?: 'dark' | 'light'; } /** * Outlet used by the declarative `` component to register * its content with `AcpDialogContainer`. The container then renders that * content inside `` instead of the configured `actions` list. */ interface AcpDialogActionsOutlet { /** Registers the declarative action template and its desired alignment. */ register(template: TemplateRef, align?: 'start' | 'center' | 'end'): void; /** Whether a declarative actions template has been registered. */ readonly hasActions: Signal; } /** * Outlet used by the declarative `` component to register * its template with `AcpDialogContainer`. The container renders it in the * header area, outside the scrollable content. */ interface AcpDialogTitlebarOutlet { /** Registers the declarative titlebar template and its title. */ register(template: TemplateRef, title?: string): void; /** Whether a declarative titlebar template has been registered. */ readonly hasTitlebar: Signal; } /** * Which gestures are allowed to close the dialog. Both default to `true`. */ interface AcpDialogCloseConfig { /** Whether clicking the backdrop closes the dialog. @default true */ backdropClick?: boolean; /** Whether pressing Escape closes the dialog. @default true */ escapeKey?: boolean; } /** Reactive state that can be bound to an action button. */ type AcpDialogActionState = boolean | Signal | Observable; /** Payload emitted when a configured footer action is clicked. */ interface AcpDialogActionClick { /** The action that was clicked. */ action: AcpDialogAction; /** The original click event. Callers may call `event.preventDefault()` to stop the default close. */ event: MouseEvent; } /** Color variants supported by `acp-button`. */ type AcpButtonColor$1 = 'primary' | 'secondary' | 'accent' | 'error' | 'danger' | 'success' | 'warning' | 'info' | 'dark'; /** Button variants supported by `acp-button`. */ type AcpButtonVariant$1 = 'basic' | 'icon' | 'fab' | 'mini-fab'; /** Button appearances supported by `acp-button`. */ type AcpButtonAppearance$1 = 'text' | 'filled' | 'elevated' | 'outlined' | 'tonal'; /** Button types supported by `acp-button`. */ type AcpButtonType$1 = 'button' | 'submit' | 'reset'; /** Button sizes supported by `acp-button`. */ type AcpButtonSize = 'small' | 'medium' | 'large'; /** * Action button rendered in the dialog footer. * Uses the same property names as `acp-button`. */ interface AcpDialogAction { /** Label shown in the button. */ text: string; /** Unique key to identify this action in `actionClicked` or `afterClosed`. */ key?: string; /** Color variant. */ color?: AcpButtonColor$1; /** Button variant. @default 'basic' */ variant?: AcpButtonVariant$1; /** Button appearance. @default 'filled' */ appearance?: AcpButtonAppearance$1; /** Optional Material icon name. */ icon?: string; /** Optional Material icon name displayed after the text. */ suffixIcon?: string; /** Whether the action is disabled. Accepts a boolean, a signal or an observable. @default false */ disabled?: AcpDialogActionState; /** Whether the action shows a loading state. Accepts a boolean, a signal or an observable. @default false */ loading?: AcpDialogActionState; /** Accessible label for the button. */ ariaLabel?: string; /** Button size. @default 'large' */ size?: AcpButtonSize; /** Whether the button spans the full width. @default false */ block?: boolean; /** Whether the FAB button is extended. @default false */ extended?: boolean; /** HTML button type. @default 'button' */ type?: AcpButtonType$1; /** ID of the form the button is associated with. */ form?: string; /** Value returned when the dialog closes after clicking this action. */ result?: R; } /** * Lazy loader for a dialog content component. Lets callers split the component * into its own bundle and only load it when the dialog is actually opened. * * Usage: * ```ts * this.dialogs.open({ loadComponent: () => import('./edit-form').then(m => m.EditForm) }, { * title: 'Edit', * data: { id: 5 }, * }); * ``` * @template C Type of the content component class. */ interface AcpDialogComponentLoader { loadComponent: () => Promise>; } /** * Factory that returns dialog content (a component class, a `TemplateRef`, * a string, another factory, or a lazy loader). */ type AcpDialogContentFunction = (data?: unknown) => AcpDialogContentInput | Promise>; /** * Accepted `content` values for {@link AcpDialogService.open}. * * - `Type`: a component class to render inside the dialog. * - `AcpDialogComponentLoader`: a lazy loader that resolves to a component. * - `TemplateRef`: an inline template rendered with dialog context. * - `string`: a plain text/HTML message rendered in the content area. * - `AcpDialogContentFunction`: a function returning any of the above. */ type AcpDialogContentInput = Type | AcpDialogComponentLoader | TemplateRef | string | AcpDialogContentFunction; /** * Content after {@link AcpDialogService} has resolved lazy loaders and factories. * @internal */ type AcpDialogResolvedContent = Type | TemplateRef | string; /** * Main configuration object for {@link AcpDialogService.open}. * * `content` can also be supplied here when calling `open()` with a single * config object. * * @template D Type of the data delivered to the content component. */ interface AcpDialogConfig { /** ID for the dialog. If omitted, a unique one will be generated. */ id?: string; /** * Data delivered to the content component. The component always reads it by * injecting `ACP_DIALOG_DATA`, whether it renders bare or inside the shell. */ data?: D; /** Optional header. When present, the content renders inside the shell. */ header?: AcpDialogHeaderConfig; /** Shortcut for `header.title`. Ignored when `header` is provided. */ title?: string; /** Whether to show the branded header/titlebar. Set to `false` to hide it. @default true */ showHeader?: boolean; /** Optional footer actions rendered as `acp-button` instances. */ actions?: AcpDialogAction[]; /** Whether to show the configured footer actions. Set to `false` to hide them. @default true */ showActions?: boolean; /** Alignment of the footer actions. @default 'end' */ actionsAlign?: 'start' | 'center' | 'end'; /** Named size preset. Ignored when `width` is set. @default 'md' */ size?: AcpDialogSize; /** Explicit width, takes precedence over `size`. Numbers are treated as pixels. */ width?: string | number; /** Dialog height. Numbers are treated as pixels. */ height?: string | number; /** Minimum width. Numbers are treated as pixels. */ minWidth?: string | number; /** Minimum height. Numbers are treated as pixels. */ minHeight?: string | number; /** @default '95vw' */ maxWidth?: string | number; /** Maximum height. Numbers are treated as pixels. */ maxHeight?: string | number; /** Whether the dialog goes full-screen on handset viewports. @default false */ fullScreenOnMobile?: boolean; position?: DialogPosition; /** Extra panel classes. `acp-dialog` and `acp-dialog-{size}` are always added. */ panelClass?: string | string[]; backdropClass?: string | string[]; /** @default true */ hasBackdrop?: boolean; /** * Whether the user can use Escape or backdrop click to close the dialog. * When set, it overrides `closeOn` for both gestures. */ disableClose?: boolean; /** Independent close gestures. @default { backdropClick: true, escapeKey: true } */ closeOn?: AcpDialogCloseConfig; /** Whether the dialog closes on browser back/forward navigation. @default true */ closeOnNavigation?: boolean; /** Layout direction for the dialog's content. @default 'ltr' */ direction?: AcpDialogDirection; /** * Function used to determine whether the dialog is allowed to close. * Receives the attempted result, the config and the component instance. */ closePredicate?: (result: Result | undefined, config: Config, componentInstance: Component | null) => boolean; /** * Where the dialog component should live in Angular's logical component tree. * Forwarded to `MatDialogConfig.viewContainerRef`; use this when the dialog * needs access to providers scoped to a lazy-loaded feature or route. */ viewContainerRef?: ViewContainerRef; /** Injector used to instantiate the content component. Takes precedence over `viewContainerRef`. */ injector?: Injector; /** Bindings to apply to a component rendered inside the dialog. Does nothing for template-based content. */ bindings?: Binding[]; /** @default 'first-tabbable' */ autoFocus?: boolean | 'first-tabbable' | 'dialog' | 'first-heading'; /** Whether to wait for the opening animation before trapping focus. @default false */ delayFocusTrap?: boolean; /** @default true */ restoreFocus?: AcpDialogRestoreFocus; ariaLabel?: string; ariaLabelledBy?: string; ariaDescribedBy?: string; /** Whether to set `aria-modal` on the dialog element. @default false */ ariaModal?: boolean; role?: 'dialog' | 'alertdialog'; /** Scroll behavior: a CDK ScrollStrategy or a shortcut name ('block', 'close', 'noop'). */ scrollStrategy?: ScrollStrategy | 'block' | 'close' | 'noop'; /** @default '300ms' */ enterAnimationDuration?: number | string; /** @default '200ms' */ exitAnimationDuration?: number | string; } /** * Payload delivered through `MAT_DIALOG_DATA` to {@link AcpDialogContainer}. * @internal Not part of the public API contract. */ interface AcpDialogContainerData { /** The resolved content rendered inside the shell. */ content: AcpDialogResolvedContent; /** The public configuration provided by the caller. */ config: AcpDialogConfig; /** Shared action-click stream so the caller and content observe the same events. */ actionClicks?: Subject; } /** * Reference to a dialog opened via `AcpDialogService`. Mirrors the public surface * of `MatDialogRef` so consumers can subscribe to `afterClosed()`, close manually, * inspect the component instance, etc. * * It is both the value returned by `AcpDialogService.open()` and an injectable * token: content components can `inject(AcpDialogRef)` to close themselves. */ declare class AcpDialogRef { private readonly matDialogRef; /** Emits every time a configured dialog action is clicked, before it closes. */ clickedResult: Subject>; /** Observable mirror of {@link clickedResult}. */ get actionClicked$(): Observable>; constructor(matDialogRef: MatDialogRef | Promise>, clickedResult?: Subject>); /** The instance of the component opened into the dialog. */ get componentInstance(): unknown; /** `ComponentRef` of the component opened into the dialog. */ get componentRef(): ComponentRef | null; /** Whether the user is allowed to close the dialog. */ get disableClose(): boolean | undefined; /** Unique ID for the dialog. */ get id(): string; /** Gets an observable that is notified when the dialog is finished closing. */ afterClosed(): Observable; /** Gets an observable that is notified when the dialog is finished opening. */ afterOpened(): Observable; /** Gets an observable that is notified when the dialog has started closing. */ beforeClosed(): Observable; /** Gets an observable that emits when the overlay's backdrop has been clicked. */ backdropClick(): Observable; /** Gets an observable that emits when keydown events are targeted on the overlay. */ keydownEvents(): Observable; /** Gets the current lifecycle state of the dialog. */ getState(): MatDialogState | undefined; /** Resolves with the result once the dialog finishes closing. */ get closed(): Promise; /** Observable that emits the result once the dialog finishes closing. */ get closed$(): Observable; /** Closes the dialog, optionally returning a result. */ close(result?: R): void; /** Updates the dialog's position. */ updatePosition(position?: { left?: string; top?: string; right?: string; bottom?: string; }): this; /** Updates the dialog's width and height. */ updateSize(width?: string, height?: string): this; /** Add a CSS class or an array of classes to the overlay pane. */ addPanelClass(classes: string | string[]): this; /** Remove a CSS class or an array of classes from the overlay pane. */ removePanelClass(classes: string | string[]): this; private fromRef; private readRef; private withRef; } /** * Reusable dialog service — a branded alternative to `MatDialog`. Every dialog * renders inside `AcpDialogContainer`, so content always works the same way: * * - read data with `inject(ACP_DIALOG_DATA)`, * - close the dialog with `inject(AcpDialogRef).close(result)`. * * Usage: * ```ts * private dialogs = inject(AcpDialogService); * * this.dialogs.open(UserForm, { * title: 'Edit user', * actions: [ * { text: 'Cancel' }, * { text: 'Save', color: 'success', result: user }, * ], * size: 'lg', * data: { userId: 5 }, * }).afterClosed().subscribe(saved => { * // handle result * }); * * // or with a single config object: * this.dialogs.open({ * content: UserForm, * title: 'Edit user', * actions: [{ text: 'Save', color: 'success' }], * data: { userId: 5 }, * }).afterClosed().subscribe(saved => { * // handle result * }); * ``` */ declare class AcpDialogService { private readonly dialog; private readonly overlay; private readonly breakpointObserver; private readonly defaults; /** Stream that emits when all open dialogs have finished closing. */ get afterAllClosed(): Observable; /** Stream that emits when a dialog has been opened. */ get afterOpened(): Observable>; /** Keeps track of the currently-open dialogs. */ get openDialogs(): MatDialogRef[]; /** * Opens a dialog with a component class. * @param component The content component to render. * @param config Dialog configuration (merged over `provideAcpDialogDefaults`). * @returns An {@link AcpDialogRef}; subscribe to `ref.afterClosed()` for the result. */ open(component: Type, config?: AcpDialogConfig): AcpDialogRef; /** * Opens a dialog with a `TemplateRef`. * @param template The inline template to render. * @param config Dialog configuration (merged over `provideAcpDialogDefaults`). * @returns An {@link AcpDialogRef}; subscribe to `ref.afterClosed()` for the result. */ open(template: TemplateRef, config?: AcpDialogConfig): AcpDialogRef; /** * Opens a dialog from a single config object. * @param config Dialog configuration that includes the `content` to render. * @returns An {@link AcpDialogRef}; subscribe to `ref.afterClosed()` for the result. */ open(config: AcpDialogConfig & { content: AcpDialogContentInput; }): AcpDialogRef; /** Closes all currently open dialogs. */ closeAll(): void; /** Finds an open dialog by its id. */ getDialogById(id: string): AcpDialogRef | undefined; private openWithContent; private createMatRef; private resolveContent; private mergeDefaults; private buildMatConfig; private normalizeCloseOn; private toMatSize; private resolveScrollStrategy; private wireCloseGestures; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * Shell that hosts any content inside an `AcpDialog`. Renders the optional * branded header (draggable title bar with icon, title and close button) and * optional footer actions. * * Content can be a component class, a `TemplateRef`, or a plain string. It is * created with a child `Injector` that provides `ACP_DIALOG_DATA` (the caller's * `config.data`) and `AcpDialogRef` (a typed handle to close the dialog). * * Opened exclusively through `AcpDialogService`; not meant to be used in templates. */ declare class AcpDialogContainer implements AfterViewInit { private readonly parentInjector; private readonly containerData; private readonly actionClicks; private readonly dialogRef; /** Outlet where the configured content is rendered. */ private readonly contentHost; /** Outlet where declarative `acp-dialog-actions` content is rendered. */ private readonly actionOutlet; /** Outlet where declarative `acp-dialog-titlebar` content is rendered. */ private readonly titlebarOutletRef; /** Template used to render a plain string content. */ private readonly stringTemplate; /** Whether the content has registered a declarative `acp-dialog-actions` template. */ protected readonly hasDeclarativeActions: _angular_core.WritableSignal; /** Whether the content has registered a declarative `acp-dialog-titlebar` template. */ protected readonly hasDeclarativeTitlebar: _angular_core.WritableSignal; /** Pending declarative actions template, captured before the outlet is ready. */ private readonly pendingActionTemplate; /** Pending declarative titlebar template, captured before the outlet is ready. */ private readonly pendingTitlebarTemplate; /** Alignment requested by a declarative actions template. */ protected readonly declarativeActionsAlign: _angular_core.WritableSignal<"start" | "end" | "center" | undefined>; /** Title requested by a declarative titlebar template. */ protected readonly declarativeTitle: _angular_core.WritableSignal; /** Outlet object provided to content so `acp-dialog-actions` can register itself. */ private readonly actionsOutlet; /** Outlet object provided to content so `acp-dialog-titlebar` can register itself. */ private readonly titlebarOutlet; /** Exposed header configuration, including the `title` shortcut. */ protected readonly headerConfig: Signal; /** Title used for the actions footer label. */ protected readonly resolvedDialogTitle: Signal; /** Alignment used for the actions footer. */ protected readonly resolvedActionsAlign: Signal<"start" | "end" | "center">; /** Whether the current content is a plain string. */ protected readonly isStringContent: _angular_core.WritableSignal; get config(): _acontplus_ng_components.AcpDialogConfig; get content(): _acontplus_ng_components.AcpDialogResolvedContent; constructor(); ngAfterViewInit(): void; private createContentInjector; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Dialog title bar. Use it inside a dialog content template for a declarative * header, or let `AcpDialogContainer` instantiate it from `config.header`. * * @example * ```html * * * * * * * ``` */ declare class AcpDialogTitlebar implements AfterViewInit { private readonly elementRef; private readonly matDialogRef; private readonly outlet; private readonly titlebarTemplateRef; protected readonly renderInline: _angular_core.WritableSignal; protected readonly hostDisplay: _angular_core.WritableSignal; /** CSS classes applied to the header element. */ protected readonly headerClasses: Signal; /** Close-button color resolved from `closeColor` or the header background. */ protected readonly resolvedCloseColor: Signal<"dark" | "light">; /** Title text shown in the header. */ title: _angular_core.InputSignal; /** Optional subtitle shown below the title. */ subtitle: _angular_core.InputSignal; /** Optional Material icon name displayed before the title. */ icon: _angular_core.InputSignal; /** Whether the close button is shown. @default true */ closable: _angular_core.InputSignal; /** Accessible label for the close button. @default 'Close dialog' */ closeLabel: _angular_core.InputSignal; /** Whether the dialog can be dragged by its header. @default true */ draggable: _angular_core.InputSignal; /** Predefined header color theme. */ color: _angular_core.InputSignal; /** Additional CSS class names to apply to the header. */ colorClass: _angular_core.InputSignal; /** Explicit close icon color. If omitted, it is chosen from the header `color`. */ closeColor: _angular_core.InputSignal<"dark" | "light" | undefined>; /** Emitted when the close button is clicked and no `MatDialogRef` is available. */ closed: _angular_core.OutputEmitterRef; close(): void; bringToFront(): void; ngAfterViewInit(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Dialog actions container. Use it declaratively inside a dialog content * template, or let `AcpDialogContainer` instantiate it from `config.actions`. * * @example * ```html * * * * * ``` */ declare class AcpDialogActions implements AfterViewInit { private readonly outlet; private readonly matDialogRef; private readonly containerData; private readonly injector; private readonly actionsTemplateRef; private readonly actionStateSignals; protected readonly renderInline: _angular_core.WritableSignal; protected readonly hostDisplay: _angular_core.WritableSignal; /** Alignment of the action buttons. @default 'end' */ align: _angular_core.InputSignal<"start" | "end" | "center">; /** Configured footer actions. When omitted, the component works as a declarative slot. */ actions: _angular_core.InputSignal[] | undefined>; /** Optional title used to label the actions footer. */ dialogTitle: _angular_core.InputSignal; /** Accessible label for the actions footer. Falls back to a generated one. */ ariaLabel: Signal; ngAfterViewInit(): void; /** Resolves an action's boolean state (boolean, signal or observable). */ protected resolveActionState(state: AcpDialogActionState | undefined): boolean; /** Broadcasts the click and closes the dialog unless the event is prevented. */ protected handleActionClick(event: MouseEvent, action: AcpDialogAction): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * Token used to deliver `AcpDialogConfig.data` to the content component. * Content components read it with `inject(ACP_DIALOG_DATA)` (typed as `D`). * This is the single data channel, used identically for bare and shell dialogs. */ declare const ACP_DIALOG_DATA: InjectionToken; /** * Application-wide defaults for every dialog opened through `AcpDialogService`. * Mirrors `MAT_DIALOG_DEFAULT_OPTIONS` from Angular Material. * Per-call config always wins over these defaults. */ declare const ACP_DIALOG_DEFAULT_OPTIONS: InjectionToken>; /** * Token used by the declarative `` component to register * its action buttons with the hosting `AcpDialogContainer`. */ declare const ACP_DIALOG_ACTIONS: InjectionToken; /** * Token used by the declarative `` component to register * its template with the hosting `AcpDialogContainer`. */ declare const ACP_DIALOG_TITLEBAR: InjectionToken; /** * Registers application-wide dialog defaults, e.g.: * `provideAcpDialogDefaults({ fullScreenOnMobile: true })`. */ declare function provideAcpDialogDefaults(defaults: AcpDialogConfig): EnvironmentProviders; type DialogSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'full'; /** * @interface MatCustomDialogConfig * This is the main configuration object for any dialog opened through the service. * It extends the standard MatDialogConfig with custom properties for convenience. */ interface MatCustomDialogConfig { data?: T; size?: DialogSize; width?: string; height?: string; minWidth?: string; minHeight?: string; maxWidth?: string; maxHeight?: string; position?: { top?: string; bottom?: string; left?: string; right?: string; }; panelClass?: string | string[]; backdropClass?: string | string[]; hasBackdrop?: boolean; /** * Whether clicking the backdrop closes the dialog. * @default true */ backdropClickClosable?: boolean; /** * Whether pressing Escape closes the dialog. Handled independently from * `backdropClickClosable`. * @default true */ escapeKeyClosable?: boolean; isMobileFullScreen?: boolean; autoFocus?: boolean | 'first-tabbable' | 'dialog' | 'first-heading'; restoreFocus?: boolean; ariaLabel?: string; ariaLabelledBy?: string; ariaDescribedBy?: string; role?: 'dialog' | 'alertdialog'; scrollStrategy?: ScrollStrategy; enterAnimationDuration?: number | string; exitAnimationDuration?: number | string; } /** * Configuration interface for opening a dialog inside the custom `DialogWrapper`. * This interface defines the properties needed to configure the dialog wrapper. * * @interface DialogWrapperConfig * @template T The type of data to pass to the content component */ interface DialogWrapperConfig { /** * The component type to render inside the dialog wrapper. * This component will be dynamically created and inserted into the dialog. */ component: Type; /** * The title text to display in the dialog header. */ title: string; /** * Optional Material icon name to display in the dialog header. */ icon?: string; /** * Optional data to pass to the content component's instance. * This will be accessible via the `data` property on the component instance. */ data?: T; /** * Whether to hide the dialog header section. * If true, the title, icon, and close button will not be displayed. * @default false */ hideHeader?: boolean; /** * Whether to show the close button in the dialog header. * If false, follows Angular Material's default behavior (no close button). * @default true */ showCloseButton?: boolean; /** * Accessible label for the header close button. * Useful to provide a localized label for screen readers. * @default 'Close dialog' */ closeAriaLabel?: string; } declare class AdvancedDialogService { private readonly dialog; private readonly overlay; private readonly breakpointObserver; private readonly zIndexService; private readonly isMobile$; /** * Main method to open any component in a dialog. * This provides maximum flexibility. * @param component The component to render. * @param config The detailed configuration for the dialog. * @returns A MatDialogRef instance. */ open(component: ComponentType, config?: MatCustomDialogConfig): Promise>; /** * A powerful helper to open a component inside our standard, branded "wrapper". * This provides maximum consistency. * @param wrapperConfig Configuration for the title, icon, and the content component. * @param matDialogConfig Standard MatDialog configuration (size, position, etc.). * @returns A MatDialogRef instance pointing to the wrapper. */ openInWrapper(wrapperConfig: DialogWrapperConfig, matDialogConfig?: MatCustomDialogConfig): Promise>; /** * Helper to open a dialog and only get an observable of the result. */ openAndGetResult(component: ComponentType, config?: MatCustomDialogConfig): Promise; /** * Closes all currently open dialogs. */ closeAll(): void; private buildDialogConfig; private applyFullScreenConfig; private applyStandardConfig; private applyCommonConfig; /** * Re-enables a single close gesture (backdrop click or Escape) when the other * one is disabled, since MatDialog's `disableClose` blocks both at once. */ private wireCloseBehavior; private getDialogWidth; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } type DialogType = 'normal' | 'alert'; /** * Centralized service that manages z-index stacking for all dialogs. * Ensures dialogs always appear in the correct order. * Alert dialogs always take priority over regular dialogs. */ declare class DialogZIndexService { private static readonly Z_INDEX_RANGES; private static readonly Z_INDEX_INCREMENT; /** * Gets the next available z-index for a specific dialog type. * @param type Dialog type (normal, alert) * @returns The next z-index to use */ getNextZIndex(type?: DialogType): number; /** * Gets the highest z-index currently in use for a specific type. * @param type Dialog type * @returns The highest z-index currently in use for that type */ getCurrentZIndex(type?: DialogType): number; /** * Gets the highest z-index across all dialog types. * @returns The highest z-index of all dialogs */ getHighestZIndex(): number; /** * Resets the z-index counter (useful for testing). * @param type Specific type to reset, or undefined to reset all */ reset(type?: DialogType): void; /** * Applies a z-index to a specific dialog. * @param dialogRef Dialog reference * @param type Dialog type (determines the z-index range) * @param zIndex Specific z-index to apply (optional) */ applyZIndex(dialogRef: MatDialogRef, type?: DialogType, zIndex?: number): void; /** * Brings a dialog to the front (used by the drag functionality). * @param element Dialog element to bring to the front * @param type Dialog type */ bringToFront(element: HTMLElement, type?: DialogType): void; /** * Forces a dialog to stay above every other dialog. * Useful for critical alerts that must have maximum priority. * @param dialogRef Dialog reference */ forceToTop(dialogRef: MatDialogRef): void; private getOverlayRef; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class OverlayService { private readonly overlay; private overlayRef; showSpinner(): void; hideSpinner(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class ThemeSwitcher { private readonly _darkMode; private readonly platformId; isDarkMode$: rxjs.Observable; constructor(); loadMode(): void; toggleDarkMode(): void; private applyTheme; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** * A wrapper component for Angular Material dialogs that provides a consistent look and feel, * including a draggable header and the ability to dynamically create components inside the dialog. * * This component is typically used with the AdvancedDialogService's openInWrapper method. */ declare class DialogWrapper implements AfterViewInit { dialogRef: MatDialogRef; config: DialogWrapperConfig; private zIndexService; /** * A template reference that acts as an anchor for dynamic content. * This is where the component specified in the config will be rendered. */ readonly contentHost: Signal; /** * A reference to the header element for the z-index focus logic. * Used to bring the dialog to the front when clicked. */ readonly header: Signal; /** * Lifecycle hook that initializes the dynamic content after the view is ready. * Creates the component specified in the config and passes data to it. */ ngAfterViewInit(): void; /** * Closes the dialog. * Called when the close button in the header is clicked. */ onClose(): void; /** * Brings the dialog to the front by adjusting its z-index. * Uses the centralized DialogZIndexService for consistent z-index management. * Called when the dialog header is clicked. */ bringToFront(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type SelectValue = string | number | null; declare class DynamicSelect implements OnInit, OnDestroy { label: _angular_core.InputSignal; options: _angular_core.InputSignal; selectedValue: _angular_core.InputSignal; className: _angular_core.InputSignal; placeholder: _angular_core.InputSignal; disabled: _angular_core.InputSignal; clearable: _angular_core.InputSignal; searchable: _angular_core.InputSignal; virtualScroll: _angular_core.InputSignal; dropdownPosition: _angular_core.InputSignal<"auto" | "top" | "bottom">; closeOnSelect: _angular_core.InputSignal; hideSelected: _angular_core.InputSignal; multiple: _angular_core.InputSignal; selectOnTab: _angular_core.InputSignal; openOnEnter: _angular_core.InputSignal; selectableGroup: _angular_core.InputSignal; selectableGroupAsModel: _angular_core.InputSignal; clearOnBackspace: _angular_core.InputSignal; readonly: _angular_core.InputSignal; searchWhileComposing: _angular_core.InputSignal; minTermLength: _angular_core.InputSignal; editableSearchTerm: _angular_core.InputSignal; typeToSearchText: _angular_core.InputSignal; addTagText: _angular_core.InputSignal; loadingText: _angular_core.InputSignal; clearAllText: _angular_core.InputSignal; notFoundText: _angular_core.InputSignal; selectionChange: _angular_core.OutputEmitterRef; selectControl: FormControl; filteredOptions: SelectOption[]; loading: boolean; private readonly _onDestroy; constructor(); ngOnInit(): void; onSelectionChange(selectedItem: any): void; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class UserIcon { size: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class SvgIcon { private readonly iconRegistry; /** * Icon name from the registry */ name: _angular_core.InputSignal; /** * Icon size (applies to both width and height) */ size: _angular_core.InputSignal; /** * Custom width (overrides size) */ width: _angular_core.InputSignal; /** * Custom height (overrides size) */ height: _angular_core.InputSignal; /** * Icon color (uses CSS currentColor by default) */ color: _angular_core.InputSignal; /** * Show fallback icon instead of empty space when icon is not found */ useFallback: _angular_core.InputSignal; /** * Computed width value */ protected computedWidth: _angular_core.Signal; /** * Computed height value */ protected computedHeight: _angular_core.Signal; /** * Get the icon SVG from the registry */ protected iconSvg: _angular_core.Signal; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface IconRegistryConfig { /** * Fallback icon to show when requested icon is not found */ fallbackIcon?: string; /** * Show console warnings when icons are not found */ showWarnings?: boolean; /** * Base URL for loading icons from external sources */ iconBaseUrl?: string; } declare class IconRegistryService { private readonly sanitizer; private readonly http; private readonly registry; private readonly pendingLoads; private config; /** * Configure the icon registry */ configure(config: IconRegistryConfig): void; /** * Register a single icon */ registerIcon(name: string, svgData: string): void; /** * Register multiple icons at once */ registerIcons(icons: IconDefinition[]): void; /** * Load an icon from a URL */ loadIconFromUrl(name: string, url: string): Promise; /** * Load multiple icons from URLs */ loadIconsFromUrls(icons: { name: string; url: string; }[]): Promise; /** * Get a sanitized icon by name * If icon is not found, attempts to load from configured base URL or returns fallback */ getIcon(name: string): SafeHtml | null; /** * Get icon with automatic online loading if not found */ getIconAsync(name: string): Promise; /** * Check if an icon exists in the registry */ hasIcon(name: string): boolean; /** * Get all registered icon names */ getRegisteredIcons(): string[]; /** * Clear all registered icons */ clearRegistry(): void; /** * Remove a specific icon from the registry */ removeIcon(name: string): boolean; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } declare class InputChip { chips: _angular_core.InputSignal; labelText: _angular_core.InputSignal; placelholder: _angular_core.InputSignal; addOnBlur: boolean; readonly separatorKeysCodes: readonly [13, 188]; announcer: LiveAnnouncer; add(event: MatChipInputEvent): void; remove(value: string): void; edit(inputRaw: string, event: MatChipEditedEvent): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class Button { variant: _angular_core.InputSignal; text: _angular_core.InputSignal; icon: _angular_core.InputSignal; disabled: _angular_core.InputSignal; type: _angular_core.InputSignal; matStyle: _angular_core.InputSignal; customClass: _angular_core.InputSignal; reportFormat: _angular_core.InputSignal; extended: _angular_core.InputSignal; title: _angular_core.InputSignal; ariaLabel: _angular_core.InputSignal; name: _angular_core.InputSignal; id: _angular_core.InputSignal; form: _angular_core.InputSignal; tabIndex: _angular_core.InputSignal; testId: _angular_core.InputSignal; handleClick: _angular_core.OutputEmitterRef; /** * Gets the icon to display. If reportFormat is provided and no explicit icon is set, * returns the appropriate icon for the report format. */ getIcon(): string; /** * Gets the variant to use. If reportFormat is provided and variant is still 'primary' (default), * returns the appropriate variant for the report format. */ getVariant(): ButtonVariant; /** * Gets the title to display. If reportFormat is provided, automatically appends * the format name to the title (e.g., "Export PDF", "Download Excel"). */ getTitle(): string; /** * Maps report format to appropriate icon */ private getReportIcon; /** * Maps report format to appropriate button variant/color */ private getReportVariant; /** * Maps report format to human-readable name */ private getReportFormatName; getButtonClasses(): Record; getDisplayText(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } type AcpButtonVariant = 'basic' | 'icon' | 'fab' | 'mini-fab'; type AcpButtonAppearance = 'text' | 'filled' | 'elevated' | 'outlined' | 'tonal'; type AcpButtonType = 'button' | 'submit' | 'reset'; type AcpButtonColor = 'primary' | 'secondary' | 'accent' | 'error' | 'danger' | 'success' | 'warning' | 'info' | 'dark' | 'light'; declare abstract class BaseButton { color: _angular_core.InputSignal; square: _angular_core.InputSignalWithTransform; icon: _angular_core.InputSignal; suffixIcon: _angular_core.InputSignal; loading: _angular_core.InputSignalWithTransform; showProgress: _angular_core.InputSignalWithTransform; progressType: _angular_core.InputSignal<"text" | "spinner">; progressText: _angular_core.InputSignal; disabled: _angular_core.InputSignalWithTransform; disableRipple: _angular_core.InputSignalWithTransform; variant: _angular_core.InputSignal; appearance: _angular_core.InputSignal; type: _angular_core.InputSignal; extended: _angular_core.InputSignalWithTransform; block: _angular_core.InputSignalWithTransform; size: _angular_core.InputSignal<"small" | "medium" | "large">; text: _angular_core.InputSignal; ariaLabel: _angular_core.InputSignal; form: _angular_core.InputSignal; hasText: _angular_core.Signal; clicked: _angular_core.OutputEmitterRef; focused: _angular_core.OutputEmitterRef; blurred: _angular_core.OutputEmitterRef; colorClass: _angular_core.Signal; sizeClass: _angular_core.Signal; squareClass: _angular_core.Signal<"" | "acp-square">; blockClass: _angular_core.Signal<"" | "acp-block">; isDisabled: _angular_core.Signal; pointerEvents: _angular_core.Signal<"none" | "auto">; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class AcpButton extends BaseButton { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class Spinner { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface TabulatorColumn { title: string; field: string; width?: number | string; minWidth?: number; maxWidth?: number; resizable?: boolean; sortable?: boolean; headerSort?: boolean; editor?: string | boolean; formatter?: string; formatterParams?: Record; validator?: string | string[]; headerFilter?: string | boolean; headerFilterParams?: Record; frozen?: boolean; responsive?: number; tooltip?: string | boolean; cssClass?: string; headerCssClass?: string; mutator?: string; accessor?: string; download?: boolean; titleDownload?: string; visible?: boolean; clipboard?: boolean; } interface TabulatorTheme { name: 'default' | 'modern' | 'midnight' | 'simple' | 'site' | 'site-dark'; cssPath?: string; } interface TabulatorConfig { data?: any[]; columns?: TabulatorColumn[]; height?: string | number | false; minHeight?: number; maxHeight?: number; layout?: 'fitData' | 'fitColumns' | 'fitDataFill' | 'fitDataStretch'; layoutColumnsOnNewData?: boolean; responsiveLayout?: boolean | 'hide' | 'collapse'; responsiveLayoutCollapseStartOpen?: boolean; columnMinWidth?: number; resizableColumns?: boolean; movableColumns?: boolean; columnHeaderVertAlign?: 'top' | 'middle' | 'bottom'; placeholder?: string; footerElement?: string; tooltips?: boolean | ((cell: any) => string); tooltipGenerationMode?: 'load' | 'hover'; history?: boolean; keybindings?: Record; reactiveData?: boolean; autoResize?: boolean; tableBuilding?: () => void; tableBuilt?: () => void; renderStarted?: () => void; renderComplete?: () => void; htmlImporting?: () => void; htmlImported?: () => void; dataLoading?: (data: any[]) => void; dataLoaded?: (data: any[]) => void; dataChanged?: (data: any[]) => void; pageLoaded?: (pageno: number) => void; dataSorting?: (sorters: any[]) => void; dataSorted?: (sorters: any[], rows: any[]) => void; dataFiltering?: (filters: any[]) => void; dataFiltered?: (filters: any[], rows: any[]) => void; validationFailed?: (cell: any, value: any, validators: any[]) => void; clipboardCopyStyled?: (clipboard: string) => string; clipboardCopyConfig?: Record; clipboardPasteParser?: string | ((clipboard: string) => any[][]); clipboardPasteAction?: 'insert' | 'update' | 'replace'; printAsHtml?: boolean; printFormatter?: (tableHtml: string, table: any) => string; printHeader?: string; printFooter?: string; tabEndNewRow?: boolean | ((row: any) => any); } interface TabulatorEventHandlers { onCellEdited?: (cell: any) => void; onRowClick?: (e: Event, row: any) => void; onRowSelected?: (row: any) => void; onRowDeselected?: (row: any) => void; onDataChanged?: (data: any[]) => void; onTableReady?: (tabulator: any) => void; } interface DataGridColumn { field: string; header?: string | Observable; hide?: boolean; show?: boolean; disabled?: boolean; pinned?: DataGridColumnPinValue; left?: string; right?: string; width?: string; resizable?: boolean; minWidth?: number; maxWidth?: number; sortable?: boolean | string; sortProp?: DataGridSortProp; type?: DataGridColumnType; typeParameter?: DataGridColumnTypeParameter; tag?: DataGridColumnTag; buttons?: DataGridColumnButton[] | ((rowData: T) => DataGridColumnButton[]); formatter?: (rowData: T, colDef?: DataGridColumn) => any; cellTemplate?: TemplateRef | null; showExpand?: boolean; description?: string; summary?: ((data: T[], colDef?: DataGridColumn) => any) | string; class?: string | ((rowData?: T, colDef?: DataGridColumn) => string); headerCellTemplate?: TemplateRef; } declare type DataGridColumnPinValue = 'left' | 'right' | null; interface DataGridColumnPinOption { label: string | Observable; value: DataGridColumnPinValue; } declare type DataGridColumnType = 'button' | 'tag' | 'link' | 'image' | 'boolean' | 'number' | 'currency' | 'percent' | 'date'; interface DataGridColumnTypeParameter { currencyCode?: string; display?: string | boolean; digitsInfo?: string; format?: string; locale?: string; timezone?: string; } interface DataGridSortProp { arrowPosition?: 'before' | 'after'; disableClear?: boolean; id?: string; start?: 'asc' | 'desc'; } interface DataGridColumnTag { [key: number]: DataGridColumnTagValue; [key: string]: DataGridColumnTagValue; } interface DataGridColumnTagValue { text?: string; color?: string; } interface DataGridColumnButton { type?: DataGridButtonType; text?: string | Observable; icon?: string; fontIcon?: string; svgIcon?: string; color?: ThemePalette; class?: string; disabled?: boolean | ((rowData: T) => boolean); click?: (rowData: T, event: Event) => void; iif?: (rowData: T) => boolean; pop?: string | Observable | DataGridColumnButtonPop; tooltip?: string | Observable | DataGridColumnButtonTooltip; badge?: number | string | Observable | DataGridColumnButtonBadge; children?: DataGridMenuItem[]; } interface DataGridColumnButtonPop { title: string | Observable; description?: string | Observable; okColor?: ThemePalette; okText?: string | Observable; closeColor?: ThemePalette; closeText?: string | Observable; } interface DataGridColumnButtonTooltip { message: string | Observable; position?: TooltipPosition; positionAtOrigin?: boolean; class?: any; hideDelay?: number; showDelay?: number; touchGestures?: TooltipTouchGestures; disabled?: boolean; } interface DataGridColumnButtonBadge { content: number | string | Observable; description?: string | Observable; color?: ThemePalette; position?: MatBadgePosition; size?: MatBadgeSize; overlap?: boolean; disabled?: boolean; hidden?: boolean; } type DataGridCellTemplate = Record>; interface DataGridRowSelectionFormatter { disabled?: (rowData: T, index: number) => boolean; hideCheckbox?: (rowData: T, index: number) => boolean; } type DataGridRowClassFormatter = Record boolean>; type DataGridButtonType = MatButtonAppearance | 'icon'; /** * Represents the default options for the grid that can be configured * using the `DATA_GRID_DEFAULT_OPTIONS` injection token. */ interface DataGridDefaultOptions { columnResizable?: boolean; emptyValuePlaceholder?: string; pageOnFront?: boolean; showPaginator?: boolean; pageDisabled?: boolean; showFirstLastButtons?: boolean; pageIndex?: number; pageSize?: number; pageSizeOptions?: number[]; hidePageSize?: boolean; sortOnFront?: boolean; sortActive?: string; sortDirection?: SortDirection; sortDisableClear?: boolean; sortDisabled?: boolean; sortStart?: 'asc' | 'desc'; rowHover?: boolean; rowStriped?: boolean; multiSelectable?: boolean; multiSelectionWithClick?: boolean; rowSelectable?: boolean; hideRowSelectionCheckbox?: boolean; disableRowClickSelection?: boolean; cellSelectable?: boolean; showToolbar?: boolean; toolbarTitle?: string; columnHideable?: boolean; columnHideableChecked?: 'show' | 'hide'; columnSortable?: boolean; columnPinnable?: boolean; columnPinOptions?: DataGridColumnPinOption[]; showColumnMenuButton?: boolean; columnMenuButtonText?: string; columnMenuButtonType?: DataGridButtonType; columnMenuButtonColor?: ThemePalette; columnMenuButtonClass?: string; columnMenuButtonIcon?: string; columnMenuButtonFontIcon?: string; columnMenuButtonSvgIcon?: string; showColumnMenuHeader?: boolean; columnMenuHeaderText?: string; showColumnMenuFooter?: boolean; columnMenuFooterText?: string; noResultText?: string; } interface DataGridMenuItem { text: string | Observable; icon?: string; fontIcon?: string; svgIcon?: string; class?: string; disabled?: boolean | ((rowData: T) => boolean); click?: (rowData: T, event: Event) => void; iif?: (rowData: T) => boolean; children?: DataGridMenuItem[]; } declare class TabulatorTable implements OnChanges, AfterViewInit, OnDestroy { readonly data: _angular_core.InputSignal; readonly columns: _angular_core.InputSignal; readonly height: _angular_core.InputSignal; readonly layout: _angular_core.InputSignal<"fitData" | "fitColumns" | "fitDataFill" | "fitDataStretch">; readonly dataTree: _angular_core.InputSignal; readonly dataTreeChildField: _angular_core.InputSignal; readonly dataTreeStartExpanded: _angular_core.InputSignal; readonly dataTreeSelectPropagate: _angular_core.InputSignal; readonly selectable: _angular_core.InputSignal; readonly reactiveData: _angular_core.InputSignal; readonly placeholder: _angular_core.InputSignal; readonly autoResize: _angular_core.InputSignal; readonly selectableRows: _angular_core.InputSignal; readonly theme: _angular_core.InputSignal; readonly customClass: _angular_core.InputSignal; readonly rowFormatter: _angular_core.InputSignal<((row: any) => void | null) | undefined>; readonly options: _angular_core.InputSignal>; readonly rowDeleted: _angular_core.OutputEmitterRef; readonly cellEdited: _angular_core.OutputEmitterRef; readonly rowClick: _angular_core.OutputEmitterRef; readonly rowSelected: _angular_core.OutputEmitterRef; readonly tableReady: _angular_core.OutputEmitterRef; private _tabulator; private static instanceCounter; containerId: string; ngAfterViewInit(): void; ngOnChanges(changes: SimpleChanges): void; ngOnDestroy(): void; private initializeTable; private applyTheme; private applyCustomClass; private registerEvents; private updateData; private updateColumns; private destroyTable; private updateRowFormatter; getInstance(): Tabulator; redraw(): void; private getRowFormatter; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class AcpGridSelectableCell { ctrlKeyPressed: boolean; shiftKeyPressed: boolean; get selected(): boolean; private _selected; cellSelectable: boolean; cellSelectedChange: EventEmitter; onClick(event: MouseEvent): void; select(): void; deselect(): void; toggle(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } /** Indicates the width of a column. */ interface ColumnSize { /** The ID/name of the column, as defined in CdkColumnDef. */ readonly columnId: string; /** The width in pixels of the column. */ readonly size: number; /** The width in pixels of the column prior to this update, if known. */ readonly previousSize?: number; } /** Interface describing column size changes. */ interface ColumnSizeAction extends ColumnSize { /** * Whether the resize action should be applied instantaneously. False for events triggered during * a UI-triggered resize (such as with the mouse) until the mouse button is released. True * for all programmatically triggered resizes. */ readonly completeImmediately?: boolean; /** * Whether the resize action is being applied to a sticky/stickyEnd column. */ readonly isStickyColumn?: boolean; } /** * Originating source of column resize events within a table. * @docs-private */ declare class ColumnResizeNotifierSource { /** Emits when an in-progress resize is canceled. */ readonly resizeCanceled: Subject; /** Emits when a resize is applied. */ readonly resizeCompleted: Subject; /** Triggers a resize action. */ readonly triggerResize: Subject; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** Service for triggering column resizes imperatively or being notified of them. */ declare class ColumnResizeNotifier { private readonly _source; /** Emits whenever a column is resized. */ readonly resizeCompleted: Observable; /** Instantly resizes the specified column. */ resize(columnId: string, size: number): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵprov: _angular_core.ɵɵInjectableDeclaration; } /** Coordinates events between the column resize directives. */ declare class HeaderRowEventDispatcher { private readonly _ngZone; /** * Emits the currently hovered header cell or null when no header cells are hovered. * Exposed publicly for events to feed in, but subscribers should use headerCellHoveredDistinct, * defined below. */ readonly headerCellHovered: Subject; /** * Emits the header cell for which a user-triggered resize is active or null * when no resize is in progress. */ readonly overlayHandleActiveForCell: Subject; /** Distinct and shared version of headerCellHovered. */ readonly headerCellHoveredDistinct: Observable; /** * Emits the header that is currently hovered or hosting an active resize event (with active * taking precedence). */ readonly headerRowHoveredOrActiveDistinct: Observable; private readonly _headerRowHoveredOrActiveDistinctReenterZone; private _lastSeenRow; private _lastSeenRowHover; /** * Emits whether the specified row should show its overlay controls. * Emission occurs within the NgZone. */ resizeOverlayVisibleForHeaderRow(row: Element): Observable; private _enterZone; static ɵfac: _angular_core.ɵɵFactoryDeclaration