@acontplus/ng-components 2.1.7 → 2.1.8

package/types/acontplus-ng-components.d.ts

@@ -1,12 +1,12 @@
 import * as _angular_core from '@angular/core';
-import { Type, AfterViewInit, OnDestroy, ViewContainerRef, ElementRef, OnInit, TemplateRef, OnChanges, SimpleChanges, InjectionToken, QueryList, TrackByFunction, KeyValueChangeRecord, PipeTransform } from '@angular/core';
+import { Type, AfterViewInit, OnDestroy, ViewContainerRef, ElementRef, OnInit, TemplateRef, OnChanges, SimpleChanges, InjectionToken, QueryList, TrackByFunction, KeyValueChangeRecord, EventEmitter, ComponentRef, AfterContentInit, PipeTransform } from '@angular/core';
 import { MatDialogRef } from '@angular/material/dialog';
 import { ScrollStrategy } from '@angular/cdk/overlay';
 import { FormControl, ControlValueAccessor } 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 } from '@angular/cdk/a11y';
+import { LiveAnnouncer, FocusOrigin } from '@angular/cdk/a11y';
 import { Tabulator } from 'tabulator-tables';
 import * as rxjs from 'rxjs';
 import { Observable, Subject } from 'rxjs';
@@ -22,6 +22,8 @@ import { MatFormFieldControl } from '@angular/material/form-field';
 import { DatexOptions } from 'datex-ui';
 export { BOOTSTRAP_THEME, DEFAULT_THEME, Datex, DatexCallback, DatexLocale, DatexOptions, DatexTheme, MATERIAL_THEME, SPANISH_LOCALE, SPANISH_LOCALE_WITH_TIME } from 'datex-ui';
 import { ComponentType } from '@angular/cdk/portal';
