@raintonic/formaui 0.2.0

package/types/raintonic-formaui-cdk-overlay.d.ts

@@ -0,0 +1,843 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ComponentRef, TemplateRef, Injector, ElementRef, Renderer2, OnInit, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Injection token for the overlay container element
+ */
+declare const FUI_OVERLAY_CONTAINER: InjectionToken<HTMLElement>;
+/**
+ * Injection token for the overlay scroll strategy
+ */
+declare const FUI_OVERLAY_SCROLL_STRATEGY: InjectionToken<() => FuiScrollStrategy>;
+/**
+ * Available overlay positions for connected positioning
+ */
+interface FuiConnectedPosition {
+    /** Horizontal alignment of the overlay relative to the origin */
+    originX: 'start' | 'center' | 'end';
+    /** Vertical alignment of the overlay relative to the origin */
+    originY: 'top' | 'center' | 'bottom';
+    /** Horizontal alignment of the overlay panel */
+    overlayX: 'start' | 'center' | 'end';
+    /** Vertical alignment of the overlay panel */
+    overlayY: 'top' | 'center' | 'bottom';
+    /** Offset in pixels along the x-axis */
+    offsetX?: number;
+    /** Offset in pixels along the y-axis */
+    offsetY?: number;
+    /** Weight for this position when multiple positions are provided */
+    weight?: number;
+}
+/**
+ * Global position configuration
+ */
+interface FuiGlobalPosition {
+    /** Top position in pixels or CSS value */
+    top?: string | number;
+    /** Bottom position in pixels or CSS value */
+    bottom?: string | number;
+    /** Left position in pixels or CSS value */
+    left?: string | number;
+    /** Right position in pixels or CSS value */
+    right?: string | number;
+    /** Width in pixels or CSS value */
+    width?: string | number;
+    /** Height in pixels or CSS value */
+    height?: string | number;
+    /** Min width in pixels or CSS value */
+    minWidth?: string | number;
+    /** Min height in pixels or CSS value */
+    minHeight?: string | number;
+    /** Max width in pixels or CSS value */
+    maxWidth?: string | number;
+    /** Max height in pixels or CSS value */
+    maxHeight?: string | number;
+}
+/**
+ * Scroll strategy types
+ */
+type FuiScrollStrategyType = 'reposition' | 'close' | 'block' | 'noop';
+/**
+ * Backdrop click behavior
+ */
+type FuiBackdropClickBehavior = 'close' | 'ignore';
+/**
+ * Configuration for creating an overlay
+ */
+interface FuiOverlayConfig {
+    /** Position strategy for the overlay */
+    positionStrategy?: FuiPositionStrategy;
+    /** Scroll strategy for the overlay */
+    scrollStrategy?: FuiScrollStrategy;
+    /** Whether to show a backdrop */
+    hasBackdrop?: boolean;
+    /** CSS class(es) to apply to the backdrop */
+    backdropClass?: string | string[];
+    /** Behavior when backdrop is clicked */
+    backdropClickBehavior?: FuiBackdropClickBehavior;
+    /** CSS class(es) to apply to the overlay pane */
+    panelClass?: string | string[];
+    /** Width of the overlay */
+    width?: string | number;
+    /** Height of the overlay */
+    height?: string | number;
+    /** Min width of the overlay */
+    minWidth?: string | number;
+    /** Min height of the overlay */
+    minHeight?: string | number;
+    /** Max width of the overlay */
+    maxWidth?: string | number;
+    /** Max height of the overlay */
+    maxHeight?: string | number;
+    /** Direction of the overlay content */
+    direction?: 'ltr' | 'rtl';
+    /** Whether to dispose the overlay when the backdrop is clicked */
+    disposeOnNavigation?: boolean;
+    /** Custom injector for the overlay content */
+    injector?: Injector;
+}
+/**
+ * Reference to an overlay instance
+ */
+interface FuiOverlayRef {
+    /** Unique identifier for this overlay */
+    readonly id: string;
+    /** The overlay pane element */
+    readonly overlayElement: HTMLElement;
+    /** The backdrop element (if any) */
+    readonly backdropElement: HTMLElement | null;
+    /** Observable that emits when the backdrop is clicked */
+    readonly backdropClick: Observable<MouseEvent>;
+    /** Observable that emits when a key is pressed while the overlay has focus */
+    readonly keydownEvents: Observable<KeyboardEvent>;
+    /** Observable that emits when the overlay is attached to the DOM */
+    readonly attachments: Observable<void>;
+    /** Observable that emits when the overlay is detached from the DOM */
+    readonly detachments: Observable<void>;
+    /** Whether the overlay is currently attached */
+    readonly hasAttached: boolean;
+    /**
+     * Attaches content to the overlay
+     * @param content The content to attach (component, template, or DOM element)
+     * @param injector Optional injector for component content
+     */
+    attach<T = unknown>(content: ComponentRef<T> | TemplateRef<unknown> | HTMLElement, injector?: Injector): ComponentRef<T> | undefined;
+    /**
+     * Detaches the content from the overlay
+     */
+    detach(): void;
+    /**
+     * Disposes the overlay and cleans up resources
+     */
+    dispose(): void;
+    /**
+     * Updates the position of the overlay
+     */
+    updatePosition(): void;
+    /**
+     * Updates the size of the overlay
+     */
+    updateSize(config?: Pick<FuiOverlayConfig, 'width' | 'height' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight'>): void;
+    /**
+     * Adds CSS classes to the overlay pane
+     */
+    addPanelClass(classes: string | string[]): void;
+    /**
+     * Removes CSS classes from the overlay pane
+     */
+    removePanelClass(classes: string | string[]): void;
+    /**
+     * Gets the current configuration of the overlay
+     */
+    getConfig(): FuiOverlayConfig;
+    /**
+     * Updates the configuration of the overlay
+     */
+    updateConfig(config: Partial<FuiOverlayConfig>): void;
+}
+/**
+ * Strategy for positioning overlays
+ */
+interface FuiPositionStrategy {
+    /** Applies the positioning strategy */
+    apply(): void;
+    /** Disposes the strategy and cleans up resources */
+    dispose(): void;
+    /** Detaches the strategy from the overlay */
+    detach(): void;
+    /** Sets the overlay element reference */
+    setOverlayElement(element: HTMLElement): void;
+    /** Observable that emits when the position changes */
+    readonly positionChanges: Observable<FuiConnectedOverlayPositionChange>;
+}
+/**
+ * Strategy for handling scroll events
+ */
+interface FuiScrollStrategy {
+    /** Enables the scroll strategy */
+    enable(): void;
+    /** Disables the scroll strategy */
+    disable(): void;
+    /** Attaches the strategy to an overlay reference */
+    attach(overlayRef: FuiOverlayRef): void;
+    /** Detaches the strategy from the overlay reference */
+    detach(): void;
+}
+/**
+ * Position change event for connected overlays
+ */
+interface FuiConnectedOverlayPositionChange {
+    /** The position that was applied */
+    connectionPair: FuiConnectedPosition;
+    /** The scroll position that triggered the change */
+    scrollableViewProperties: FuiScrollableViewProperties;
+}
+/**
+ * Properties of a scrollable view
+ */
+interface FuiScrollableViewProperties {
+    /** The size of the scrollable view */
+    size: {
+        width: number;
+        height: number;
+    };
+    /** The scroll position of the view */
+    scrollPosition: {
+        top: number;
+        left: number;
+    };
+}
+/**
+ * Content that can be attached to an overlay
+ */
+type FuiOverlayContent<T = unknown> = ComponentRef<T> | TemplateRef<unknown> | HTMLElement | string;
+/**
+ * Factory function for creating scroll strategies
+ */
+type FuiScrollStrategyFactory = () => FuiScrollStrategy;
+/**
+ * Options for creating a connected position strategy
+ */
+interface FuiConnectedPositionStrategyOptions {
+    /** The element to position relative to */
+    origin: ElementRef<HTMLElement> | HTMLElement;
+    /** Array of preferred positions */
+    positions: FuiConnectedPosition[];
+    /** Whether to push the overlay on-screen if it would otherwise be clipped */
+    withPush?: boolean;
+    /** Whether to grow the overlay after it reaches the edge of the viewport */
+    withGrowAfterOpen?: boolean;
+    /** Whether to lock the position after the first time it is positioned */
+    withLockedPosition?: boolean;
+    /** Whether to apply the default offset */
+    withDefaultOffsetX?: number;
+    /** Whether to apply the default offset */
+    withDefaultOffsetY?: number;
+    /** Whether to transform the origin element */
+    withTransformOriginOn?: ElementRef<HTMLElement> | HTMLElement;
+    /** Margin between the overlay and the viewport edge */
+    viewportMargin?: number;
+    /** Whether to use flexible dimensions */
+    withFlexibleDimensions?: boolean;
+}
+/**
+ * Options for creating a global position strategy
+ */
+interface FuiGlobalPositionStrategyOptions extends FuiGlobalPosition {
+    /** Whether to center the overlay horizontally */
+    centerHorizontally?: boolean;
+    /** Whether to center the overlay vertically */
+    centerVertically?: boolean;
+}
+/**
+ * Overlay size configuration
+ */
+interface FuiOverlaySizeConfig {
+    width?: string | number;
+    height?: string | number;
+    minWidth?: string | number;
+    minHeight?: string | number;
+    maxWidth?: string | number;
+    maxHeight?: string | number;
+}
+/**
+ * Overlay state information
+ */
+interface FuiOverlayState {
+    /** Whether the overlay is attached */
+    isAttached: boolean;
+    /** Whether the overlay has a backdrop */
+    hasBackdrop: boolean;
+    /** The current size configuration */
+    size: FuiOverlaySizeConfig;
+    /** The current position strategy */
+    positionStrategy: FuiPositionStrategy | null;
+    /** The current scroll strategy */
+    scrollStrategy: FuiScrollStrategy | null;
+}
+
+/**
+ * # FuiGlobalPositionStrategy
+ *
+ * A position strategy that positions the overlay at a fixed position on the screen.
+ * This strategy is useful for modals, dialogs, and other overlays that should be
+ * positioned relative to the viewport rather than a specific element.
+ *
+ * ## Features
+ * - Fixed positioning relative to the viewport
+ * - Support for all CSS position properties (top, bottom, left, right)
+ * - Centering options (horizontal and vertical)
+ * - Responsive positioning
+ * - Size constraints (width, height, min/max dimensions)
+ */
+declare class FuiGlobalPositionStrategy implements FuiPositionStrategy {
+    private _renderer;
+    private _options;
+    private _overlayElement?;
+    private readonly _positionChanges;
+    private _isDisposed;
+    constructor(_renderer: Renderer2, _options?: FuiGlobalPositionStrategyOptions);
+    /** Observable that emits when the position changes */
+    get positionChanges(): Observable<FuiConnectedOverlayPositionChange>;
+    /**
+     * Sets the overlay element reference
+     */
+    setOverlayElement(element: HTMLElement): void;
+    /**
+     * Applies the positioning strategy
+     */
+    apply(): void;
+    /**
+     * Sets the top position
+     */
+    top(value?: string | number): this;
+    /**
+     * Sets the bottom position
+     */
+    bottom(value?: string | number): this;
+    /**
+     * Sets the left position
+     */
+    left(value?: string | number): this;
+    /**
+     * Sets the right position
+     */
+    right(value?: string | number): this;
+    /**
+     * Centers the overlay horizontally
+     */
+    centerHorizontally(): this;
+    /**
+     * Centers the overlay vertically
+     */
+    centerVertically(): this;
+    /**
+     * Sets the width of the overlay
+     */
+    width(value: string | number): this;
+    /**
+     * Sets the height of the overlay
+     */
+    height(value: string | number): this;
+    /**
+     * Sets the minimum width of the overlay
+     */
+    minWidth(value: string | number): this;
+    /**
+     * Sets the minimum height of the overlay
+     */
+    minHeight(value: string | number): this;
+    /**
+     * Sets the maximum width of the overlay
+     */
+    maxWidth(value: string | number): this;
+    /**
+     * Sets the maximum height of the overlay
+     */
+    maxHeight(value: string | number): this;
+    /**
+     * Disposes the strategy and cleans up resources
+     */
+    dispose(): void;
+    /**
+     * Detaches the strategy from the overlay
+     */
+    detach(): void;
+    private _applyPosition;
+    private _applyCentering;
+    private _applySizeConstraints;
+    private _coerceCssPixelValue;
+}
+
+/**
+ * # FuiConnectedPositionStrategy
+ *
+ * A position strategy that positions the overlay relative to a connected element.
+ * This strategy is ideal for tooltips, dropdowns, menus, and other overlays that
+ * should be positioned relative to a trigger element.
+ *
+ * ## Features
+ * - Positions overlay relative to an origin element
+ * - Multiple fallback positions with automatic selection
+ * - Collision detection and viewport boundary handling
+ * - Push and grow behaviors for constrained spaces
+ * - Scroll and resize event handling
+ * - Transform origin support for animations
+ */
+declare class FuiConnectedPositionStrategy implements FuiPositionStrategy {
+    private _renderer;
+    private _overlayElement?;
+    private _originElement;
+    private _positions;
+    private _appliedPosition?;
+    private _isDisposed;
+    private _resizeSubscription?;
+    private _scrollSubscription?;
+    private readonly _positionChanges;
+    private _withPush;
+    private _withGrowAfterOpen;
+    private _withLockedPosition;
+    private _defaultOffsetX;
+    private _defaultOffsetY;
+    private _transformOriginElement?;
+    private _viewportMargin;
+    private _withFlexibleDimensions;
+    constructor(_renderer: Renderer2, options: FuiConnectedPositionStrategyOptions);
+    /** Observable that emits when the position changes */
+    get positionChanges(): Observable<FuiConnectedOverlayPositionChange>;
+    /**
+     * Sets the overlay element reference
+     */
+    setOverlayElement(element: HTMLElement): void;
+    /**
+     * Applies the positioning strategy
+     */
+    apply(): void;
+    /**
+     * Updates the positions array
+     */
+    withPositions(positions: FuiConnectedPosition[]): this;
+    /**
+     * Enables pushing the overlay on-screen if it would otherwise be clipped
+     */
+    withPush(enabled?: boolean): this;
+    /**
+     * Enables growing the overlay after it reaches the edge of the viewport
+     */
+    withGrowAfterOpen(enabled?: boolean): this;
+    /**
+     * Locks the position after the first time it is positioned
+     */
+    withLockedPosition(enabled?: boolean): this;
+    /**
+     * Sets the default offset for the x-axis
+     */
+    withDefaultOffsetX(offset: number): this;
+    /**
+     * Sets the default offset for the y-axis
+     */
+    withDefaultOffsetY(offset: number): this;
+    /**
+     * Sets the element to use for transform origin
+     */
+    withTransformOriginOn(element: ElementRef<HTMLElement> | HTMLElement): this;
+    /**
+     * Sets the margin between the overlay and the viewport edge
+     */
+    withViewportMargin(margin: number): this;
+    /**
+     * Enables flexible dimensions
+     */
+    withFlexibleDimensions(enabled?: boolean): this;
+    /**
+     * Disposes the strategy and cleans up resources
+     */
+    dispose(): void;
+    /**
+     * Detaches the strategy from the overlay
+     */
+    detach(): void;
+    private _getBestPosition;
+    private _applyPosition;
+    private _calculatePositionedRect;
+    private _calculatePositionScore;
+    private _pushWithinViewport;
+    private _setTransformOrigin;
+    private _applyFlexibleDimensions;
+    private _setupEventListeners;
+    private _removeEventListeners;
+    private _getViewportSize;
+    private _getScrollableViewProperties;
+}
+
+/**
+ * # FuiNoopScrollStrategy
+ *
+ * A scroll strategy that does nothing when the user scrolls.
+ * This is useful for overlays that should remain in their position
+ * regardless of scrolling.
+ */
+declare class FuiNoopScrollStrategy implements FuiScrollStrategy {
+    enable(): void;
+    disable(): void;
+    attach(_overlayRef: FuiOverlayRef): void;
+    detach(): void;
+}
+/**
+ * # FuiCloseScrollStrategy
+ *
+ * A scroll strategy that closes the overlay when the user scrolls.
+ * This is useful for overlays like tooltips or dropdowns that should
+ * disappear when the user scrolls away from the trigger element.
+ */
+declare class FuiCloseScrollStrategy implements FuiScrollStrategy {
+    private _threshold;
+    private _overlayRef?;
+    private _scrollListener?;
+    private _isEnabled;
+    constructor(_threshold?: number);
+    enable(): void;
+    disable(): void;
+    attach(overlayRef: FuiOverlayRef): void;
+    detach(): void;
+    private _removeScrollListener;
+}
+/**
+ * # FuiRepositionScrollStrategy
+ *
+ * A scroll strategy that repositions the overlay when the user scrolls.
+ * This is useful for overlays that should follow their trigger element
+ * as it moves due to scrolling.
+ */
+declare class FuiRepositionScrollStrategy implements FuiScrollStrategy {
+    private _scrollThrottle;
+    private _autoClose;
+    private _overlayRef?;
+    private _scrollListener?;
+    private _isEnabled;
+    constructor(_scrollThrottle?: number, _autoClose?: boolean);
+    enable(): void;
+    disable(): void;
+    attach(overlayRef: FuiOverlayRef): void;
+    detach(): void;
+    private _removeScrollListener;
+    private _isScrolledOutOfView;
+}
+/**
+ * # FuiBlockScrollStrategy
+ *
+ * A scroll strategy that prevents scrolling while the overlay is open.
+ * This is useful for modal dialogs and other overlays that should
+ * prevent interaction with the underlying content.
+ */
+declare class FuiBlockScrollStrategy implements FuiScrollStrategy {
+    private _document?;
+    private _previousHTMLStyles;
+    private _previousBodyStyles;
+    private _isEnabled;
+    constructor(_document?: Document | undefined);
+    enable(): void;
+    disable(): void;
+    attach(_overlayRef: FuiOverlayRef): void;
+    detach(): void;
+    private _getScrollbarWidth;
+}
+/**
+ * Factory functions for creating scroll strategies
+ */
+declare const FUI_SCROLL_STRATEGIES: {
+    /**
+     * Creates a noop scroll strategy
+     */
+    noop: () => FuiNoopScrollStrategy;
+    /**
+     * Creates a close scroll strategy
+     */
+    close: (threshold?: number) => FuiCloseScrollStrategy;
+    /**
+     * Creates a reposition scroll strategy
+     */
+    reposition: (scrollThrottle?: number, autoClose?: boolean) => FuiRepositionScrollStrategy;
+    /**
+     * Creates a block scroll strategy
+     * @param doc Optional Document reference for SSR compatibility
+     */
+    block: (doc?: Document) => FuiBlockScrollStrategy;
+};
+
+declare class FuiOverlayService {
+    private readonly _document;
+    private readonly _rendererFactory;
+    private readonly _environmentInjector;
+    private readonly _renderer;
+    private _overlayContainer?;
+    private _nextUniqueId;
+    private _activeOverlays;
+    private _currentZIndex;
+    constructor();
+    /**
+     * Creates a new overlay with the given configuration
+     */
+    create(config?: FuiOverlayConfig): FuiOverlayRef;
+    /**
+     * Gets the next available z-index for a new overlay
+     */
+    private _getNextZIndex;
+    /**
+     * Recalculates the base z-index when overlays are disposed
+     * Resets to base if no overlays are active
+     */
+    private _recalculateBaseZIndex;
+    /**
+     * Gets the position builder for creating position strategies
+     */
+    position(): FuiOverlayPositionBuilder;
+    /**
+     * Gets the scroll strategies factory
+     */
+    get scrollStrategies(): typeof FUI_SCROLL_STRATEGIES;
+    /**
+     * Gets all currently active overlays
+     */
+    getActiveOverlays(): FuiOverlayRef[];
+    /**
+     * Disposes all active overlays
+     */
+    disposeAll(): void;
+    private _createOverlayElement;
+    private _attachToContainer;
+    private _getOverlayContainer;
+    private _applyConfigDefaults;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FuiOverlayService>;
+}
+/**
+ * # FuiOverlayPositionBuilder
+ *
+ * Builder class for creating position strategies. Provides a fluent API
+ * for configuring overlay positioning.
+ */
+declare class FuiOverlayPositionBuilder {
+    private _renderer;
+    constructor(_renderer: Renderer2);
+    /**
+     * Creates a global position strategy
+     */
+    global(options?: FuiGlobalPositionStrategyOptions): FuiGlobalPositionStrategy;
+    /**
+     * Creates a connected position strategy
+     */
+    connectedTo(origin: ElementRef<HTMLElement> | HTMLElement, positions?: FuiConnectedPosition[]): FuiConnectedPositionStrategy;
+    /**
+     * Creates a flexible connected position strategy with common tooltip positions
+     */
+    flexibleConnectedTo(origin: ElementRef<HTMLElement> | HTMLElement, preferredPosition?: 'top' | 'bottom' | 'left' | 'right'): FuiConnectedPositionStrategy;
+    private _getFlexiblePositions;
+}
+
+/**
+ * # FuiOverlayRefImpl
+ *
+ * Implementation of the FuiOverlayRef interface. This class manages the lifecycle
+ * of an individual overlay instance, including content attachment, positioning,
+ * and cleanup.
+ *
+ * ## Features
+ * - Content attachment and detachment
+ * - Event handling (backdrop clicks, keyboard events)
+ * - Position and size updates
+ * - CSS class management
+ * - Proper cleanup and disposal
+ */
+declare class FuiOverlayRefImpl implements FuiOverlayRef {
+    private readonly _id;
+    private readonly _overlayElement;
+    private readonly _renderer;
+    private readonly _zIndex;
+    private _backdropElement;
+    private _attachedContent;
+    private _config;
+    private _hasAttached;
+    private readonly _backdropClick;
+    private readonly _keydownEvents;
+    private readonly _attachments;
+    private readonly _detachments;
+    private _backdropClickListener?;
+    private _keydownListener?;
+    constructor(overlayElement: HTMLElement, config: FuiOverlayConfig, renderer: Renderer2, id?: string, zIndex?: number);
+    /** Unique identifier for this overlay */
+    get id(): string;
+    /** The overlay pane element */
+    get overlayElement(): HTMLElement;
+    /** The backdrop element (if any) */
+    get backdropElement(): HTMLElement | null;
+    /** Observable that emits when the backdrop is clicked */
+    get backdropClick(): Observable<MouseEvent>;
+    /** Observable that emits when a key is pressed while the overlay has focus */
+    get keydownEvents(): Observable<KeyboardEvent>;
+    /** Observable that emits when the overlay is attached to the DOM */
+    get attachments(): Observable<void>;
+    /** Observable that emits when the overlay is detached from the DOM */
+    get detachments(): Observable<void>;
+    /** Whether the overlay is currently attached */
+    get hasAttached(): boolean;
+    /**
+     * Attaches content to the overlay
+     */
+    attach<T = unknown>(content: ComponentRef<T> | TemplateRef<unknown> | HTMLElement, injector?: Injector): ComponentRef<T> | undefined;
+    /**
+     * Detaches the content from the overlay
+     */
+    detach(): void;
+    /**
+     * Disposes the overlay and cleans up resources
+     */
+    dispose(): void;
+    /**
+     * Updates the position of the overlay
+     */
+    updatePosition(): void;
+    /**
+     * Updates the size of the overlay
+     */
+    updateSize(config?: Pick<FuiOverlayConfig, 'width' | 'height' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight'>): void;
+    /**
+     * Adds CSS classes to the overlay pane
+     */
+    addPanelClass(classes: string | string[]): void;
+    /**
+     * Removes CSS classes from the overlay pane
+     */
+    removePanelClass(classes: string | string[]): void;
+    /**
+     * Gets the current configuration of the overlay
+     */
+    getConfig(): FuiOverlayConfig;
+    /**
+     * Updates the configuration of the overlay
+     */
+    updateConfig(config: Partial<FuiOverlayConfig>): void;
+    private _setupOverlayElement;
+    private _setupBackdrop;
+    private _createBackdrop;
+    private _removeBackdrop;
+    private _setupEventListeners;
+    private _removeEventListeners;
+    private _applySizeConfig;
+    private _coerceCssPixelValue;
+    private _generateId;
+}
+
+/**
+ * # FuiOverlayContainer Component
+ *
+ * Container component that holds all overlay content. This component is automatically
+ * created and attached to the document body when the overlay service is first used.
+ *
+ * ## Features
+ * - Provides a dedicated container for all overlay content
+ * - Manages z-index stacking for multiple overlays
+ * - Handles cleanup when destroyed
+ * - Applies proper CSS classes for styling
+ *
+ * ## Usage
+ *
+ * This component is used internally by the overlay service and should not be
+ * instantiated directly by application code.
+ */
+declare class FuiOverlayContainerComponent implements OnInit, OnDestroy {
+    private readonly _document;
+    private readonly _elementRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Gets the container element
+     */
+    getContainerElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiOverlayContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiOverlayContainerComponent, "fui-overlay-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Portal attachment result containing the attached element and cleanup function
+ */
+interface PortalAttachment {
+    /** The element that was attached to the portal outlet */
+    element: HTMLElement;
+    /** Function to detach the element and clean up */
+    detach: () => void;
+}
+/**
+ * # Portal Service
+ *
+ * A service for dynamically moving DOM elements to different locations in the DOM tree,
+ * particularly useful for moving elements to the document body to avoid clipping issues
+ * with parent containers that have overflow: hidden.
+ *
+ * ## Features
+ * - Move elements to document body or any other container
+ * - Maintain element references and event listeners
+ * - Proper cleanup when detaching
+ * - Support for multiple portal outlets
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * constructor(private portalService: PortalService) {}
+ *
+ * openMenu() {
+ *   const menuElement = this.menuElementRef.nativeElement;
+ *   this.portalAttachment = this.portalService.attachToBody(menuElement);
+ * }
+ *
+ * closeMenu() {
+ *   if (this.portalAttachment) {
+ *     this.portalAttachment.detach();
+ *     this.portalAttachment = null;
+ *   }
+ * }
+ * ```
+ */
+declare class PortalService {
+    private readonly _document;
+    private readonly _renderer;
+    private readonly _rendererFactory;
+    constructor();
+    /**
+     * Attaches an element to the document body
+     * @param element The element to attach
+     * @returns PortalAttachment with detach function
+     */
+    attachToBody(element: HTMLElement): PortalAttachment;
+    /**
+     * Attaches an element to a specific container
+     * @param element The element to attach
+     * @param container The container to attach to
+     * @returns PortalAttachment with detach function
+     */
+    attachToContainer(element: HTMLElement, container: HTMLElement): PortalAttachment;
+    /**
+     * Creates a portal outlet element and attaches it to the document body
+     * @param className Optional CSS class for the outlet
+     * @returns The created outlet element
+     */
+    createBodyOutlet(className?: string): HTMLElement;
+    /**
+     * Removes a portal outlet from the document
+     * @param outlet The outlet element to remove
+     */
+    removeOutlet(outlet: HTMLElement): void;
+    /**
+     * Checks if an element is currently attached to a portal
+     * @param element The element to check
+     * @returns True if the element is attached to the body or not in its original position
+     */
+    isAttachedToPortal(element: HTMLElement): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PortalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PortalService>;
+}
+
+export { FUI_OVERLAY_CONTAINER, FUI_OVERLAY_SCROLL_STRATEGY, FUI_SCROLL_STRATEGIES, FuiBlockScrollStrategy, FuiCloseScrollStrategy, FuiConnectedPositionStrategy, FuiGlobalPositionStrategy, FuiNoopScrollStrategy, FuiOverlayContainerComponent, FuiOverlayPositionBuilder, FuiOverlayRefImpl, FuiOverlayService, FuiRepositionScrollStrategy, PortalService };
+export type { FuiBackdropClickBehavior, FuiConnectedOverlayPositionChange, FuiConnectedPosition, FuiConnectedPositionStrategyOptions, FuiGlobalPosition, FuiGlobalPositionStrategyOptions, FuiOverlayConfig, FuiOverlayContent, FuiOverlayRef, FuiOverlaySizeConfig, FuiOverlayState, FuiPositionStrategy, FuiScrollStrategy, FuiScrollStrategyFactory, FuiScrollStrategyType, FuiScrollableViewProperties, PortalAttachment };
+//# sourceMappingURL=raintonic-formaui-cdk-overlay.d.ts.map