epic-modals 1.0.0 → 1.0.2

package/dist/core.d.ts

@@ -0,0 +1,1558 @@
+export declare function acquireModalZIndex(): number;
+
+export declare function animateModalsToPositions(moves: Map<string, Position>): void;
+
+export declare const ANIMATION_DURATIONS: {
+    readonly minimize: 500;
+    readonly restore: 400;
+    readonly open: 400;
+    readonly close: 250;
+    readonly overlay: 200;
+    readonly centerAfterResize: 200;
+    readonly glowStabilize: 1000;
+};
+
+export declare const ANIMATION_NAMES: {
+    readonly MINIMIZE: "modal-genie-minimize";
+    readonly RESTORE: "modal-genie-restore";
+    readonly OPEN: "modal-genie-restore";
+    readonly CLOSE: "modal-close";
+    readonly CLOSE_CENTERED: "modal-close-centered";
+    readonly CHILD_APPEAR: "modal-child-appear";
+    readonly CHILD_DISAPPEAR: "modal-child-disappear";
+};
+
+export declare interface AnimationController {
+    getState(): AnimationState;
+    isAnimating(): boolean;
+    getAnimationType(): AnimationType;
+    getTransform(): AnimationTransform | null;
+    getPendingOpenSource(): Position | null;
+    setPendingOpenSource(source: Position | null): void;
+    startMinimize(customTarget?: Position, onComplete?: () => void): boolean;
+    startRestore(storePosition: Position | undefined, modalSize: Dimensions | undefined): void;
+    startOpen(): boolean;
+    startClose(onComplete: () => void): boolean;
+    forceClearMinimize(): void;
+    destroy(): void;
+    subscribe(callback: (state: AnimationState) => void): () => void;
+}
+
+export declare interface AnimationControllerOptions {
+
+    getId: () => string;
+
+    getElement: () => HTMLElement | null;
+
+    getPosition: () => Position;
+
+    setPosition: (pos: Position) => void;
+
+    getHasBeenDragged: () => boolean;
+
+    setHasBeenDragged: (value: boolean) => void;
+
+    getHasBeenResized: () => boolean;
+
+    getSize: () => Dimensions;
+
+    areAnimationsEnabled?: () => boolean;
+
+    onMinimizeComplete?: (position: Position, hasBeenDragged: boolean, size: Dimensions) => void;
+
+    onOpenStart?: () => void;
+}
+
+export declare interface AnimationDurations {
+
+    open: number;
+
+    close: number;
+
+    minimize: number;
+
+    restore: number;
+
+    easing: string;
+}
+
+export declare interface AnimationEvents {
+    change: AnimationState;
+    animationStart: {
+        type: AnimationType;
+    };
+    animationEnd: {
+        type: AnimationType;
+    };
+}
+
+export declare interface AnimationOverride {
+    open?: number;
+    close?: number;
+    minimize?: number;
+    restore?: number;
+    easing?: string;
+}
+
+export declare type AnimationPhase = 'idle' | 'prepare' | 'animate' | 'complete';
+
+export declare interface AnimationState {
+    type: AnimationType;
+    isAnimating: boolean;
+    transform: AnimationTransform | null;
+}
+
+export declare interface AnimationTransform {
+    x: number;
+    y: number;
+    originX: number;
+    originY: number;
+}
+
+export declare type AnimationType = 'open' | 'close' | 'minimize' | 'restore' | 'attention' | 'none';
+
+export declare interface AppearanceConfig {
+    headerLayout: HeaderLayout;
+    defaultWidth: string;
+    defaultHeight: string;
+    minWidth: number;
+    minHeight: number;
+}
+
+export declare interface AppearanceOverride {
+    headerLayout?: HeaderLayout;
+    defaultWidth?: string;
+    defaultHeight?: string;
+    minWidth?: number;
+    minHeight?: number;
+}
+
+export declare function applyLayoutPositions(positions: Map<string, Position>): void;
+
+declare interface AvailableArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare interface BackdropConfig {
+
+    visible: boolean;
+
+    blockClicks: boolean;
+}
+
+export declare interface BaseModalProps {
+
+    id: ModalId;
+
+    title: string;
+
+    icon?: string;
+
+    description?: string;
+
+    maxWidth?: string;
+
+    preferredHeight?: string;
+
+    autoOpen?: boolean;
+
+    openSourcePosition?: Position | null;
+
+    glow?: ModalGlow;
+
+    config?: ModalConfigOverrides;
+
+    closeOnEscape?: boolean;
+
+    onClose?: () => void;
+}
+
+export declare function batchUpdates(callback: () => void): void;
+
+export declare interface Bounds extends Position, Dimensions {
+}
+
+export declare function bringToFront(id: ModalId): void;
+
+export declare function calculateCenteredChildPosition(parentPosition: Position, parentSize: Dimensions, childSize: Dimensions): Position;
+
+export declare function calculateChildCenterPosition(parentId: ModalId, childWidth: number, childHeight: number): Position | null;
+
+export declare function calculateChildPosition(parentPosition: Position, offset: Position): Position;
+
+export declare function calculateDockDragPosition(clientX: number, clientY: number, dragOffset: Position, dockWidth: number, dockHeight: number, padding?: number): Position;
+
+declare function calculateEqualSpaceLayout(existingModals: ModalLayoutInfo[], newModal: {
+    id: string;
+    width: number;
+    height: number;
+} | null, options?: SmartLayoutOptions): SmartLayoutResult;
+export { calculateEqualSpaceLayout }
+export { calculateEqualSpaceLayout as calculateSmartLayout }
+
+export declare function calculateMinDistance(a: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, b: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): number;
+
+export declare function calculateMinimizeTransform(modalPosition: Position, modalSize: Dimensions, targetPosition: Position): AnimationTransform;
+
+export declare function calculateOffsetFromParent(childPosition: Position, parentPosition: Position): Position;
+
+export declare function calculateOpenTransform(modalPosition: Position, modalSize: Dimensions, sourcePosition: Position): AnimationTransform;
+
+export declare function calculateOverlap(a: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, b: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): number;
+
+export declare function calculateParentPosition(childPosition: Position, offset: Position): Position;
+
+export declare function calculateRestoreTransform(modalPosition: Position, modalSize: Dimensions, sourcePosition: Position): AnimationTransform;
+
+export declare function calculateTotalOverlap(x: number, y: number, width: number, height: number, existingModals: ModalBounds[], gap: number): number;
+
+export declare function cleanupResizeListener(): void;
+
+export declare function clearActiveAttention(id: ModalId): void;
+
+export declare function clearPendingParentAnimation(parentId: ModalId): void;
+
+export declare function clearPositionAnimation(id: ModalId): void;
+
+export declare function closeAllModals(exclude?: ModalId[]): void;
+
+export declare function closeModal(id: ModalId, force?: boolean): void;
+
+export declare function computeAvailableArea(vw: number, vh: number, margin: number, avoidBounds: ModalBounds[], avoidMargin: number): AvailableArea;
+
+export declare function computeCssClasses(input: ComputeCssClassesInput): string[];
+
+export declare interface ComputeCssClassesInput {
+    isDragging: boolean;
+    isResizing: boolean;
+    hasBeenDragged: boolean;
+    isMinimizing: boolean;
+    isRestoring: boolean;
+    isOpening: boolean;
+    isClosing: boolean;
+    showCentered: boolean;
+    isTransparent: boolean;
+    glowEnabled: boolean;
+    hasChild: boolean;
+    isChildModal: boolean;
+    wasRestored: boolean;
+    isVisibleByAnimation: boolean;
+    isAwaitingRestore: boolean;
+    isAwaitingChildOpen: boolean;
+    isAnimatingToCenter: boolean;
+    isAnimatingPosition: boolean;
+    isAttentionAnimating: boolean;
+    glowStabilizing: boolean;
+}
+
+export declare interface ComputedModalState {
+    position: Position;
+    size: Dimensions;
+    zIndex: number;
+    isDragging: boolean;
+    isResizing: boolean;
+    hasBeenDragged: boolean;
+    hasBeenResized: boolean;
+    isMinimizing: boolean;
+    isRestoring: boolean;
+    isOpening: boolean;
+    isClosing: boolean;
+    isAnyAnimating: boolean;
+    animationTransform: AnimationTransform | null;
+    isVisible: boolean;
+    showCentered: boolean;
+    isAwaitingRestore: boolean;
+    isAwaitingChildOpen: boolean;
+    isVisibleByAnimation: boolean;
+    hasChild: boolean;
+    isChildModal: boolean;
+    showOverlay: boolean;
+    isTransparent: boolean;
+    isAttentionAnimating: boolean;
+    glowStabilizing: boolean;
+    isAnimatingPosition: boolean;
+    isAnimatingToCenter: boolean;
+    wasRestored: boolean;
+    overlayClosing: boolean;
+    glowEnabled: boolean;
+    draggable: boolean;
+    resizable: boolean;
+    minimizable: boolean;
+    dataState: string;
+    dataAnimationPhase: string;
+    style: Record<string, string | number>;
+    cssClasses: string[];
+}
+
+export declare function computeStyle(input: ComputeStyleInput): Record<string, string | number>;
+
+export declare interface ComputeStyleInput {
+    position: Position;
+    hasBeenDragged: boolean;
+    hasBeenResized: boolean;
+    size: Dimensions;
+    animationTransform: AnimationTransform | null;
+    zIndex: number;
+    glowEnabled: boolean;
+    glow: ModalGlow | null;
+    maxWidth: string | undefined;
+    preferredHeight: string | undefined;
+
+    isAnimatingPosition?: boolean;
+}
+
+export declare interface ConfigResolver {
+
+    getEffectiveConfig: () => ModalLibraryConfig;
+
+    isFeatureEnabled: (feature: keyof ModalFeatures) => boolean;
+
+    getAppearance: <K extends keyof AppearanceConfig>(key: K) => AppearanceConfig[K];
+
+    getAnimation: <K extends keyof AnimationDurations>(key: K) => AnimationDurations[K];
+
+    getPositioning: <K extends keyof PositioningConfig>(key: K) => PositioningConfig[K];
+
+    getParentChild: <K extends keyof ParentChildConfig>(key: K) => ParentChildConfig[K];
+}
+
+export declare interface ConfigResolverOptions {
+
+    getModalConfig: () => ModalConfigOverrides | undefined;
+
+    getProviderConfig: () => PartialModalLibraryConfig | undefined;
+}
+
+export declare function constrainDockPosition(position: Position, dockWidth: number, dockHeight: number): Position;
+
+export declare function constrainSizeToViewport(x: number, y: number, width: number, height: number, options?: ViewportConstraintOptions): Bounds;
+
+export declare function constrainToViewport(x: number, y: number, width: number, height: number, options?: ViewportConstraintOptions): Position;
+
+export declare function consumeOpenSourcePosition(id: ModalId): Position | null;
+
+export declare function consumePendingAttention(id: ModalId): void;
+
+export declare function consumePendingChildRestore(id: ModalId): void;
+
+export declare function consumePendingClose(id: ModalId): void;
+
+export declare function consumePendingForceClose(id: ModalId): void;
+
+export declare function consumePendingMinimize(id: ModalId): AnimationTransform | null;
+
+export declare function consumePendingMinimizeTarget(): AnimationTransform | null;
+
+export declare function consumePendingMinimizeWithParent(id: ModalId): void;
+
+export declare function consumePendingOpen(id: ModalId): void;
+
+export declare function consumePendingParentAnimation(id: ModalId): Position | null;
+
+export declare function consumePendingParentLink(modalId?: ModalId): {
+    parentId: ModalId;
+    childId: ModalId;
+} | null;
+
+export declare function consumePendingRestore(id: ModalId): void;
+
+export declare function containsFocus(container: HTMLElement): boolean;
+
+export declare function createAnimationController(options: AnimationControllerOptions): AnimationController;
+
+export declare function createConfigHelper(modalConfig?: DeepPartial<{
+    features?: Partial<ModalFeatures>;
+    appearance?: Partial<AppearanceConfig>;
+    positioning?: Partial<PositioningConfig>;
+}>, providerConfig?: PartialModalLibraryConfig): ModalConfigHelper;
+
+export declare function createConfigResolver(options: ConfigResolverOptions): ConfigResolver;
+
+export declare function createDragBehavior(options?: DragBehaviorOptions): DragBehavior;
+
+export declare function createEventEmitter<T>(): {
+
+    on<K extends keyof T>(event: K, callback: EventCallback<T[K]>): () => void;
+
+    emit<K extends keyof T>(event: K, data: T[K]): void;
+
+    off<K extends keyof T>(event?: K): void;
+
+    listenerCount<K extends keyof T>(event: K): number;
+};
+
+export declare function createFocusTrap(container: HTMLElement): {
+
+    activate(): void;
+
+    deactivate(): void;
+
+    handleKeyDown(event: KeyboardEvent): void;
+
+    containsFocus(): boolean;
+};
+
+export declare function createModal(modal: Omit<ModalState, 'zIndex' | 'isAnimating'>): void;
+
+export declare function createModalController(options: ModalControllerOptions): ModalController;
+
+export declare function createModalRegistration(props: CreateModalRegistrationProps): Omit<ModalState, 'zIndex' | 'isAnimating'>;
+
+export declare interface CreateModalRegistrationProps {
+    id: ModalId;
+    title: string;
+    icon?: string;
+    autoOpen?: boolean;
+    glow?: ModalGlow | null;
+}
+
+export declare function createResizeBehavior(options: ResizeBehaviorOptions): ResizeBehavior;
+
+declare const CSS_2: {
+    readonly modal: "modal-dialog";
+    readonly modalDragging: "modal-dragging";
+    readonly modalResizing: "modal-resizing";
+    readonly modalPositioned: "modal-positioned";
+    readonly modalMinimizing: "modal-minimizing";
+    readonly modalRestoring: "modal-restoring";
+    readonly modalOpening: "modal-opening";
+    readonly modalClosing: "modal-closing";
+    readonly modalCentered: "modal-centered";
+    readonly modalSolid: "modal-solid";
+    readonly modalTransparent: "modal-transparent";
+    readonly modalGlow: "modal-glow";
+    readonly modalHasGlow: "modal-has-glow";
+    readonly modalHasChild: "modal-has-child";
+    readonly modalIsChild: "modal-is-child";
+    readonly modalWasRestored: "modal-was-restored";
+    readonly modalVisibleByAnimation: "modal-visible-by-animation";
+    readonly modalAwaitingRestore: "modal-awaiting-restore";
+    readonly modalAwaitingChildOpen: "modal-awaiting-child-open";
+    readonly modalAnimatingToCenter: "modal-animating-to-center";
+    readonly modalAnimatingPosition: "modal-animating-position";
+    readonly modalAttention: "modal-attention";
+    readonly modalGlowStabilizing: "modal-glow-stabilizing";
+    readonly header: "modal-header";
+    readonly headerDraggable: "modal-header-draggable";
+    readonly body: "modal-body";
+    readonly footer: "modal-footer";
+    readonly childOverlay: "modal-child-overlay";
+    readonly overlayClosing: "modal-overlay-closing";
+    readonly headerTitle: "modal-header-title";
+    readonly headerIcon: "modal-header-icon";
+    readonly headerTitleGroup: "modal-header-title-group";
+    readonly headerActions: "modal-header-actions";
+    readonly headerTrafficLights: "modal-header-traffic-lights";
+    readonly headerLight: "modal-header-light";
+    readonly headerLightClose: "modal-header-light-close";
+    readonly headerLightMinimize: "modal-header-light-minimize";
+    readonly headerLightStyle: "modal-header-light-style";
+    readonly headerLightDisabled: "modal-header-light-disabled";
+    readonly headerMacCenter: "modal-header-mac-center";
+    readonly headerMacSpacer: "modal-header-mac-spacer";
+    readonly headerBtnWindows: "modal-header-btn-windows";
+    readonly headerBtnWindowsClose: "modal-header-btn-windows-close";
+    readonly headerBtnWindowsStyle: "modal-header-btn-windows-style";
+    readonly headerBtnWindowsDisabled: "modal-header-btn-windows-disabled";
+    readonly resizeHandles: "modal-resize-handles";
+    readonly resizeHandle: "modal-resize-handle";
+    readonly resizeN: "modal-resize-n";
+    readonly resizeS: "modal-resize-s";
+    readonly resizeE: "modal-resize-e";
+    readonly resizeW: "modal-resize-w";
+    readonly resizeNE: "modal-resize-ne";
+    readonly resizeNW: "modal-resize-nw";
+    readonly resizeSE: "modal-resize-se";
+    readonly resizeSW: "modal-resize-sw";
+    readonly resizePrefix: "modal-resize-";
+    readonly dock: "modal-dock";
+    readonly dockContainer: "modal-dock-container";
+    readonly dockItem: "modal-dock-item";
+    readonly dockItemActive: "modal-dock-item-active";
+    readonly dockItemHasGlow: "modal-dock-item-has-glow";
+    readonly dockItemHasChild: "modal-dock-item-has-child";
+    readonly dockItemLabelBeside: "modal-dock-item-label-beside";
+    readonly dockItemLabelBelow: "modal-dock-item-label-below";
+    readonly dockItemIcon: "modal-dock-item-icon";
+    readonly dockItemIconPlaceholder: "modal-dock-item-icon-placeholder";
+    readonly dockItemLabel: "modal-dock-item-label";
+    readonly dockItemGlow: "modal-dock-item-glow";
+    readonly dockChildIndicator: "modal-dock-child-indicator";
+    readonly dockHandle: "modal-dock-handle";
+    readonly dockHandleDragging: "modal-dock-handle-dragging";
+    readonly dockLeft: "modal-dock-left";
+    readonly dockRight: "modal-dock-right";
+    readonly dockBottom: "modal-dock-bottom";
+    readonly dockFree: "modal-dock-free";
+    readonly dockEmpty: "modal-dock-empty";
+    readonly dockFreeHorizontal: "modal-dock-free-horizontal";
+    readonly dockFreeVertical: "modal-dock-free-vertical";
+    readonly backdrop: "modal-backdrop";
+    readonly backdropVisible: "modal-backdrop-visible";
+    readonly srOnly: "sr-only";
+    readonly reactBodyContent: "react-modal-body-content";
+    readonly reactFooterContent: "react-modal-footer-content";
+};
+export { CSS_2 as CSS }
+
+export declare const CSS_CLASSES: {
+    readonly dialog: "modal-dialog";
+    readonly dialogCentered: "modal-centered";
+    readonly dialogDragging: "modal-dragging";
+    readonly dialogResizing: "modal-resizing";
+    readonly dialogMinimizing: "modal-minimizing";
+    readonly dialogRestoring: "modal-restoring";
+    readonly dialogOpening: "modal-opening";
+    readonly dialogClosing: "modal-closing";
+    readonly dialogSolid: "modal-solid";
+    readonly dialogTransparent: "modal-transparent";
+    readonly dialogHasGlow: "modal-has-glow";
+    readonly dialogHasChild: "modal-has-child";
+    readonly dialogIsChild: "modal-is-child";
+    readonly dialogAnimatingPosition: "modal-animating-position";
+    readonly dialogAttention: "modal-attention";
+    readonly header: "modal-header";
+    readonly headerDraggable: "modal-header-draggable";
+    readonly headerLayout: (layout: string) => string;
+    readonly body: "modal-body";
+    readonly footer: "modal-footer";
+    readonly childOverlay: "modal-child-overlay";
+    readonly overlayClosing: "modal-overlay-closing";
+    readonly headerTitle: "modal-header-title";
+    readonly headerIcon: "modal-header-icon";
+    readonly headerTitleGroup: "modal-header-title-group";
+    readonly headerActions: "modal-header-actions";
+    readonly headerTrafficLights: "modal-header-traffic-lights";
+    readonly headerLight: "modal-header-light";
+    readonly headerLightClose: "modal-header-light-close";
+    readonly headerLightMinimize: "modal-header-light-minimize";
+    readonly headerLightStyle: "modal-header-light-style";
+    readonly headerLightDisabled: "modal-header-light-disabled";
+    readonly headerMacCenter: "modal-header-mac-center";
+    readonly headerMacSpacer: "modal-header-mac-spacer";
+    readonly headerBtnWindows: "modal-header-btn-windows";
+    readonly headerBtnWindowsClose: "modal-header-btn-windows-close";
+    readonly headerBtnWindowsStyle: "modal-header-btn-windows-style";
+    readonly headerBtnWindowsDisabled: "modal-header-btn-windows-disabled";
+    readonly resizeHandles: "modal-resize-handles";
+    readonly resizeHandle: "modal-resize-handle";
+    readonly resizePrefix: "modal-resize-";
+    readonly dock: "modal-dock";
+    readonly dockContainer: "modal-dock-container";
+    readonly dockItem: "modal-dock-item";
+    readonly dockItemActive: "modal-dock-item-active";
+    readonly dockItemHasGlow: "modal-dock-item-has-glow";
+    readonly dockItemHasChild: "modal-dock-item-has-child";
+    readonly dockItemLabelBeside: "modal-dock-item-label-beside";
+    readonly dockItemLabelBelow: "modal-dock-item-label-below";
+    readonly dockItemIcon: "modal-dock-item-icon";
+    readonly dockItemIconPlaceholder: "modal-dock-item-icon-placeholder";
+    readonly dockItemLabel: "modal-dock-item-label";
+    readonly dockItemGlow: "modal-dock-item-glow";
+    readonly dockChildIndicator: "modal-dock-child-indicator";
+    readonly dockHandle: "modal-dock-handle";
+    readonly dockHandleDragging: "modal-dock-handle-dragging";
+    readonly dockLeft: "modal-dock-left";
+    readonly dockRight: "modal-dock-right";
+    readonly dockBottom: "modal-dock-bottom";
+    readonly dockFree: "modal-dock-free";
+    readonly dockEmpty: "modal-dock-empty";
+    readonly dockFreeHorizontal: "modal-dock-free-horizontal";
+    readonly dockFreeVertical: "modal-dock-free-vertical";
+    readonly backdrop: "modal-backdrop";
+    readonly backdropVisible: "modal-backdrop-visible";
+};
+
+export declare const DATA_ATTRIBUTES: {
+    readonly modalId: "data-modal-id";
+    readonly resizeDirection: "data-direction";
+    readonly dockItemId: "data-dock-item-id";
+};
+
+export declare const DATA_ATTRS: {
+    readonly modalId: "data-modal-id";
+    readonly dockContainer: "data-dock-container";
+    readonly resizeDir: "data-resize-dir";
+    readonly modalBridge: "data-modal-bridge";
+};
+
+export declare type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+export declare const defaultConfig: ModalLibraryConfig;
+
+export declare const DEFAULTS: {
+    readonly minWidth: 280;
+    readonly minHeight: 200;
+    readonly maxWidth: "600px";
+    readonly zIndexBase: 1000;
+};
+
+export declare interface Dimensions {
+
+    width: number;
+
+    height: number;
+}
+
+export declare interface DockConfig {
+
+    position: DockPosition;
+
+    labelMode: DockLabelMode;
+
+    enableReorder: boolean;
+
+    enableFreeDrag: boolean;
+}
+
+export declare type DockLabelMode = 'hidden' | 'beside' | 'below';
+
+export declare type DockOrientation = 'horizontal' | 'vertical';
+
+export declare type DockPosition = 'left' | 'right' | 'bottom' | 'free';
+
+export declare type DockPositionGetter = () => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+export declare interface DragBehavior {
+    getState(): DragState;
+    getPosition(): Position;
+    isDragging(): boolean;
+    hasBeenDragged(): boolean;
+    setPosition(position: Position): void;
+    setHasBeenDragged(value: boolean): void;
+    reset(): void;
+    constrainToViewport(modalSize: Dimensions): void;
+    onPointerDown(e: PointerEvent, element: HTMLElement): void;
+    onPointerMove(e: PointerEvent, modalSize: Dimensions): void;
+    onPointerUp(e: PointerEvent, element: HTMLElement): void;
+    subscribe(callback: (state: DragState) => void): () => void;
+    destroy(): void;
+}
+
+export declare interface DragBehaviorOptions {
+    initialPosition?: Position;
+    constrain?: boolean;
+}
+
+export declare interface DragEvents {
+    change: DragState;
+    dragStart: Position;
+    dragMove: Position;
+    dragEnd: Position;
+}
+
+export declare interface DragState {
+    isDragging: boolean;
+    position: Position;
+    hasBeenDragged: boolean;
+}
+
+export declare const DURATIONS: {
+    readonly minimize: 500;
+    readonly restore: 400;
+    readonly open: 400;
+    readonly close: 250;
+    readonly attention: 300;
+    readonly parentMove: 300;
+
+    readonly parentRetargetInterval: 100;
+    readonly centerAfterResize: 200;
+    readonly glowStabilize: 1000;
+    readonly overlayFade: 200;
+};
+
+export declare const EASINGS: {
+
+    readonly easeOut: "ease-out";
+
+    readonly easeOutCubic: "cubic-bezier(0.25, 0.1, 0.25, 1)";
+
+    readonly linear: "linear";
+
+    readonly easeInOut: "ease-in-out";
+};
+
+export declare function endAttentionAnimation(_id: ModalId): void;
+
+export declare type EventCallback<T = void> = (data: T) => void;
+
+export declare type EventEmitter<T> = ReturnType<typeof createEventEmitter<T>>;
+
+export declare interface ExternalElementProps {
+
+    bodyElement?: HTMLElement | null;
+
+    footerElement?: HTMLElement | null;
+
+    iconElement?: HTMLElement | null;
+}
+
+export declare function finalizeChildMinimize(id: ModalId): void;
+
+export declare function finalizeModalClose(id: ModalId): void;
+
+export declare function findChildModalElement(childId: string): HTMLElement | null;
+
+export declare function findParentModalElement(parentId: string): HTMLElement | null;
+
+export declare function findRootAncestor(modalId: string, getParentId: (id: string) => string | undefined): string;
+
+export declare function flipAnimate(element: HTMLElement, oldPosition: Position, newPosition: Position, options?: {
+    duration?: number;
+    easing?: string;
+    onComplete?: () => void;
+}): () => void;
+
+export declare const FOCUSABLE_SELECTORS: string;
+
+export declare function focusFirstElement(container: HTMLElement): boolean;
+
+export declare function focusLastElement(container: HTMLElement): boolean;
+
+export declare function getAncestorIds(modalId: string, getParentId: (id: string) => string | undefined): string[];
+
+export declare function getBackdropConfig(): BackdropConfig;
+
+export declare function getConfig(): ModalLibraryConfig;
+
+export declare function getConfigVersion(): number;
+
+export declare function getDefaultDockTarget(): Position;
+
+export declare function getDescendantIds(modalId: string, getChildId: (id: string) => string | undefined): string[];
+
+export declare function getDockClasses(dockPosition: 'left' | 'right' | 'bottom' | 'free', orientation: 'horizontal' | 'vertical'): string;
+
+export declare function getDockContainerClasses(dockPosition: 'left' | 'right' | 'bottom' | 'free', isEmpty: boolean): string;
+
+export declare function getDockItemElement(id: ModalId): HTMLElement | null;
+
+export declare function getDockItemPosition(modalId: string, fallback?: Position): Position;
+
+export declare function getDockOrder(): ModalId[];
+
+export declare function getDuration(type: AnimationType): number;
+
+export declare function getEasing(type: AnimationType): string;
+
+export declare function getElementBounds(selectors: string[]): ModalBounds[];
+
+export declare function getFocusableElements(container: HTMLElement): HTMLElement[];
+
+export declare function _getInternalState(): {
+    modals: Map<string, ModalState>;
+    pendingMinimize: string[];
+    pendingOpen: string[];
+    pendingClose: string[];
+    pendingRestore: string[];
+    dockOrder: string[];
+    animatingModals: Set<string>;
+    transparentModals: Set<string>;
+};
+
+export declare function getLayerZIndex(layer: StackingLayerName): number;
+
+export declare function getMinimizedModals(): ModalState[];
+
+export declare function getModalBounds(element: HTMLElement): {
+    position: Position;
+    size: Dimensions;
+};
+
+export declare function getModalLayoutInfos(): ModalLayoutInfo[];
+
+export declare function getModalsStore(): Map<ModalId, ModalState>;
+
+export declare function getModalState(id: ModalId): ModalState | undefined;
+
+export declare function getModalsToClose(fromIdOrExclude: ModalId | ModalId[]): ModalId[];
+
+export declare function getOpenModalBounds(excludeId?: ModalId): ModalBounds[];
+
+export declare function getOpenModalBoundsWithIds(excludeId?: ModalId): Array<{
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+
+export declare function getOpenSourcePosition(id: ModalId): Position | null;
+
+export declare function getPendingParentAnimation(id: ModalId): Position | null;
+
+export declare function getPendingParentLink(): {
+    parentId: ModalId;
+    childId: ModalId;
+} | null;
+
+export declare function getStateVersion(): number;
+
+export declare function handleWindowResize(): void;
+
+export declare function hasOpenModals(): boolean;
+
+export declare function hasPendingAttention(id: ModalId): boolean;
+
+export declare function hasPendingChildRestore(id: ModalId): boolean;
+
+export declare function hasPendingClose(id: ModalId): boolean;
+
+export declare function hasPendingForceClose(id: ModalId): boolean;
+
+export declare function hasPendingMinimize(id: ModalId): boolean;
+
+export declare function hasPendingMinimizeWithParent(id: ModalId): boolean;
+
+export declare function hasPendingOpen(id: ModalId): boolean;
+
+export declare function hasPendingParentAnimation(id: ModalId): boolean;
+
+export declare function hasPendingParentLinkFor(id: ModalId): boolean;
+
+export declare function hasPendingRestore(id: ModalId): boolean;
+
+export declare type HeaderLayout = 'macos' | 'windows' | 'none';
+
+export declare function hideChildWithParent(parentId: ModalId): void;
+
+export declare function initializeResizeListener(): void;
+
+export declare function initializeStacking(): void;
+
+export declare interface InteractionConfigHelper {
+    isFeatureEnabled: (feature: keyof ModalFeatures) => boolean;
+}
+
+export declare interface InteractionDragBehavior {
+    onPointerDown: (e: PointerEvent, element: HTMLElement) => void;
+    onPointerMove: (e: PointerEvent, modalSize: {
+        width: number;
+        height: number;
+    }) => void;
+    onPointerUp: (e: PointerEvent, element: HTMLElement) => void;
+    isDragging: () => boolean;
+    getPosition: () => {
+        x: number;
+        y: number;
+    };
+    hasBeenDragged: () => boolean;
+}
+
+export declare interface InteractionResizeBehavior {
+    startResize: (e: PointerEvent, direction: ResizeDirection) => void;
+    hasBeenResized: () => boolean;
+    getSize: () => {
+        width: number;
+        height: number;
+    };
+    justFinishedResizing: () => boolean;
+}
+
+export declare interface InteractionState {
+    hasChild: boolean;
+}
+
+export declare function isBackdropEnabled(): boolean;
+
+export declare function isFeatureEnabled(feature: keyof ModalFeatures): boolean;
+
+export declare function isModalAnimating(id: ModalId): boolean;
+
+export declare function isModalOpen(id: ModalId): boolean;
+
+export declare function isModalRegistered(id: ModalId): boolean;
+
+export declare function isTopModal(id: ModalId): boolean;
+
+export declare function linkModals(parentId: ModalId, childId: ModalId, offset: Position): void;
+
+export declare function mergeConfig(base: ModalLibraryConfig, override: PartialModalLibraryConfig): ModalLibraryConfig;
+
+export declare function minimizeModal(id: ModalId): void;
+
+export declare type ModalAnimationState = 'closed' | 'opening' | 'open' | 'closing' | 'minimizing' | 'minimized' | 'restoring';
+
+export declare interface ModalBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare interface ModalBoundsWithId extends ModalBounds {
+    id: string;
+}
+
+export declare interface ModalConfigHelper {
+    isFeatureEnabled: (feature: keyof ModalFeatures) => boolean;
+    getAppearance: <K extends keyof AppearanceConfig>(key: K) => AppearanceConfig[K];
+    getPositioning: <K extends keyof PositioningConfig>(key: K) => PositioningConfig[K];
+    getEffectiveConfig: () => ModalLibraryConfig;
+}
+
+export declare interface ModalConfigOverrides {
+    features?: ModalFeaturesOverride;
+    appearance?: AppearanceOverride;
+    animations?: AnimationOverride;
+    positioning?: PositioningOverride;
+    parentChild?: ParentChildOverride;
+}
+
+export declare class ModalController {
+    private id;
+    private dataId;
+    private options;
+    private drag;
+    private resize;
+    private animation;
+    private positioning;
+    private lifecycle;
+    private interactions;
+    private stateManager;
+    private overlayClosing;
+    private emitter;
+    private unsubscribeState;
+    private cachedState;
+    constructor(options: ModalControllerOptions);
+
+    mount(element: HTMLElement): void;
+
+    destroy(): void;
+
+    private get element();
+
+    private handleWindowResize;
+
+    private register;
+
+    getState(): ComputedModalState;
+
+    subscribe(callback: (state: ComputedModalState) => void): () => void;
+    private notifyStateChange;
+
+    startDrag(e: PointerEvent): void;
+
+    startResize(e: PointerEvent, direction: ResizeDirection): void;
+
+    handlePointerMove(e: PointerEvent): void;
+
+    handlePointerUp(e: PointerEvent): void;
+
+    handleKeyDown(e: KeyboardEvent): void;
+
+    handleTabKey(e: KeyboardEvent): void;
+
+    minimize(): void;
+
+    close(): void;
+
+    toggleTransparency(): void;
+
+    bringToFront(): void;
+
+    setOpenSourcePosition(position: Position | null): void;
+
+    updateGlow(glow: ModalControllerOptions['glow']): void;
+
+    focusFirst(): void;
+    private handleResizeEnd;
+    private handleStateChange;
+    private handlePendingStates;
+    getId(): ModalId;
+    getDataId(): string;
+    getElement(): HTMLElement | null;
+}
+
+export declare interface ModalControllerEvents {
+    stateChange: ComputedModalState;
+    close: void;
+}
+
+export declare interface ModalControllerOptions {
+
+    id: ModalId;
+
+    title: string;
+
+    icon?: string;
+
+    config?: ModalConfigOverrides;
+
+    providerConfig?: Partial<ModalLibraryConfig>;
+
+    maxWidth?: string;
+
+    preferredHeight?: string;
+
+    glow?: ModalGlow;
+
+    closeOnEscape?: boolean;
+
+    autoOpen?: boolean;
+
+    openSourcePosition?: Position | null;
+
+    onClose?: () => void;
+
+    skipRegistration?: boolean;
+
+    configHelper: ModalConfigHelper;
+}
+
+export declare interface ModalFeatures {
+    dock: boolean;
+    minimize: boolean;
+    transparency: boolean;
+    resize: boolean;
+    drag: boolean;
+    focusTrap: boolean;
+    animations: boolean;
+
+    backdrop: boolean | BackdropConfig;
+    parentChild: boolean;
+}
+
+export declare interface ModalFeaturesOverride {
+    dock?: boolean;
+    minimize?: boolean;
+    transparency?: boolean;
+    resize?: boolean;
+    drag?: boolean;
+    focusTrap?: boolean;
+    animations?: boolean;
+    backdrop?: boolean | BackdropConfig;
+    parentChild?: boolean;
+}
+
+export declare interface ModalGlow {
+    color: string;
+    intensity: 'minimum' | 'low' | 'medium' | 'high';
+}
+
+export declare interface ModalHeaderBaseProps {
+    title: string;
+
+    icon?: string;
+    isTransparent?: boolean;
+    titleId?: string;
+    headerLayout?: HeaderLayout;
+    minimizable?: boolean;
+    minimizeDisabled?: boolean;
+    transparencyEnabled?: boolean;
+}
+
+export declare type ModalId = string;
+
+export declare class ModalInteractions {
+    private options;
+    constructor(options: ModalInteractionsOptions);
+
+    startDrag(e: PointerEvent): void;
+
+    startResize(e: PointerEvent, direction: ResizeDirection): void;
+
+    handlePointerMove(e: PointerEvent): void;
+
+    handlePointerUp(e: PointerEvent): void;
+
+    handleKeyDown(e: KeyboardEvent): void;
+
+    handleTabKey(e: KeyboardEvent): void;
+
+    focusFirst(): void;
+}
+
+export declare interface ModalInteractionsOptions {
+    id: string;
+    configHelper: InteractionConfigHelper;
+    getDragBehavior: () => InteractionDragBehavior;
+    getResizeBehavior: () => InteractionResizeBehavior;
+    getElement: () => HTMLElement | null;
+    getState: () => InteractionState;
+    onDragMove: () => void;
+    onDragEnd: () => void;
+    onClose?: () => void;
+    closeOnEscape?: boolean;
+    isTopModal: () => boolean;
+}
+
+export declare interface ModalLayoutInfo {
+    id: string;
+    width: number;
+    height: number;
+    currentPosition: Position;
+
+    parentId?: string;
+}
+
+export declare interface ModalLibraryConfig {
+    features: ModalFeatures;
+    dock: DockConfig;
+    animations: AnimationDurations;
+    appearance: AppearanceConfig;
+    zIndex: ZIndexConfig;
+    parentChild: ParentChildConfig;
+    positioning: PositioningConfig;
+
+    portalTarget: string | HTMLElement;
+}
+
+export declare class ModalLifecycle {
+    private element;
+    private resizeHandler;
+    private options;
+    constructor(options?: ModalLifecycleOptions);
+
+    mount(element: HTMLElement): void;
+
+    destroy(): void;
+
+    getElement(): HTMLElement | null;
+
+    isMounted(): boolean;
+}
+
+export declare interface ModalLifecycleOptions {
+    onMount?: () => void;
+    onDestroy?: () => void;
+    onWindowResize?: () => void;
+}
+
+export declare class ModalPositioning {
+    private id;
+    private dataId;
+    private configHelper;
+    private getDragBehavior;
+    private getElement;
+    constructor(options: ModalPositioningOptions);
+
+    constrainToViewport(size: Dimensions): void;
+
+    shouldApplySmartPositioning(): boolean;
+
+    applySmartPositioning(): boolean;
+
+    scheduleSmartPositioning(): void;
+
+    centerChildOnParent(parentId: ModalId): boolean;
+
+    scheduleCenterChildOnParent(parentId: ModalId): void;
+}
+
+export declare interface ModalPositioningOptions {
+
+    id: ModalId;
+
+    dataId: string;
+
+    configHelper: PositioningConfigHelper;
+
+    getDragBehavior: () => DragBehavior;
+
+    getElement: () => HTMLElement | null;
+}
+
+export declare interface ModalState {
+    id: ModalId;
+    title: string;
+    icon: string;
+    iconBadge?: string;
+    isOpen: boolean;
+    isMinimized: boolean;
+    isHiddenWithParent: boolean;
+    isTransparent: boolean;
+    isAnimating: boolean;
+    isAnimatingPosition?: boolean;
+    isRejected: boolean;
+    zIndex: number;
+    position: Position | null;
+    size: Dimensions | null;
+    hasBeenDragged: boolean;
+    dockPosition: number;
+    glow: ModalGlow | null;
+    content?: unknown;
+    contentBg?: string;
+    parentId?: ModalId;
+    childId?: ModalId;
+    offsetFromParent?: Position;
+    lastChildId?: ModalId;
+}
+
+export declare class ModalStateManager {
+    private id;
+    private options;
+    private _isHandlingMinimize;
+    private _isAttentionAnimating;
+    private _wasRestored;
+    private _glowStabilizing;
+    private _restoreHold;
+    private _isAnimatingToCenter;
+    private _cancelParentAnimationCleanup;
+    private _parentFlipInFlight;
+    private _deferredParentTarget;
+    private _parentFlipStartTime;
+    constructor(options: ModalStateManagerOptions);
+
+    handlePendingStates(): void;
+
+    private handlePendingForceClose;
+
+    private handlePendingMinimize;
+
+    private handlePendingMinimizeWithParent;
+
+    private handlePendingRestore;
+
+    private handlePendingChildRestore;
+
+    private handlePendingClose;
+
+    private handlePendingParentLink;
+
+    private handlePendingOpen;
+
+    private openChildModalWithAnimation;
+
+    private openStandaloneModalWithAnimation;
+
+    private handlePendingAttention;
+
+    private handlePendingParentAnimation;
+
+    private startParentFlip;
+
+    private handleChildCentering;
+    get wasRestored(): boolean;
+    set wasRestored(value: boolean);
+    get isAttentionAnimating(): boolean;
+    get glowStabilizing(): boolean;
+    set glowStabilizing(value: boolean);
+    get restoreHold(): boolean;
+    set restoreHold(value: boolean);
+    get isAnimatingToCenter(): boolean;
+    set isAnimatingToCenter(value: boolean);
+    get isHandlingMinimize(): boolean;
+}
+
+export declare interface ModalStateManagerOptions {
+
+    id: ModalId;
+
+    options: {
+        glow?: unknown;
+        openSourcePosition?: Position | null;
+        onClose?: () => void;
+    };
+
+    getDragBehavior: () => DragBehavior;
+
+    getResizeBehavior: () => ResizeBehavior;
+
+    getAnimationController: () => AnimationController;
+
+    getElement: () => HTMLElement | null;
+
+    getPositioning: () => StateManagerPositioning;
+
+    onStateChange: () => void;
+
+    focusFirst: () => void;
+}
+
+export declare function normalizeBackdropConfig(backdrop: boolean | BackdropConfig): BackdropConfig;
+
+export declare function onAnimationEnd(element: HTMLElement, animationName?: string, timeout?: number): Promise<AnimationEvent>;
+
+export declare function openChildModal(childId: ModalId, parentId: ModalId, source: HTMLElement | Position): void;
+
+export declare function openModal(id: ModalId, source: HTMLElement | Position, options?: OpenModalOptions): void;
+
+export declare interface OpenModalOptions {
+
+    parentId?: ModalId;
+}
+
+export declare interface ParentChildConfig {
+
+    movementMode: 'realtime' | 'animated';
+
+    animationDuration: number;
+}
+
+export declare interface ParentChildOverride {
+    movementMode?: 'realtime' | 'animated';
+    animationDuration?: number;
+}
+
+export declare type PartialModalLibraryConfig = DeepPartial<ModalLibraryConfig>;
+
+export declare interface Position {
+
+    x: number;
+
+    y: number;
+}
+
+export declare interface PositioningConfig {
+
+    strategy: 'centered' | 'smart';
+
+    modalGap: number;
+
+    avoidElements: string[];
+}
+
+export declare interface PositioningConfigHelper {
+    getPositioning: <K extends keyof PositioningConfig>(key: K) => PositioningConfig[K];
+}
+
+export declare interface PositioningOverride {
+    strategy?: 'centered' | 'smart';
+    modalGap?: number;
+    avoidElements?: string[];
+}
+
+export declare function registerModal(modal: Omit<ModalState, 'zIndex' | 'isAnimating'>): void;
+
+export declare interface RegistryCallbacks {
+    mountModal: (id: ModalId) => void;
+    isRegisteredInRegistry: (id: ModalId) => boolean;
+    unmountModal: (id: ModalId) => void;
+}
+
+export declare function reorderDock(newOrderOrFromIndex: ModalId[] | number, toIndex?: number): void;
+
+export declare function resetConfig(): void;
+
+export declare function _resetInternalState(): void;
+
+export declare function resetModalTransparency(id: ModalId): void;
+
+export declare function resetStacking(): void;
+
+export declare const RESIZE_DIRECTION_LABELS: Record<ResizeDirection_2, string>;
+
+export declare const RESIZE_DIRECTIONS: readonly ["n", "s", "e", "w", "ne", "nw", "se", "sw"];
+
+export declare interface ResizeBehavior {
+    getState(): ResizeState;
+    getSize(): Dimensions;
+    isResizing(): boolean;
+    hasBeenResized(): boolean;
+    justFinishedResizing(): boolean;
+    setSize(size: Dimensions): void;
+    reset(): void;
+    constrainToViewport(): void;
+    startResize(e: PointerEvent, direction: ResizeDirection): void;
+    subscribe(callback: (state: ResizeState) => void): () => void;
+    destroy(): void;
+}
+
+export declare interface ResizeBehaviorOptions {
+    minWidth?: number;
+    minHeight?: number;
+    getPosition: () => Position;
+    setPosition: (pos: Position) => void;
+    getHasBeenDragged: () => boolean;
+    setHasBeenDragged: (value: boolean) => void;
+    getElement: () => HTMLElement | null;
+    getSymmetricResize?: () => boolean;
+    onResizeEnd?: (position: Position, size: Dimensions) => void;
+}
+
+export declare type ResizeDirection = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw' | '';
+
+declare type ResizeDirection_2 = typeof RESIZE_DIRECTIONS[number];
+
+export declare interface ResizeEvents {
+    change: ResizeState;
+    resizeStart: {
+        direction: ResizeDirection;
+    };
+    resizeMove: {
+        size: Dimensions;
+        position: Position;
+    };
+    resizeEnd: {
+        size: Dimensions;
+        position: Position;
+    };
+}
+
+export declare interface ResizeState {
+    isResizing: boolean;
+    direction: ResizeDirection;
+    size: Dimensions;
+    hasBeenResized: boolean;
+}
+
+export declare function restoreAllMinimizedModals(): void;
+
+export declare function restoreChildModal(id: ModalId): void;
+
+export declare function restoreModal(id: ModalId): void;
+
+export declare function setConfig(config: PartialModalLibraryConfig): void;
+
+export declare function setDockPositionGetterInternal(getter: DockPositionGetter | null): void;
+
+export declare function setModalAnimating(id: ModalId, animating: boolean): void;
+
+declare function setRegistryCallbacksInternal(callbacks: RegistryCallbacks | null): void;
+export { setRegistryCallbacksInternal }
+export { setRegistryCallbacksInternal as setRegistryFunctions }
+
+export declare function setupAnimationEndListener(element: HTMLElement, callback: (animationName: string) => void): () => void;
+
+declare function setURLCallbacks(callbacks: URLStateCallbacks | null): void;
+export { setURLCallbacks }
+export { setURLCallbacks as setURLStateCallbacks }
+
+export declare function shakeElement(element: HTMLElement): void;
+
+export declare function shouldChildBeVisible(parentIsOpen: boolean, parentIsMinimized: boolean, parentIsHiddenWithParent: boolean): boolean;
+
+export declare interface SmartLayoutOptions {
+
+    modalGap?: number;
+
+    viewportMargin?: number;
+
+    avoidBounds?: ModalBounds[];
+
+    avoidMargin?: number;
+}
+
+export declare interface SmartLayoutResult {
+
+    positions: Map<string, Position>;
+}
+
+export declare interface SmartPositionOptions {
+
+    modalGap?: number;
+
+    margin?: number;
+
+    gridResolution?: number;
+
+    avoidBounds?: ModalBounds[];
+
+    avoidMargin?: number;
+}
+
+export declare type StackingLayerName = 'BASE' | 'DROPDOWN' | 'STICKY' | 'OVERLAY' | 'MODAL' | 'DOCK' | 'TOAST';
+
+export declare function startAttentionAnimation(_id: ModalId): void;
+
+export declare interface StateManagerPositioning {
+    centerChildOnParent: (parentId: ModalId) => boolean;
+    scheduleCenterChildOnParent: (parentId: ModalId) => void;
+    applySmartPositioning: () => void;
+    scheduleSmartPositioning: () => void;
+}
+
+export declare function storeOpenSourcePosition(id: ModalId, position: Position): void;
+
+export declare function subscribe(callback: () => void): () => void;
+
+export declare function subscribeToConfig(callback: () => void): () => void;
+
+export declare function toDataId(id: ModalId): string;
+
+export declare function toggleModalTransparency(id: ModalId): void;
+
+export declare function transformToCSSVars(transform: AnimationTransform): Record<string, string>;
+
+export declare function trapFocus(event: KeyboardEvent, container: HTMLElement): void;
+
+export declare function triggerAttention(id: ModalId): void;
+
+export declare function triggerCascadingParentAnimations(childId: ModalId): void;
+
+export declare function triggerRearrangement(newModal: {
+    id: string;
+    width: number;
+    height: number;
+} | null): void;
+
+export declare function triggerRejection(id: ModalId): void;
+
+export declare function unhideChildModal(id: ModalId): void;
+
+export declare function unregisterModal(id: ModalId): void;
+
+export declare function updateModal(id: ModalId, updates: Partial<ModalState>): void;
+
+export declare function updateModalPosition(id: ModalId, position: Position, options?: {
+    constrain?: boolean;
+    drag?: boolean;
+    size?: Dimensions;
+    realtime?: boolean;
+}): void;
+
+export declare function updateModalSize(id: ModalId, size: Dimensions): void;
+
+export declare interface URLStateCallbacks {
+    push: (id: ModalId) => void;
+    replace: (id: ModalId) => void;
+    pop: () => void;
+}
+
+export declare interface ViewportConstraintOptions {
+
+    margin?: number;
+
+    allowPartialVisibility?: boolean;
+}
+
+declare interface WhenDOMReadyOptions {
+
+    timeout?: number;
+
+    pollInterval?: number;
+}
+
+export declare function whenHasDimensions(element: () => HTMLElement | null, options?: WhenDOMReadyOptions): Promise<HTMLElement>;
+
+export declare interface ZIndexConfig {
+
+    base: number;
+
+    dock: number;
+
+    toast: number;
+}
+
+export { }