+import { Direction } from '@angular/cdk/bidi';
+import { DialogRole, CdkDialogContainer, DialogRef } from '@angular/cdk/dialog';
 
 /**
  * A versatile card component that wraps Angular Material's mat-card with additional functionality
@@ -1198,8 +1200,9 @@ declare class DataGrid<T = any> implements AfterViewInit, OnDestroy, OnChanges {
     private _defaultOptions;
     private _keyboardNavService;
     private _destroy$;
+    paginator: _angular_core.Signal<MatPaginator | undefined>;
     table: MatTable<any>;
-    paginator: MatPaginator;
+    paginator1: MatPaginator;
     sort: MatSort;
     tableContainer: ElementRef<HTMLDivElement>;
     rowDefs: QueryList<MatRowDef<any>>;
@@ -1221,7 +1224,7 @@ declare class DataGrid<T = any> implements AfterViewInit, OnDestroy, OnChanges {
     noResultTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
     paginationTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
     summaryTemplate: _angular_core.InputSignal<TemplateRef<any> | DataGridCellTemplate | undefined>;
-    size: _angular_core.InputSignal<"medium" | "small" | "normal">;
+    size: _angular_core.InputSignal<"small" | "medium" | "normal">;
     headerCellTemplate: _angular_core.InputSignal<TemplateRef<any> | DataGridCellTemplate | undefined>;
     expandable: _angular_core.InputSignal<boolean>;
     expansionTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
@@ -1490,6 +1493,827 @@ declare class DateRangePicker<AsString extends boolean = true> implements OnInit
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangePicker<any>, "acp-date-range-picker", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholderText": { "alias": "placeholderText"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "inputReadonly": { "alias": "inputReadonly"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "formatOutputAsString": { "alias": "formatOutputAsString"; "required": false; "isSignal": true; }; "calendarIcon": { "alias": "calendarIcon"; "required": false; "isSignal": true; }; "showCalendarButton": { "alias": "showCalendarButton"; "required": false; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; "checkboxChecked": { "alias": "checkboxChecked"; "required": false; "isSignal": true; }; "checkboxReadonly": { "alias": "checkboxReadonly"; "required": false; "isSignal": true; }; "checkboxAriaLabel": { "alias": "checkboxAriaLabel"; "required": false; "isSignal": true; }; "checkboxPosition": { "alias": "checkboxPosition"; "required": false; "isSignal": true; }; }, { "checkboxChecked": "checkboxCheckedChange"; "dateRangeSelected": "dateRangeSelected"; "pickerShow": "pickerShow"; "pickerHide": "pickerHide"; "pickerApply": "pickerApply"; "pickerCancel": "pickerCancel"; "checkboxChange": "checkboxChange"; }, never, never, true, never>;
 }
 
+/** Options for where to set focus to automatically on dialog open. */
+type AutoFocusTarget = 'dialog' | 'first-tabbable' | 'first-heading';
+/** Possible overrides for a drawer's position. */
+type DrawerPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Configuration used when opening a drawer.
+ *
+ * This class provides all the configuration options available when opening
+ * a drawer, including positioning, sizing, behavior, and accessibility options.
+ *
+ * @template D The type of data to be injected into the drawer component
+ *
+ * @example
+ * ```typescript
+ * const config: AcpDrawerConfig = {
+ *   position: 'right',
+ *   width: '400px',
+ *   hasBackdrop: true,
+ *   disableClose: false,
+ *   data: { message: 'Hello from drawer!' },
+ *   ariaLabel: 'Settings drawer'
+ * };
+ *
+ * this.drawer.open(MyDrawerComponent, config);
+ * ```
+ */
+declare class AcpDrawerConfig<D = any> {
+    /** The view container to place the overlay for the drawer into. */
+    viewContainerRef?: ViewContainerRef;
+    /** ID for the drawer. If omitted, a unique one will be generated. */
+    id?: string;
+    /** The ARIA role of the dialog element. */
+    role?: DialogRole;
+    /** Extra CSS classes to be added to the drawer container. */
+    panelClass?: string | string[];
+    /** Text layout direction for the drawer. */
+    direction?: Direction;
+    /** Data being injected into the child component. */
+    data?: D | null;
+    /** Whether the drawer has a backdrop. */
+    hasBackdrop?: boolean;
+    /** Custom class for the backdrop. */
+    backdropClass?: string;
+    /** Whether the user can use escape or clicking outside to close the drawer. */
+    disableClose?: boolean;
+    /** Aria label to assign to the drawer element. */
+    ariaLabel?: string | null;
+    /**
+     * Whether this is a modal dialog. Used to set the `aria-modal` attribute. Off by default,
+     * because it can interfere with other overlay-based components (e.g. `mat-select`) and because
+     * it is redundant since the dialog marks all outside content as `aria-hidden` anyway.
+     */
+    ariaModal?: boolean;
+    /**
+     * Whether the drawer should close when the user goes backwards/forwards in history.
+     * Note that this usually doesn't include clicking on links (unless the user is using
+     * the `HashLocationStrategy`).
+     */
+    closeOnNavigation?: boolean;
+    /**
+     * Where the drawer should focus on open.
+     * @breaking-change 14.0.0 Remove boolean option from autoFocus. Use string or
+     * AutoFocusTarget instead.
+     */
+    autoFocus?: AutoFocusTarget | string | boolean;
+    /**
+     * Whether the drawer should restore focus to the
+     * previously-focused element, after it's closed.
+     */
+    restoreFocus?: boolean;
+    /** Scroll strategy to be used for the drawer. */
+    scrollStrategy?: ScrollStrategy;
+    /** Position of the drawer. */
+    position?: DrawerPosition;
+    /** Width of the drawer. */
+    width?: string;
+    /** Height of the drawer. */
+    height?: string;
+    /** Whether the drawer should take the full screen. */
+    fullScreen?: boolean;
+    /** Min-width of the drawer. If a number is provided, assumes pixel units. */
+    minWidth?: number | string;
+    /** Min-height of the drawer. If a number is provided, assumes pixel units. */
+    minHeight?: number | string;
+    /** Max-width of the drawer. If a number is provided, assumes pixel units. */
+    maxWidth?: number | string;
+    /** Max-height of the drawer. If a number is provided, assumes pixel units. */
+    maxHeight?: number | string;
+}
+
+/**
+ * Internal component that wraps user-provided drawer content.
+ *
+ * This component handles the drawer's animations, positioning, and lifecycle.
+ * It extends the CDK's DialogContainer to provide drawer-specific behavior
+ * including slide-in/slide-out animations and proper focus management.
+ *
+ * @docs-private
+ */
+declare class AcpDrawerContainer extends CdkDialogContainer<AcpDrawerConfig> implements OnDestroy {
+    /** Whether animations are disabled in the current environment. */
+    protected _animationsDisabled: boolean;
+    /** The state of the drawer animations. */
+    _animationState: 'void' | 'visible' | 'hidden';
+    /** Emits whenever the state of the animation changes. */
+    _animationStateChanged: EventEmitter<{
+        toState: "visible" | "hidden";
+        phase: "start" | "done";
+    }>;
+    /** Whether the component has been destroyed. */
+    private _destroyed;
+    /**
+     * Gets the CSS class for the drawer position.
+     * @returns CSS class name based on the drawer's position
+     */
+    get _drawerPosition(): string;
+    /**
+     * Called when content is attached to the container.
+     * Initializes the dialog container and starts the entrance animation.
+     */
+    protected _contentAttached(): void;
+    /**
+     * Begin animation of drawer entrance into view.
+     * Sets the animation state to visible and triggers change detection.
+     */
+    enter(): void;
+    /**
+     * Begin animation of the drawer exiting from view.
+     * Sets the animation state to hidden and triggers the exit animation.
+     */
+    exit(): void;
+    /**
+     * Lifecycle hook called when the component is destroyed.
+     * Marks the component as destroyed and calls the parent's ngOnDestroy.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Simulates animation events when animations are disabled.
+     * @param name The animation name to simulate
+     */
+    private _simulateAnimation;
+    /**
+     * Handles animation events for both start and end phases.
+     * @param isStart Whether this is the start or end of the animation
+     * @param animationName The name of the animation
+     */
+    protected _handleAnimationEvent(isStart: boolean, animationName: string): void;
+    /**
+     * Override to prevent automatic focus capture.
+     * Focus is handled by the enter animation instead.
+     */
+    protected _captureInitialFocus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcpDrawerContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AcpDrawerContainer, "acp-drawer-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Reference to a drawer dispatched from the drawer service.
+ *
+ * This class provides methods and properties to interact with an open drawer,
+ * including dismissing it, accessing its component instance, and subscribing
+ * to lifecycle events like opening and closing.
+ *
+ * @template T The type of the component opened in the drawer
+ * @template R The type of the result returned when the drawer is dismissed
+ *
+ * @example
+ * ```typescript
+ * const drawerRef = this.drawer.open(MyComponent);
+ *
+ * // Access component instance
+ * drawerRef.instance.someProperty = 'value';
+ *
+ * // Listen for dismissal
+ * drawerRef.afterDismissed().subscribe(result => {
+ *   console.log('Drawer dismissed with:', result);
+ * });
+ *
+ * // Dismiss programmatically
+ * drawerRef.dismiss('some result');
+ * ```
+ */
+declare class AcpDrawerRef<T = any, R = any> {
+    private _ref;
+    /** Instance of the component making up the content of the drawer. */
+    get instance(): T;
+    /**
+     * `ComponentRef` of the component opened into the drawer. Will be
+     * null when the drawer is opened using a `TemplateRef`.
+     */
+    get componentRef(): ComponentRef<T> | null;
+    /**
+     * Instance of the component into which the drawer content is projected.
+     * @docs-private
+     */
+    containerInstance: AcpDrawerContainer;
+    /** Whether the user is allowed to close the drawer. */
+    disableClose: boolean | undefined;
+    /** Unique ID for the drawer. */
+    id: string;
+    /** Subject for notifying the user that the drawer has been dismissed. */
+    private readonly _afterDismissed;
+    /** Subject for notifying the user that the drawer has opened and appeared. */
+    private readonly _afterOpened;
+    /** Result to be passed down to the `afterDismissed` stream. */
+    private _result;
+    /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */
+    private _closeFallbackTimeout;
+    /**
+     * Creates a new drawer reference.
+     * @param _ref The underlying CDK dialog reference
+     * @param config Configuration options for the drawer
+     * @param containerInstance The drawer container instance
+     */
+    constructor(_ref: DialogRef<R, T>, config: AcpDrawerConfig, containerInstance: AcpDrawerContainer);
+    /**
+     * Dismisses the drawer.
+     * @param result Data to be passed back to the drawer opener.
+     */
+    dismiss(result?: R): void;
+    /**
+     * Gets an observable that is notified when the drawer is finished closing.
+     * @returns Observable that emits the result passed to dismiss() or undefined
+     */
+    afterDismissed(): Observable<R | undefined>;
+    /**
+     * Gets an observable that is notified when the drawer has opened and appeared.
+     * @returns Observable that emits when the drawer is fully visible
+     */
+    afterOpened(): Observable<void>;
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     * @returns Observable that emits mouse events from backdrop clicks
+     */
+    backdropClick(): Observable<MouseEvent>;
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     * @returns Observable that emits keyboard events
+     */
+    keydownEvents(): Observable<KeyboardEvent>;
+}
+
+/** Injection token that can be used to access the data that was passed in to a drawer. */
+declare const ACP_DRAWER_DATA: InjectionToken<any>;
+/** Injection token that can be used to specify default drawer options. */
+declare const ACP_DRAWER_DEFAULT_OPTIONS: InjectionToken<AcpDrawerConfig<any>>;
+/**
+ * Service to trigger ACP drawer components.
+ *
+ * The AcpDrawer service provides methods to open, manage, and dismiss drawer panels
+ * that slide in from any side of the screen. It's built on top of Angular CDK Dialog
+ * and provides a flexible way to display additional content without navigating away
+ * from the current page.
+ *
+ * @example
+ * ```typescript
+ * constructor(private drawer: AcpDrawer) {}
+ *
+ * openDrawer() {
+ *   const drawerRef = this.drawer.open(MyDrawerComponent, {
+ *     position: 'right',
+ *     width: '400px',
+ *     data: { message: 'Hello from drawer!' }
+ *   });
+ *
+ *   drawerRef.afterDismissed().subscribe(result => {
+ *     console.log('Drawer closed with result:', result);
+ *   });
+ * }
+ * ```
+ */
+declare class AcpDrawer implements OnDestroy {
+    private _overlay;
+    private _parentDrawer;
+    private _defaultOptions;
+    private readonly _openDrawersAtThisLevel;
+    private readonly _afterAllDismissedAtThisLevel;
+    private readonly _afterOpenedAtThisLevel;
+    private _dialog;
+    /** Keeps track of the currently-open dialogs. */
+    get openDrawers(): AcpDrawerRef<any>[];
+    /** Stream that emits when a drawer has been opened. */
+    get afterOpened(): Subject<AcpDrawerRef<any>>;
+    /**
+     * Gets the subject for tracking when all drawers are dismissed.
+     * @returns Subject that emits when all drawers at this level are closed
+     */
+    private _getAfterAllDismissed;
+    /**
+     * Stream that emits when all open drawer have finished closing.
+     * Will emit on subscribe if there are no open drawers to begin with.
+     */
+    readonly afterAllDismissed: Observable<void>;
+    /**
+     * Opens a drawer containing the given component.
+     * @param component Type of the component to load into the drawer.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened drawer.
+     */
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: AcpDrawerConfig<D>): AcpDrawerRef<T, R>;
+    /**
+     * Opens a drawer containing the given template.
+     * @param template TemplateRef to instantiate as the drawer content.
+     * @param config Extra configuration options.
+     * @returns Reference to the newly-opened drawer.
+     */
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: AcpDrawerConfig<D>): AcpDrawerRef<T, R>;
+    /**
+     * Dismisses all of the currently-open drawers.
+     * This will close all drawers at the current level and emit the afterAllDismissed event.
+     */
+    dismissAll(): void;
+    /**
+     * Finds an open drawer by its id.
+     * @param id ID to use when looking up the drawer.
+     * @returns The drawer reference if found, undefined otherwise.
+     */
+    getDrawerById(id: string): AcpDrawerRef<any> | undefined;
+    /**
+     * Lifecycle hook that is called when the service is destroyed.
+     * Dismisses all drawers at this level and completes observables.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Dismisses multiple drawers.
+     * @param drawers Array of drawer references to dismiss
+     */
+    private _dismissDrawers;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcpDrawer, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AcpDrawer>;
+}
+
+/**
+ * Injection token that can be used to reference instances of `AcpPopoverContent`. It serves
+ * as alternative token to the actual `AcpPopoverContent` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const ACP_POPOVER_CONTENT: InjectionToken<AcpPopoverContent>;
+/**
+ * Base class for popover content that provides common functionality.
+ *
+ * This abstract class handles the attachment and detachment of popover content
+ * using Angular CDK portals. It manages the DOM manipulation required to display
+ * popover content in an overlay.
+ *
+ * @docs-private
+ */
+declare abstract class _AcpPopoverContentBase implements OnDestroy {
+    private _template;
+    private _appRef;
+    private _injector;
+    private _viewContainerRef;
+    private _document;
+    private _changeDetectorRef;
+    private _portal;
+    private _outlet;
+    /** Emits when the popover content has been attached. */
+    readonly _attached: Subject<void>;
+    /**
+     * Attaches the content with a particular context.
+     * @param context Context data to pass to the template
+     * @docs-private
+     */
+    attach(context?: any): void;
+    /**
+     * Detaches the content from the DOM.
+     * @docs-private
+     */
+    detach(): void;
+    /**
+     * Lifecycle hook called when the component is destroyed.
+     * Cleans up the portal outlet to prevent memory leaks.
+     */
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<_AcpPopoverContentBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<_AcpPopoverContentBase, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Popover content that will be rendered lazily once the popover is opened.
+ *
+ * This directive allows you to define content that should be rendered inside
+ * a popover panel. The content is only created when the popover is actually
+ * opened, which can improve performance for complex content.
+ *
+ * @example
+ * ```html
+ * <ng-template acpPopoverContent>
+ *   <div>This content will be shown in the popover</div>
+ * </ng-template>
+ * ```
+ */
+declare class AcpPopoverContent extends _AcpPopoverContentBase {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcpPopoverContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AcpPopoverContent, "ng-template[acpPopoverContent]", never, {}, {}, never, never, true, never>;
+}
+
+/** First value of popover's position. */
+type AcpPopoverPositionStart = 'above' | 'below' | 'before' | 'after';
+/** Second value of popover's position. */
+type AcpPopoverPositionEnd = AcpPopoverPositionStart | 'center';
+/** Popover's position. */
+type AcpPopoverPosition = [AcpPopoverPositionStart, AcpPopoverPositionEnd];
+/** Popover's trigger event. */
+type AcpPopoverTriggerEvent = 'click' | 'hover' | 'none';
+/** Reason why the popover was closed. */
+type PopoverCloseReason = void | 'click' | 'keydown' | 'tab';
+
+/**
+ * Interface for a custom popover panel that can be used with `acpPopoverTriggerFor`.
+ * @docs-private
+ */
+interface AcpPopoverPanel {
+    triggerEvent: AcpPopoverTriggerEvent;
+    enterDelay: number;
+    leaveDelay: number;
+    position: AcpPopoverPosition;
+    xOffset: number;
+    yOffset: number;
+    closeOnPanelClick: boolean;
+    closeOnBackdropClick: boolean;
+    closeDisabled: boolean;
+    backdropClass?: string;
+    overlayPanelClass?: string | string[];
+    hasBackdrop?: boolean;
+    templateRef: TemplateRef<any>;
+    lazyContent?: any;
+    direction?: Direction;
+    readonly panelId?: string;
+    readonly closed: EventEmitter<PopoverCloseReason>;
+    setCurrentStyles: (pos?: AcpPopoverPosition) => void;
+    setPositionClasses: (pos?: AcpPopoverPosition) => void;
+    setElevation: () => void;
+}
+/** Default `acp-popover` options that can be overridden. */
+interface AcpPopoverDefaultOptions {
+    triggerEvent?: AcpPopoverTriggerEvent;
+    enterDelay?: number;
+    leaveDelay?: number;
+    position?: AcpPopoverPosition;
+    xOffset?: number;
+    yOffset?: number;
+    arrowWidth?: number;
+    arrowHeight?: number;
+    arrowOffsetX?: number;
+    arrowOffsetY?: number;
+    hideArrow?: boolean;
+    closeOnPanelClick?: boolean;
+    closeOnBackdropClick?: boolean;
+    overlayPanelClass?: string;
+    backdropClass?: string;
+    hasBackdrop?: boolean;
+    focusTrapEnabled?: boolean;
+    focusTrapAutoCaptureEnabled?: boolean;
+}
+
+/** Injection token to be used to override the default options for `acp-popover`. */
+declare const ACP_POPOVER_DEFAULT_OPTIONS: InjectionToken<AcpPopoverDefaultOptions>;
+/**
+ * ACP Popover component that displays content in an overlay panel.
+ *
+ * The popover can be triggered by hover or click events and supports
+ * various positioning options. It's built on top of Angular CDK Overlay
+ * and provides a flexible way to display contextual information.
+ *
+ * @example
+ * ```html
+ * <acp-popover #popover="acpPopover" [position]="['below', 'after']">
+ *   <div>Popover content goes here</div>
+ * </acp-popover>
+ *
+ * <button [acpPopoverTriggerFor]="popover">Show popover</button>
+ * ```
+ */
+declare class AcpPopover implements AcpPopoverPanel, OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _elementRef;
+    private _unusedNgZone;
+    private _defaultOptions;
+    private _previousElevation?;
+    private _elevationPrefix;
+    private _baseElevation;
+    private _exitFallbackTimeout;
+    private _mouseleaveTimer;
+    /** Whether animations are currently disabled. */
+    protected _animationsDisabled: boolean;
+    /** Config object to be passed into the popover's class. */
+    _classList: Record<string, boolean>;
+    /** Current state of the panel animation. */
+    _panelAnimationState: 'void' | 'enter';
+    /** Emits whenever an animation on the popover completes. */
+    readonly _animationDone: Subject<"void" | "enter">;
+    /** Whether the popover is animating. */
+    _isAnimating: boolean;
+    /** Closing disabled on popover */
+    closeDisabled: boolean;
+    /** Config object to be passed into the popover's arrow style */
+    arrowStyles?: Record<string, unknown>;
+    /** Layout direction of the popover. */
+    direction?: Direction;
+    /** Class or list of classes to be added to the overlay panel. */
+    overlayPanelClass: string | string[];
+    /** Class to be added to the backdrop element. */
+    backdropClass: string | undefined;
+    /** aria-label for the popover panel. */
+    ariaLabel?: string;
+    /** aria-labelledby for the popover panel. */
+    ariaLabelledby?: string;
+    /** aria-describedby for the popover panel. */
+    ariaDescribedby?: string;
+    /** Popover's trigger event. */
+    triggerEvent: AcpPopoverTriggerEvent;
+    /** Popover's enter delay. */
+    enterDelay: number;
+    /** Popover's leave delay. */
+    leaveDelay: number;
+    /** Popover's position. */
+    get position(): AcpPopoverPosition;
+    set position(value: AcpPopoverPosition);
+    private _position;
+    /** Popover-panel's X offset. */
+    xOffset: number;
+    /** Popover-panel's Y offset. */
+    yOffset: number;
+    /** Popover-arrow's width. */
+    arrowWidth: number;
+    /** Popover-arrow's height. */
+    arrowHeight: number;
+    /** Popover-arrow's X offset. */
+    arrowOffsetX: number;
+    /** Popover-arrow's Y offset. */
+    arrowOffsetY: number;
+    /** Whether the popover arrow should be hidden. */
+    hideArrow: boolean;
+    /** Whether popover can be closed when click the popover-panel. */
+    closeOnPanelClick: boolean;
+    /** Whether popover can be closed when click the backdrop. */
+    closeOnBackdropClick: boolean;
+    /** Whether enable focus trap using `cdkTrapFocus`. */
+    focusTrapEnabled: boolean;
+    /** Whether enable focus trap auto capture using `cdkTrapFocusAutoCapture`. */
+    focusTrapAutoCaptureEnabled: boolean;
+    /** Whether the popover has a backdrop. It will always be false if the trigger event is hover. */
+    hasBackdrop: boolean | undefined;
+    /**
+     * This method takes classes set on the host acp-popover element and applies them on the
+     * popover template that displays in the overlay container. Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @param classes list of class names
+     */
+    set panelClass(classes: string);
+    private _previousPanelClass?;
+    /**
+     * This method takes classes set on the host acp-popover element and applies them on the
+     * popover template that displays in the overlay container. Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @deprecated Use `panelClass` instead.
+     * @breaking-change 8.0.0
+     */
+    get classList(): string;
+    set classList(classes: string);
+    /** Event emitted when the popover is closed. */
+    closed: EventEmitter<PopoverCloseReason>;
+    /** @docs-private */
+    templateRef: TemplateRef<any>;
+    /**
+     * Popover content that will be rendered lazily.
+     * @docs-private
+     */
+    lazyContent?: AcpPopoverContent;
+    readonly panelId: string;
+    /**
+     * Lifecycle hook called when the component is initialized.
+     * Sets up the initial position classes for the popover.
+     */
+    ngOnInit(): void;
+    /**
+     * Lifecycle hook called when the component is destroyed.
+     * Cleans up subscriptions and timers.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handle a keyboard event from the popover, delegating to the appropriate action.
+     * @param event The keyboard event to handle
+     */
+    _handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Close popover on click if `closeOnPanelClick` is true.
+     */
+    _handleClick(): void;
+    /**
+     * Disables close of popover when leaving trigger element and mouse over the popover.
+     */
+    _handleMouseOver(): void;
+    /**
+     * Enables close of popover when mouse leaving popover element.
+     */
+    _handleMouseLeave(): void;
+    /**
+     * Sets the current styles for the popover to allow for dynamically changing settings.
+     * @param pos The position to set styles for, defaults to current position
+     */
+    setCurrentStyles(pos?: AcpPopoverPosition): void;
+    /**
+     * It's necessary to set position-based classes to ensure the popover panel animation
+     * folds out from the correct direction.
+     * @param pos The position to set classes for, defaults to current position
+     */
+    setPositionClasses(pos?: AcpPopoverPosition): void;
+    /**
+     * Sets the popover-panel's elevation.
+     * Applies Material Design elevation classes based on the base elevation level.
+     */
+    setElevation(): void;
+    /**
+     * Callback that is invoked when the panel animation completes.
+     * @param state The animation state that completed
+     */
+    protected _onAnimationDone(state: string): void;
+    /**
+     * Callback that is invoked when the panel animation starts.
+     * @param state The animation state that started
+     */
+    protected _onAnimationStart(state: string): void;
+    /**
+     * Sets the open state of the popover and manages animations.
+     * @param isOpen Whether the popover should be open
+     */
+    _setIsOpen(isOpen: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcpPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AcpPopover, "acp-popover", ["acpPopover"], { "backdropClass": { "alias": "backdropClass"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; }; "triggerEvent": { "alias": "triggerEvent"; "required": false; }; "enterDelay": { "alias": "enterDelay"; "required": false; }; "leaveDelay": { "alias": "leaveDelay"; "required": false; }; "position": { "alias": "position"; "required": false; }; "xOffset": { "alias": "xOffset"; "required": false; }; "yOffset": { "alias": "yOffset"; "required": false; }; "arrowWidth": { "alias": "arrowWidth"; "required": false; }; "arrowHeight": { "alias": "arrowHeight"; "required": false; }; "arrowOffsetX": { "alias": "arrowOffsetX"; "required": false; }; "arrowOffsetY": { "alias": "arrowOffsetY"; "required": false; }; "hideArrow": { "alias": "hideArrow"; "required": false; }; "closeOnPanelClick": { "alias": "closeOnPanelClick"; "required": false; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; }; "focusTrapEnabled": { "alias": "focusTrapEnabled"; "required": false; }; "focusTrapAutoCaptureEnabled": { "alias": "focusTrapAutoCaptureEnabled"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "classList": { "alias": "classList"; "required": false; }; }, { "closed": "closed"; }, ["lazyContent"], ["*"], true, never>;
+    static ngAcceptInputType_hideArrow: unknown;
+    static ngAcceptInputType_closeOnPanelClick: unknown;
+    static ngAcceptInputType_closeOnBackdropClick: unknown;
+    static ngAcceptInputType_focusTrapEnabled: unknown;
+    static ngAcceptInputType_focusTrapAutoCaptureEnabled: unknown;
+    static ngAcceptInputType_hasBackdrop: unknown;
+}
+
+/**
+ * Directive that marks an element as a popover target.
+ *
+ * This directive provides a reference to an element that can be used
+ * as the target for popover positioning. It's useful when you want
+ * the popover to appear relative to a different element than the trigger.
+ *
+ * @example
+ * ```html
+ * <div acpPopoverTarget #target="acpPopoverTarget">Target element</div>
+ * <button [acpPopoverTriggerFor]="popover" [acpPopoverTargetAt]="target">
+ *   Trigger
+ * </button>
+ * ```
+ */
+declare class AcpPopoverTarget {
+    /** Reference to the target element. */
+    elementRef: ElementRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcpPopoverTarget, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AcpPopoverTarget, "acp-popover-target, [acpPopoverTarget]", ["acpPopoverTarget"], {}, {}, never, never, true, never>;
+}
+
+/** Injection token that determines the scroll handling while the popover is open. */
+declare const ACP_POPOVER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/**
+ * This directive is intended to be used in conjunction with an `acp-popover` tag. It is
+ * responsible for toggling the display of the provided popover instance.
+ *
+ * The trigger handles various events (click, hover) and manages the popover's lifecycle,
+ * including opening, closing, positioning, and focus management.
+ *
+ * @example
+ * ```html
+ * <acp-popover #popover="acpPopover">
+ *   <div>Popover content</div>
+ * </acp-popover>
+ *
+ * <button [acpPopoverTriggerFor]="popover">
+ *   Show popover
+ * </button>
+ * ```
+ */
+declare class AcpPopoverTrigger implements AfterContentInit, OnDestroy {
+    private _overlay;
+    private _elementRef;
+    private _viewContainerRef;
+    private _dir;
+    private _changeDetectorRef;
+    private _focusMonitor;
+    private _portal?;
+    private _overlayRef;
+    private _popoverOpen;
+    private _halt;
+    private _positionSubscription;
+    private _popoverCloseSubscription;
+    private _pendingRemoval;
+    private _closingActionsSubscription;
+    private _scrollStrategy;
+    private _mouseoverTimer;
+    private _mouseleaveTimer;
+    _openedBy: Exclude<FocusOrigin, 'program' | null> | undefined;
+    /** References the popover instance that the trigger is associated with. */
+    get popover(): AcpPopoverPanel;
+    set popover(popover: AcpPopoverPanel);
+    private _popover;
+    /** Data to be passed along to any lazily-rendered content. */
+    popoverData: any;
+    /** References the popover target instance that the trigger is associated with. */
+    targetElement?: AcpPopoverTarget;
+    /** Popover trigger event */
+    triggerEvent?: AcpPopoverTriggerEvent;
+    /** Event emitted when the associated popover is opened. */
+    popoverOpened: EventEmitter<void>;
+    /** Event emitted when the associated popover is closed. */
+    popoverClosed: EventEmitter<void>;
+    /**
+     * Lifecycle hook called after content initialization.
+     * Validates the popover reference and sets up initial configuration.
+     */
+    ngAfterContentInit(): void;
+    /**
+     * Lifecycle hook called when the component is destroyed.
+     * Cleans up subscriptions and overlay references.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Sets the current configuration for the popover.
+     * Updates trigger event and applies current styles.
+     */
+    private _setCurrentConfig;
+    /** Whether the popover is open. */
+    get popoverOpen(): boolean;
+    /** The text direction of the containing app. */
+    get dir(): Direction;
+    /**
+     * Handles mouse click on the trigger.
+     * @param _event The mouse event
+     */
+    _handleClick(_event: MouseEvent): void;
+    /**
+     * Handles mouse enter on the trigger.
+     * @param _event The mouse event
+     */
+    _handleMouseEnter(_event: MouseEvent): void;
+    /**
+     * Handles mouse leave on the trigger.
+     * @param _event The mouse event
+     */
+    _handleMouseLeave(_event: MouseEvent): void;
+    /** Handles mouse presses on the trigger. */
+    _handleMousedown(event: MouseEvent): void;
+    /** Handles key presses on the trigger. */
+    _handleKeydown(event: KeyboardEvent): void;
+    /** Toggles the popover between the open and closed states. */
+    togglePopover(): void;
+    /** Opens the popover. */
+    openPopover(): void;
+    /** Closes the popover. */
+    closePopover(): void;
+    /**
+     * Focuses the popover trigger.
+     * @param origin Source of the popover trigger's focus.
+     */
+    focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Removes the popover from the DOM. */
+    private _destroyPopover;
+    /**
+     * This method sets the popover state to open.
+     */
+    private _initPopover;
+    private _setIsPopoverOpen;
+    /**
+     * This method checks that a valid instance of AcpPopover has been passed into
+     * `acpPopoverTriggerFor`. If not, an exception is thrown.
+     */
+    private _checkPopover;
+    /**
+     * This method creates the overlay from the provided popover's template and saves its
+     * OverlayRef so that it can be attached to the DOM when openPopover is called.
+     */
+    private _createOverlay;
+    /**
+     * This method builds the configuration object needed to create the overlay, the OverlayConfig.
+     * @returns OverlayConfig
+     */
+    private _getOverlayConfig;
+    private _getTargetElement;
+    /**
+     * Listens to changes in the position of the overlay and sets the correct classes
+     * on the popover based on the new position. This ensures the animation origin is always
+     * correct, even if a fallback position is used for the overlay.
+     */
+    private _subscribeToPositions;
+    /**
+     * Sets the appropriate positions on a position strategy
+     * so the overlay connects with the trigger correctly.
+     * @param positionStrategy Strategy whose position to update.
+     */
+    private _setPosition;
+    /** Returns a stream that emits whenever an action that should close the popover occurs. */
+    private _popoverClosingActions;
+    /** Gets the portal that should be attached to the overlay. */
+    private _getPortal;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AcpPopoverTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AcpPopoverTrigger, "[acpPopoverTriggerFor]", ["acpPopoverTrigger"], { "popover": { "alias": "acpPopoverTriggerFor"; "required": false; }; "popoverData": { "alias": "popoverData"; "required": false; }; "targetElement": { "alias": "targetElement"; "required": false; }; "triggerEvent": { "alias": "triggerEvent"; "required": false; }; }, { "popoverOpened": "popoverOpened"; "popoverClosed": "popoverClosed"; }, never, never, true, never>;
+}
+
+/**
+ * Throws an exception for the case when popover trigger doesn't have a valid acp-popover instance
+ */
+declare function throwAcpPopoverMissingError(): void;
+/**
+ * Throws an exception for the case when popover's acpPopoverPosition[0] value isn't valid.
+ * In other words, it doesn't match 'above', 'below', 'before' or 'after'.
+ */
+declare function throwAcpPopoverInvalidPositionStart(): void;
+/**
+ * Throws an exception for the case when popover's acpPopoverPosition[1] value isn't valid.
+ * In other words, it doesn't match 'above', 'below', 'before', 'after' or 'center'.
+ */
+declare function throwAcpPopoverInvalidPositionEnd(): void;
+
 declare class ToUpperCase implements ControlValueAccessor {
     private el;
     private renderer;
@@ -1533,5 +2357,5 @@ declare class StatusDisplayPipe implements PipeTransform {
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<StatusDisplayPipe, "statusDisplay", true>;
 }
 
-export { AUTOCOMPLETE_WRAPPER_CUSTOMER_CONFIG, AUTOCOMPLETE_WRAPPER_DEFAULT_CONFIG, AUTOCOMPLETE_WRAPPER_LOCAL_CONFIG, AUTOCOMPLETE_WRAPPER_PAGINATED_CONFIG, AUTOCOMPLETE_WRAPPER_PRODUCT_CONFIG, AUTOCOMPLETE_WRAPPER_SIMPLE_CONFIG, AdvancedDialogService, AutocompleteWrapperService, Button, DATA_GRID_DEFAULT_OPTIONS, DataGrid, DateRangePicker, DialogWrapper, DynamicCard, DynamicSelect, GetTotalPipe, IconRegistryService, InputChip, KeyboardNavigationService, OverlayService, Pagination, ReusableAutocompleteComponent, Spinner, StatusDisplayPipe, SvgIcon, TabulatorTable, ThemeSwitcher, ThemeToggle, ToUpperCase, UserIcon, createAutocompleteWrapperConfig };
-export type { AutocompleteWrapperActions, AutocompleteWrapperConfig, AutocompleteWrapperEventHandler, AutocompleteWrapperEvents, AutocompleteWrapperFilters, AutocompleteWrapperItem, AutocompleteWrapperItemProperty, AutocompleteWrapperPaginationInfo, AutocompleteWrapperSearchField, AutocompleteWrapperSearchFunction, AutocompleteWrapperSearchMode, AutocompleteWrapperSearchResult, AutocompleteWrapperState, AutocompleteWrapperStockOption, DataGridButtonType, DataGridCellTemplate, DataGridColumn, DataGridColumnButton, DataGridColumnButtonBadge, DataGridColumnButtonPop, DataGridColumnButtonTooltip, DataGridColumnPinOption, DataGridColumnPinValue, DataGridColumnTag, DataGridColumnTagValue, DataGridColumnType, DataGridColumnTypeParameter, DataGridDefaultOptions, DataGridMenuItem, DataGridRowClassFormatter, DataGridRowSelectionFormatter, DataGridSortProp, DateRangePickerOptions, DateRangeValue, DialogSize, DialogWrapperConfig, FocusableElement, IconRegistryConfig, MatCustomDialogConfig, ReusableAutocompleteWrapperComponent, TabulatorColumn, TabulatorConfig, TabulatorEventHandlers, TabulatorTheme };
+export { ACP_DRAWER_DATA, ACP_DRAWER_DEFAULT_OPTIONS, ACP_POPOVER_CONTENT, ACP_POPOVER_DEFAULT_OPTIONS, ACP_POPOVER_SCROLL_STRATEGY, AUTOCOMPLETE_WRAPPER_CUSTOMER_CONFIG, AUTOCOMPLETE_WRAPPER_DEFAULT_CONFIG, AUTOCOMPLETE_WRAPPER_LOCAL_CONFIG, AUTOCOMPLETE_WRAPPER_PAGINATED_CONFIG, AUTOCOMPLETE_WRAPPER_PRODUCT_CONFIG, AUTOCOMPLETE_WRAPPER_SIMPLE_CONFIG, AcpDrawer, AcpDrawerConfig, AcpDrawerContainer, AcpDrawerRef, AcpPopover, AcpPopoverContent, AcpPopoverTarget, AcpPopoverTrigger, AdvancedDialogService, AutocompleteWrapperService, Button, DATA_GRID_DEFAULT_OPTIONS, DataGrid, DateRangePicker, DialogWrapper, DynamicCard, DynamicSelect, GetTotalPipe, IconRegistryService, InputChip, KeyboardNavigationService, OverlayService, Pagination, ReusableAutocompleteComponent, Spinner, StatusDisplayPipe, SvgIcon, TabulatorTable, ThemeSwitcher, ThemeToggle, ToUpperCase, UserIcon, _AcpPopoverContentBase, createAutocompleteWrapperConfig, throwAcpPopoverInvalidPositionEnd, throwAcpPopoverInvalidPositionStart, throwAcpPopoverMissingError };
+export type { AcpPopoverDefaultOptions, AcpPopoverPanel, AcpPopoverPosition, AcpPopoverPositionEnd, AcpPopoverPositionStart, AcpPopoverTriggerEvent, AutoFocusTarget, AutocompleteWrapperActions, AutocompleteWrapperConfig, AutocompleteWrapperEventHandler, AutocompleteWrapperEvents, AutocompleteWrapperFilters, AutocompleteWrapperItem, AutocompleteWrapperItemProperty, AutocompleteWrapperPaginationInfo, AutocompleteWrapperSearchField, AutocompleteWrapperSearchFunction, AutocompleteWrapperSearchMode, AutocompleteWrapperSearchResult, AutocompleteWrapperState, AutocompleteWrapperStockOption, DataGridButtonType, DataGridCellTemplate, DataGridColumn, DataGridColumnButton, DataGridColumnButtonBadge, DataGridColumnButtonPop, DataGridColumnButtonTooltip, DataGridColumnPinOption, DataGridColumnPinValue, DataGridColumnTag, DataGridColumnTagValue, DataGridColumnType, DataGridColumnTypeParameter, DataGridDefaultOptions, DataGridMenuItem, DataGridRowClassFormatter, DataGridRowSelectionFormatter, DataGridSortProp, DateRangePickerOptions, DateRangeValue, DialogSize, DialogWrapperConfig, DrawerPosition, FocusableElement, IconRegistryConfig, MatCustomDialogConfig, PopoverCloseReason, ReusableAutocompleteWrapperComponent, TabulatorColumn, TabulatorConfig, TabulatorEventHandlers, TabulatorTheme };