@cocoar/ui 0.1.0-beta.99 → 0.1.1

package/types/cocoar-ui-menu.d.ts

@@ -0,0 +1,326 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+
+interface CoarMenuAimConfig {
+    readonly enabled: boolean;
+    /** Emits debug events consumed by the showcase to render the aim triangle overlay. */
+    readonly debugEnabled: boolean;
+    /** Delay before switching to a newly hovered sibling submenu when aim is detected. */
+    readonly switchDelayMs: number;
+    /** Maximum age of the last pointer sample used for intent detection. */
+    readonly sampleMaxAgeMs: number;
+}
+interface CoarMenuAimConfigProvider {
+    getMenuAimConfig(): CoarMenuAimConfig;
+}
+declare const DEFAULT_COAR_MENU_AIM_CONFIG: CoarMenuAimConfig;
+declare const COAR_MENU_AIM_CONFIG: InjectionToken<CoarMenuAimConfigProvider>;
+
+declare class CoarMenuAimConfigDirective implements CoarMenuAimConfigProvider {
+    private readonly parent;
+    /** Enable/disable menu-aim for this menu tree. */
+    readonly aimEnabled: _angular_core.InputSignal<boolean | undefined>;
+    /** Emit debug events for menu-aim visualization (showcase only). */
+    readonly aimDebugEnabled: _angular_core.InputSignal<boolean | undefined>;
+    /** Delay before switching to a newly hovered sibling submenu when aim is detected. */
+    readonly aimSwitchDelayMs: _angular_core.InputSignal<number | undefined>;
+    /** Maximum age of the last pointer sample used for intent detection. */
+    readonly aimSampleMaxAgeMs: _angular_core.InputSignal<number | undefined>;
+    getMenuAimConfig(): CoarMenuAimConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarMenuAimConfigDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoarMenuAimConfigDirective, "[coarMenuAimConfig]", never, { "aimEnabled": { "alias": "aimEnabled"; "required": false; "isSignal": true; }; "aimDebugEnabled": { "alias": "aimDebugEnabled"; "required": false; "isSignal": true; }; "aimSwitchDelayMs": { "alias": "aimSwitchDelayMs"; "required": false; "isSignal": true; }; "aimSampleMaxAgeMs": { "alias": "aimSampleMaxAgeMs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * CoarMenu: Shell component providing menu styling container.
+ *
+ * Responsibilities:
+ * - Apply consistent menu styling via CSS variables
+ * - Provide semantic menu container (<menu> or <div role="menu">)
+ * - Provide root cascade for sibling submenu tracking
+ * - No logic - just a styled wrapper
+ *
+ * Use standalone for inline menus, or as overlay content (via `createOverlayBuilder`) for context menus/flyouts.
+ *
+ * @example
+ * ```html
+ * <coar-menu>
+ *   <coar-menu-item>Action 1</coar-menu-item>
+ *   <coar-menu-item>Action 2</coar-menu-item>
+ *   <coar-menu-divider></coar-menu-divider>
+ *   <coar-menu-item>Action 3</coar-menu-item>
+ * </coar-menu>
+ * ```
+ */
+declare class CoarMenuComponent {
+    private readonly overlayRef;
+    /**
+     * Controls whether the menu reserves and renders an icon column.
+     *
+     * Default is enabled to avoid layout shift for stateful icons (e.g. checkmarks).
+     * Set to false for text-only menus (icons will not render).
+     */
+    readonly showIconColumn: _angular_core.InputSignal<boolean>;
+    /**
+     * Removes border, background, border-radius, and shadow for seamless embedding in containers.
+     *
+     * Use when embedding menu in sidebars, panels, or custom containers that provide their own styling.
+     * Use as boolean attribute: `<coar-menu borderless>` or `[borderless]="true"`
+     */
+    readonly borderless: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Check if this menu is rendered inside an overlay (flyout).
+     * Used to enable border visibility for menu items.
+     */
+    protected isInOverlay(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarMenuComponent, "coar-menu", never, { "showIconColumn": { "alias": "showIconColumn"; "required": false; "isSignal": true; }; "borderless": { "alias": "borderless"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof CoarMenuAimConfigDirective; inputs: { "aimEnabled": "aimEnabled"; "aimDebugEnabled": "aimDebugEnabled"; "aimSwitchDelayMs": "aimSwitchDelayMs"; "aimSampleMaxAgeMs": "aimSampleMaxAgeMs"; }; outputs: {}; }]>;
+}
+
+/**
+ * Event emitted when a menu item is clicked.
+ * Provides control over menu closing behavior.
+ */
+interface CoarMenuItemClickEvent {
+    /** Call this to keep the menu open after clicking (prevents auto-close) */
+    keepMenuOpen(): void;
+    /** Original mouse event */
+    event: MouseEvent;
+}
+/**
+ * CoarMenuItem: Individual menu item with optional icon and submenu support.
+ *
+ * Responsibilities:
+ * - Render item text and optional icon
+ * - Handle click events
+ * - Support disabled state
+ * - Visual states: hover, active, focus
+ * - Trigger submenu (accordion or flyout via parent menu logic)
+ *
+ * Does NOT manage overlay directly - parent menu handles flyout logic.
+ *
+ * @example
+ * ```html
+ * <coar-menu-item (clicked)="onSave()">Save</coar-menu-item>
+ * <coar-menu-item icon="copy">Copy</coar-menu-item>
+ * <coar-menu-item [disabled]="true">Unavailable</coar-menu-item>
+ *
+ * <!-- Prevent menu from closing on click: -->
+ * <coar-menu-item (clicked)="toggle($event)">Toggle Setting</coar-menu-item>
+ *
+ * toggle(event: CoarMenuItemClickEvent) {
+ *   event.keepMenuOpen(); // Keep menu open
+ *   this.setting = !this.setting;
+ * }
+ * ```
+ */
+declare class CoarMenuItemComponent {
+    private readonly parentOverlay;
+    /** Item text content */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Optional icon identifier (rendered via CoarIconComponent) */
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    /** Disabled state prevents interaction */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Emitted when user clicks/selects the item. Menu closes by default unless preventDefault() is called. */
+    readonly clicked: _angular_core.OutputEmitterRef<CoarMenuItemClickEvent>;
+    /** Emitted when user hovers over item (for flyout trigger) */
+    readonly hovered: _angular_core.OutputEmitterRef<Event>;
+    onClick(event: MouseEvent): void;
+    onMouseEnter(event: MouseEvent): void;
+    onKeyboardActivate(): void;
+    private closeMenuTree;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarMenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarMenuItemComponent, "coar-menu-item", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; "hovered": "hovered"; }, never, ["*"], true, never>;
+}
+
+/**
+ * CoarMenuDivider: Visual separator between menu items.
+ *
+ * Simple horizontal line for grouping menu items.
+ *
+ * @example
+ * ```html
+ * <coar-menu>
+ *   <coar-menu-item>Cut</coar-menu-item>
+ *   <coar-menu-item>Copy</coar-menu-item>
+ *   <coar-menu-divider></coar-menu-divider>
+ *   <coar-menu-item>Paste</coar-menu-item>
+ * </coar-menu>
+ * ```
+ */
+declare class CoarMenuDividerComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarMenuDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarMenuDividerComponent, "coar-menu-divider", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * CoarMenuHeading: Non-interactive section label for menu groups.
+ *
+ * Responsibilities:
+ * - Display section/group heading text
+ * - Provide visual separation between menu sections
+ * - Non-interactive (no hover, no click, not focusable)
+ *
+ * @example
+ * ```html
+ * <coar-menu>
+ *   <coar-menu-heading>Foundations</coar-menu-heading>
+ *   <coar-menu-item routerLink="/typography">Typography</coar-menu-item>
+ *   <coar-menu-item routerLink="/colors">Colors</coar-menu-item>
+ *
+ *   <coar-menu-heading>Form Controls</coar-menu-heading>
+ *   <coar-menu-item routerLink="/text-input">Text Input</coar-menu-item>
+ * </coar-menu>
+ * ```
+ */
+declare class CoarMenuHeadingComponent {
+    /** Optional explicit label text (alternative to content projection) */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarMenuHeadingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarMenuHeadingComponent, "coar-menu-heading", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * CoarSubmenuItem: Menu item that opens a submenu on hover.
+ *
+ * Responsibilities:
+ * - Render parent item with icon and label
+ * - Manage submenu overlay lifecycle
+ * - Support nested submenus (can contain other submenu-items)
+ *
+ * @example
+ * ```html
+ * <coar-submenu-item label="Share" icon="🔗">
+ *   <ng-template>
+ *     <coar-menu-item icon="✉️" (clicked)="sendEmail()">Email</coar-menu-item>
+ *     <coar-menu-item icon="🔗" (clicked)="copyLink()">Copy Link</coar-menu-item>
+ *   </ng-template>
+ * </coar-submenu-item>
+ *
+ * <!-- Optional: explicitly mark the template -->
+ * <coar-submenu-item label="Share" icon="🔗">
+ *   <ng-template coarSubmenu>
+ *     ...
+ *   </ng-template>
+ * </coar-submenu-item>
+ *
+ * <!-- Also supported (legacy / external template): -->
+ * <coar-submenu-item label="Share" icon="🔗" [submenuTemplate]="shareMenu" />
+ * ```
+ */
+declare class CoarSubmenuItemComponent {
+    private readonly destroyRef;
+    private readonly cdr;
+    private readonly cascade;
+    private readonly parentOverlay;
+    private readonly injector;
+    private readonly overlayBuilder;
+    protected readonly submenuTemplateInjector: _angular_core.DestroyableInjector;
+    constructor();
+    /** Label text for the menu item */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Optional icon identifier */
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    /** Disabled state prevents interaction */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Optional external submenu template.
+     *
+     * Prefer an inline `<ng-template>` child when possible.
+     */
+    readonly submenuTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /**
+     * Optional data to pass to the submenu template.
+     *
+     * If provided, this data will be passed as the context to the submenu template,
+     * instead of inheriting the parent overlay's context.
+     *
+     * Use this to create clean boundaries between parent and submenu:
+     * - Simple case: `[submenuData]="context"` (pass full context)
+     * - Complex case: `[submenuData]="transformData(context)"` (pass only what submenu needs)
+     *
+     * @example
+     * ```html
+     * <!-- Pass specific data contract to submenu -->
+     * <coar-submenu-item
+     *   label="Status"
+     *   [submenuTemplate]="statusMenu"
+     *   [submenuData]="{ selectedIds: context.selected.map(s => s.Id) }">
+     * </coar-submenu-item>
+     * ```
+     */
+    readonly submenuData: _angular_core.InputSignal<unknown>;
+    private readonly markedInlineTemplate?;
+    private readonly inlineTemplate?;
+    private overlaySubmenuTemplate;
+    private submenuRef;
+    isOpen: boolean;
+    protected submenuTemplateToRender(): TemplateRef<unknown>;
+    onMouseEnter(event: MouseEvent): void;
+    onClick(event: MouseEvent): void;
+    onKeyboardActivate(event: Event): void;
+    private openSubmenu;
+    private closeSubmenu;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarSubmenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarSubmenuItemComponent, "coar-submenu-item, coar-sub-flyout", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "submenuTemplate": { "alias": "submenuTemplate"; "required": false; "isSignal": true; }; "submenuData": { "alias": "submenuData"; "required": false; "isSignal": true; }; }, {}, ["markedInlineTemplate", "inlineTemplate"], never, true, never>;
+}
+
+/**
+ * CoarSubExpand: Menu item that expands/collapses a submenu inline.
+ *
+ * Use this variant when you want nested options to stay visible (e.g. sidebar panels)
+ * while still reusing the same menu item types inside the submenu.
+ *
+ * @example
+ * ```html
+ * <coar-menu>
+ *   <coar-sub-expand label="Filters" icon="settings" [(open)]="filtersOpen">
+ *     <ng-template>
+ *       <coar-menu>
+ *         <coar-menu-item icon="plus">Add Filter</coar-menu-item>
+ *         <coar-menu-item icon="trash">Clear</coar-menu-item>
+ *       </coar-menu>
+ *     </ng-template>
+   </coar-sub-expand>
+ * </coar-menu>
+ * ```
+ */
+declare class CoarSubExpandComponent {
+    /** Label text for the menu item */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Optional icon identifier */
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    /** Disabled state prevents interaction */
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Expanded state (two-way bindable with [(open)]) */
+    readonly open: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Emits when expanded state changes (for [(open)]) */
+    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly openInternal;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    /** Optional external submenu template. Prefer an inline `<ng-template>` child when possible. */
+    readonly submenuTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    private readonly markedInlineTemplate?;
+    private readonly inlineTemplate?;
+    protected submenuTemplateToRender(): TemplateRef<unknown>;
+    constructor();
+    toggle(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarSubExpandComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarSubExpandComponent, "coar-sub-expand", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "submenuTemplate": { "alias": "submenuTemplate"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, ["markedInlineTemplate", "inlineTemplate"], never, true, never>;
+}
+
+/**
+ * Marks an inline submenu template for a `coar-submenu-item`.
+ *
+ * This is optional: if a submenu item contains exactly one direct child `<ng-template>`,
+ * that template will be used even without this directive.
+ */
+declare class CoarSubmenuTemplateDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarSubmenuTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoarSubmenuTemplateDirective, "ng-template[coarSubmenu]", never, {}, {}, never, never, true, never>;
+}
+
+export { COAR_MENU_AIM_CONFIG, CoarMenuAimConfigDirective, CoarMenuComponent, CoarMenuDividerComponent, CoarMenuHeadingComponent, CoarMenuItemComponent, CoarSubExpandComponent, CoarSubmenuItemComponent, CoarSubmenuTemplateDirective, DEFAULT_COAR_MENU_AIM_CONFIG };
+export type { CoarMenuAimConfig, CoarMenuAimConfigProvider, CoarMenuItemClickEvent };

package/types/cocoar-ui-overlay.d.ts

@@ -0,0 +1,301 @@
+import * as i0 from '@angular/core';
+import { Type, TemplateRef, InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+
+interface OverlaySpec<TInputs = void> {
+    content?: ContentSpec<TInputs>;
+    anchor?: AnchorSpec;
+    position?: PositionSpec;
+    size?: SizeSpec;
+    backdrop?: BackdropSpec;
+    scroll?: ScrollSpec;
+    dismiss?: DismissSpec;
+    focus?: FocusSpec;
+    a11y?: A11ySpec;
+    attachment?: AttachmentSpec;
+    /**
+     * Additional CSS class(es) to add to the overlay panel element.
+     * Useful for applying custom styles or size variants.
+     */
+    panelClass?: string | string[];
+}
+/**
+ * Optional application-level hook to apply global overlay defaults/policies.
+ *
+ * Resolvers should be pure functions and must not override explicit caller configuration
+ * unless the application intentionally chooses to.
+ */
+type OverlaySpecResolver = (spec: OverlaySpec<unknown>) => OverlaySpec<unknown>;
+/**
+ * Multi-provider token. Resolvers are applied in registration order.
+ */
+declare const COAR_OVERLAY_SPEC_RESOLVERS: InjectionToken<readonly OverlaySpecResolver[]>;
+type Placement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end' | 'center';
+interface ContentSpec<TInputs> {
+    kind: 'component' | 'template' | 'text';
+    component?: Type<unknown>;
+    template?: TemplateRef<unknown>;
+    /**
+     * Optional default inputs.
+     * Runtime inputs provided at open() time are merged on top.
+     */
+    defaults?: Partial<TInputs>;
+}
+type AnchorSpec = {
+    kind: 'element';
+    element: Element;
+} | {
+    kind: 'point';
+    x: number;
+    y: number;
+} | {
+    kind: 'virtual';
+    placement: 'center' | 'top' | 'bottom';
+};
+interface PositionSpec {
+    placement: Placement | readonly Placement[];
+    offset?: number;
+    flip?: boolean;
+    shift?: boolean;
+}
+interface SizeSpec {
+    mode: 'content' | 'content-clamped' | 'fixed';
+    minWidth?: number | 'anchor';
+    minHeight?: number | 'anchor';
+    maxWidth?: number | 'viewport';
+    maxHeight?: number | 'viewport';
+}
+type BackdropSpec = {
+    kind: 'none';
+} | {
+    kind: 'modal';
+    closeOnBackdropClick?: boolean;
+};
+interface ScrollSpec {
+    strategy: 'noop' | 'reposition' | 'close';
+}
+interface DismissSpec {
+    outsideClick?: boolean;
+    escapeKey?: boolean;
+    /**
+     * Optional pointer-based dismissal for menu-like overlays.
+     *
+     * When enabled, the overlay closes after the pointer leaves the overlay *tree*
+     * (the overlay itself and any child overlays opened via openChild()).
+     * Entering any child overlay cancels the parent's close timer.
+     */
+    hoverTree?: {
+        enabled?: boolean;
+        delayMs?: number;
+    };
+}
+interface FocusSpec {
+    trap?: boolean;
+    restore?: boolean;
+}
+interface A11ySpec {
+    role?: 'dialog' | 'menu' | 'tooltip' | 'listbox';
+    label?: string;
+    labelledBy?: string;
+    describedBy?: string;
+}
+/**
+ * Defines where the overlay element is attached in the DOM and what boundaries
+ * are used for clamping/fallback calculations.
+ *
+ * - 'body': Attach to document.body (portal pattern), use viewport boundaries
+ * - 'parent': Attach to a specific container element, use that container's boundaries
+ */
+type AttachmentSpec = {
+    strategy: 'body';
+} | {
+    strategy: 'parent';
+    container: HTMLElement;
+};
+declare const COAR_OVERLAY_DEFAULTS: {
+    readonly anchor: {
+        readonly kind: "virtual";
+        readonly placement: "center";
+    };
+    readonly position: {
+        readonly placement: readonly ["top", "bottom", "left", "right"];
+        readonly offset: 8;
+        readonly flip: true;
+        readonly shift: true;
+    };
+    readonly backdrop: {
+        readonly kind: "none";
+    };
+    readonly scroll: {
+        readonly strategy: "reposition";
+    };
+    readonly dismiss: {
+        readonly outsideClick: true;
+        readonly escapeKey: true;
+    };
+    readonly focus: {
+        readonly trap: false;
+        readonly restore: true;
+    };
+    readonly a11y: {};
+    readonly attachment: {
+        readonly strategy: "body";
+    };
+};
+
+interface OverlayRef {
+    close(result?: unknown): void;
+    updatePosition(): void;
+    closeChildren(exclude?: OverlayRef): void;
+    readonly afterClosed$: Observable<unknown>;
+    readonly isClosed: boolean;
+    /**
+     * Get the root overlay in a parent-child tree (e.g., menu with submenus).
+     * Returns this overlay if it has no parent.
+     */
+    getRoot(): OverlayRef;
+    /**
+     * Optional DOM access for advanced behaviors (e.g. menu-aim).
+     * Implementations may return the inner panel element that contains the rendered content.
+     */
+    getPanelElement?(): HTMLElement;
+}
+
+interface OverlayOpenOptions {
+    closeSiblings?: boolean;
+}
+type OverlaySettings<TInputs> = Omit<OverlaySpec<TInputs>, 'content'>;
+type UnwrapInputSignal<T> = T extends i0.InputSignal<infer V> ? V : T;
+type ComponentInputs<C> = {
+    [K in keyof C]?: UnwrapInputSignal<C[K]>;
+};
+declare class CoarOverlayService {
+    private readonly appRef;
+    private readonly environmentInjector;
+    private readonly specResolvers;
+    private readonly openOverlays;
+    private globalListenersInstalled;
+    private readonly onDocumentPointerDown;
+    private readonly onDocumentKeyDown;
+    openTemplate<TCtx>(template: TemplateRef<TCtx>, settings: OverlaySettings<TCtx>, inputs: TCtx): OverlayRef;
+    openComponent<C>(component: Type<C>, settings: OverlaySettings<ComponentInputs<C>>, inputs: ComponentInputs<C>): OverlayRef;
+    openText(settings: OverlaySettings<{
+        text: string;
+    }>, inputs: {
+        text: string;
+    }): OverlayRef;
+    openTemplateAsChild<TCtx>(parent: OverlayRef, template: TemplateRef<TCtx>, settings: OverlaySettings<TCtx>, inputs: TCtx, options?: OverlayOpenOptions): OverlayRef;
+    openComponentAsChild<C>(parent: OverlayRef, component: Type<C>, settings: OverlaySettings<ComponentInputs<C>>, inputs: ComponentInputs<C>, options?: OverlayOpenOptions): OverlayRef;
+    openTextAsChild(parent: OverlayRef, settings: OverlaySettings<{
+        text: string;
+    }>, inputs: {
+        text: string;
+    }, options?: OverlayOpenOptions): OverlayRef;
+    closeAll(): void;
+    private resolveSpec;
+    private applySpecResolvers;
+    private attach;
+    private inheritDismissFromParent;
+    private getInternalRefOrNull;
+    private installGlobalListenersIfNeeded;
+    private uninstallGlobalListenersIfIdle;
+    private getOpenOverlaysInOrder;
+    private getTopmostOverlayContainingTarget;
+    private getTopmostDismissableOverlay;
+    private getTopmostFocusTrappingOverlay;
+    private mergeInputs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoarOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CoarOverlayService>;
+}
+
+interface OverlayChildOpenOptions {
+    closeSiblings?: boolean;
+}
+interface TemplateOverlayOpener<TCtx> {
+    open(inputs: TCtx): OverlayRef;
+    openAsChild(parent: OverlayRef, inputs: TCtx, options?: OverlayChildOpenOptions): OverlayRef;
+}
+interface ComponentOverlayOpener<C> {
+    open(inputs: ComponentInputs<C>): OverlayRef;
+    openAsChild(parent: OverlayRef, inputs: ComponentInputs<C>, options?: OverlayChildOpenOptions): OverlayRef;
+}
+interface TextOverlayOpener {
+    open(inputs: {
+        text: string;
+    }): OverlayRef;
+    openAsChild(parent: OverlayRef, inputs: {
+        text: string;
+    }, options?: OverlayChildOpenOptions): OverlayRef;
+}
+declare class CoarOverlayOpenBuilder {
+    private readonly service;
+    private readonly settings;
+    constructor(service: CoarOverlayService, settings?: OverlaySettings<unknown>);
+    fork(): CoarOverlayOpenBuilder;
+    backdrop(value: OverlaySettings<unknown>['backdrop']): CoarOverlayOpenBuilder;
+    anchor(value: OverlaySettings<unknown>['anchor']): CoarOverlayOpenBuilder;
+    position(value: OverlaySettings<unknown>['position']): CoarOverlayOpenBuilder;
+    size(value: OverlaySettings<unknown>['size']): CoarOverlayOpenBuilder;
+    scroll(value: OverlaySettings<unknown>['scroll']): CoarOverlayOpenBuilder;
+    dismiss(value: OverlaySettings<unknown>['dismiss']): CoarOverlayOpenBuilder;
+    focus(value: OverlaySettings<unknown>['focus']): CoarOverlayOpenBuilder;
+    a11y(value: OverlaySettings<unknown>['a11y']): CoarOverlayOpenBuilder;
+    attachment(value: OverlaySettings<unknown>['attachment']): CoarOverlayOpenBuilder;
+    /**
+     * Add CSS class(es) to the overlay panel element.
+     * Useful for applying custom styles or size variants.
+     */
+    panelClass(value: string | string[]): CoarOverlayOpenBuilder;
+    /**
+     * Applies baseline settings, without overriding fields already set on this builder.
+     * Useful for applying a preset after you've already configured part of the builder.
+     */
+    withPreset(value: OverlaySettings<unknown>): CoarOverlayOpenBuilder;
+    fromTemplate<TCtx>(template: TemplateRef<TCtx>): TemplateOverlayOpener<TCtx>;
+    fromComponent<C>(component: Type<C>): ComponentOverlayOpener<C>;
+    fromText(): TextOverlayOpener;
+}
+/**
+ * Content-last overlay builder (configure shared overlay settings once).
+ *
+ * Intended usage:
+ *
+ * ```ts
+ * const overlay = createOverlayBuilder()
+ *   .anchor({ kind: 'element', element })
+ *   .position({ placement: 'bottom-start', offset: 4, flip: true, shift: true });
+ *
+ * overlay.fromTemplate(tpl).open({ $implicit: data });
+ * overlay.fromComponent(MyCmp).open({ text: 'Hello' });
+ * ```
+ *
+ * You can also provide initial settings:
+ *
+ * ```ts
+ * const overlay = createOverlayBuilder(coarMenuPreset);
+ * ```
+ */
+declare function createOverlayBuilder(): CoarOverlayOpenBuilder;
+declare function createOverlayBuilder(initial: OverlaySettings<unknown>): CoarOverlayOpenBuilder;
+
+declare const coarTooltipPreset: OverlaySettings<unknown>;
+declare const coarModalPreset: OverlaySettings<unknown>;
+declare const coarMenuPreset: OverlaySettings<unknown>;
+declare const coarHoverMenuPreset: OverlaySettings<unknown>;
+
+/**
+ * The OverlayRef for the overlay currently rendering this content.
+ *
+ * Provided automatically by CoarOverlayService for overlay content so components
+ * can open true child overlays without DOM lookups.
+ */
+declare const COAR_OVERLAY_REF: InjectionToken<OverlayRef>;
+/**
+ * Parent overlay reference for menu hierarchies.
+ * Each overlay provides this token pointing to itself, enabling child menu items
+ * to close siblings by calling parent.closeChildren().
+ */
+declare const COAR_MENU_PARENT: InjectionToken<OverlayRef | null>;
+
+export { COAR_MENU_PARENT, COAR_OVERLAY_DEFAULTS, COAR_OVERLAY_REF, COAR_OVERLAY_SPEC_RESOLVERS, CoarOverlayOpenBuilder, coarHoverMenuPreset, coarMenuPreset, coarModalPreset, coarTooltipPreset, createOverlayBuilder };
+export type { A11ySpec, AnchorSpec, AttachmentSpec, BackdropSpec, ComponentOverlayOpener, DismissSpec, FocusSpec, OverlayChildOpenOptions, OverlayRef, OverlaySettings, OverlaySpec, OverlaySpecResolver, Placement, PositionSpec, ScrollSpec, SizeSpec, TemplateOverlayOpener, TextOverlayOpener };

package/types/cocoar-ui.d.ts

@@ -0,0 +1,3 @@
+export * from '@cocoar/ui/overlay';
+export * from '@cocoar/ui/components';
+export * from '@cocoar/ui/menu';

package/src/index.d.ts

@@ -1,4 +0,0 @@
-export * from '@cocoar/ui-components';
-export * from '@cocoar/ui-menu';
-export * from '@cocoar/ui-overlay';
-//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../libs/ui/src/index.ts"],"names":[],"mappings":"AACA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/src/index.js

@@ -1,5 +0,0 @@
-// Re-export all Cocoar Design System packages
-export * from '@cocoar/ui-components';
-export * from '@cocoar/ui-menu';
-export * from '@cocoar/ui-overlay';
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/ui/src/index.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC","sourcesContent":["// Re-export all Cocoar Design System packages\nexport * from '@cocoar/ui-components';\nexport * from '@cocoar/ui-menu';\nexport * from '@cocoar/ui-overlay';\n"]}