@frame-kit/ui-ng 0.0.2 → 0.0.4

package/ui/nav-group/README.md

@@ -15,6 +15,8 @@ An expandable sidenav group — renders a clickable trigger row (icon + label, o
 | `iconSize`   | `IconSize`                   | `"sm"`  | Size passed through to the trigger's `fk-sidenav-link`.                                                                      |
 | `routerLink` | `string \| string[] \| null` | `null`  | Destination for the trigger's anchor. Active in both expanded and collapsed states.                                          |
 | `collapsed`  | `boolean`                    | `false` | Set this to `true` when the outer sidenav is in its collapsed rail state — clicks then both navigate AND emit `requestOpen`. |
+| `lockedOpen` | `boolean`                    | `false` | When `true`, clicking an expanded group's trigger no longer folds it — children stay visible (navigation via `routerLink` still fires). No effect in collapsed rail mode.   |
+| `showChevron`| `boolean`                    | `false` | Renders a trailing disclosure chevron that points right while collapsed and rotates to point down while expanded. Decorative; hidden in rail mode.                          |
 | `className`  | `string`                     | `''`    | Additional CSS classes merged onto the host element.                                                                         |
 
 ### Models
@@ -49,6 +51,8 @@ An expandable sidenav group — renders a clickable trigger row (icon + label, o
 - `requestOpen` output bridges to a collapsible outer shell (`fk-app-shell` and friends) — fires alongside navigation when clicked in rail mode
 - Content projection for arbitrary child rows — `fk-sidenav-link`, section titles, custom markers
 - Token-driven spacing (`--fk-nav-group-row-gap`, `--fk-nav-group-children-gap`, `--fk-nav-group-children-indent`, `--fk-nav-group-children-offset`)
+- Section rule — a vertical line brackets the expanded children, flush-left under the icon/label, tokenized via `--fk-nav-group-children-border-{width,color,offset}` (removable)
+- Optional disclosure chevron (`showChevron`) — points right collapsed, rotates down when expanded; colour via `--fk-nav-group-chevron-color`
 
 ---
 
@@ -125,8 +129,23 @@ export class ExampleComponent {}
 --fk-nav-group-children-gap;
 --fk-nav-group-children-indent;
 --fk-nav-group-children-offset;
+--fk-nav-group-children-border-width;  // section rule width (default --fk-border-width / 1px)
+--fk-nav-group-children-border-color;  // section rule colour (default --fk-color-border)
+--fk-nav-group-children-border-offset; // section rule x-position (see below)
+--fk-nav-group-chevron-color;          // disclosure chevron colour (default --fk-color-muted)
 ```
 
+The expanded children column carries a quiet vertical **section rule** by
+default — a line that brackets the nested items, aligned flush-left with the
+trigger row's content-left edge (the icon when present, the label text
+otherwise — both start at the link's inline padding, so a single offset
+covers both, independent of icon size). The colour defaults to the semantic
+`--fk-color-border`, so the rule adapts to dark mode through the fallback
+chain with no dedicated dark token.
+
+Override `--fk-nav-group-children-border-offset` to pin the line elsewhere, or
+remove the rule by zeroing the width / making the colour transparent.
+
 Override in your app stylesheet:
 
 ```scss
@@ -134,6 +153,11 @@ Override in your app stylesheet:
   --fk-nav-group-children-indent: 1rem;
   --fk-nav-group-children-gap: var(--fk-rhythm-2);
 }
+
+// Remove the section rule for a particular scope:
+.flat-nav {
+  --fk-nav-group-children-border-width: 0;
+}
 ```
 
 ---
@@ -142,4 +166,5 @@ Override in your app stylesheet:
 
 - The built-in `toggle()` decides what happens to `expanded` on click: in rail mode it leaves `expanded` alone and only emits `requestOpen` (children must not render inside the rail); in expanded mode it flips `expanded` unless `lockedOpen` is `true`. Navigation via `routerLink` happens independently on the inner sidenav-link's anchor in both states. If you want custom behavior, listen to `(requestOpen)` and drive `[(expanded)]` yourself.
 - The trigger row composes `fk-sidenav-link` — you get the same active-route styling and keyboard semantics for free.
+- The section rule is an absolutely-positioned `::before` on the children column (not a `border-left`), so its x-position can anchor to the icon or text. It spans the full height of the children and sits behind them; child rows render normally on top. It only shows while the group is expanded (the children column isn't rendered otherwise).
 - No opinionated max-width — the trigger fills the row. Cap the width at the consumer level if you need it (e.g., docs shells clamp their top-level items to 18rem).

package/fesm2022/frame-kit-ui-ng-services-overlay-orchestrator.mjs

@@ -1,133 +0,0 @@
-import * as i0 from '@angular/core';
-import { signal, computed, Injectable } from '@angular/core';
-
-let nextOverlayId = 0;
-/**
- * Centralized overlay orchestrator.
- *
- * Tracks all open overlays (dialogs, drawers, popovers, navigation, tooltips)
- * in a priority-based stack. When a new overlay opens:
- *
- * - All overlays with LOWER priority are closed automatically.
- * - Overlays with EQUAL or HIGHER priority are left open.
- *
- * This prevents UI conflicts like drawers staying open behind dialogs,
- * or kebab menus persisting when a modal pops up.
- *
- * @example
- * ```ts
- * const id = orchestrator.register({
- *   priority: OVERLAY_PRIORITY.DRAWER,
- *   type: 'drawer',
- *   close: () => drawerRef.close(),
- * });
- *
- * // Later, when the overlay closes:
- * orchestrator.unregister(id);
- * ```
- */
-class OverlayOrchestrator {
-    entries = signal([], ...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
-    /** Whether any overlay is currently open. */
-    hasActiveOverlay = computed(() => this.entries().length > 0, ...(ngDevMode ? [{ debugName: "hasActiveOverlay" }] : /* istanbul ignore next */ []));
-    /** The topmost (highest priority) overlay. */
-    topOverlay = computed(() => {
-        const all = this.entries();
-        if (all.length === 0) {
-            return null;
-        }
-        return all.reduce((top, entry) => entry.priority >= top.priority ? entry : top);
-    }, ...(ngDevMode ? [{ debugName: "topOverlay" }] : /* istanbul ignore next */ []));
-    /** Current number of active overlays. */
-    count = computed(() => this.entries().length, ...(ngDevMode ? [{ debugName: "count" }] : /* istanbul ignore next */ []));
-    /**
-     * Register an overlay and close all overlays with lower priority.
-     *
-     * @returns The unique overlay ID — pass this to `unregister()` when closing.
-     */
-    register(entry) {
-        const id = `overlay-${nextOverlayId++}`;
-        // Close all overlays with strictly lower priority
-        const current = this.entries();
-        const toClose = current.filter((e) => e.priority < entry.priority);
-        for (const overlay of toClose) {
-            overlay.close();
-        }
-        // Remove closed overlays and add the new one
-        const remaining = current.filter((e) => e.priority >= entry.priority);
-        this.entries.set([...remaining, { ...entry, id }]);
-        return id;
-    }
-    /**
-     * Unregister an overlay by ID. Call this when the overlay closes.
-     */
-    unregister(id) {
-        this.entries.update((entries) => entries.filter((e) => e.id !== id));
-    }
-    /**
-     * Check if an overlay with the given priority or higher is currently open.
-     * Useful for guards that want to prevent opening lower-priority overlays.
-     */
-    hasOverlayAtOrAbove(priority) {
-        return this.entries().some((e) => e.priority >= priority);
-    }
-    /**
-     * Check if any overlay of a specific type is open.
-     */
-    hasOverlayOfType(type) {
-        return this.entries().some((e) => e.type === type);
-    }
-    /**
-     * Close all overlays. Closes from lowest to highest priority.
-     */
-    closeAll() {
-        const sorted = [...this.entries()].sort((a, b) => a.priority - b.priority);
-        for (const entry of sorted) {
-            entry.close();
-        }
-        this.entries.set([]);
-    }
-    /**
-     * Close all overlays at or below the given priority.
-     */
-    closeAtOrBelow(priority) {
-        const current = this.entries();
-        const toClose = current.filter((e) => e.priority <= priority);
-        for (const overlay of toClose) {
-            overlay.close();
-        }
-        this.entries.update((entries) => entries.filter((e) => e.priority > priority));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: OverlayOrchestrator, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: OverlayOrchestrator, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: OverlayOrchestrator, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-/**
- * Default priority levels for common overlay types.
- * Higher number = higher priority = stays open when lower-priority overlays open.
- *
- * Consumers can use any number — these are conventions, not constraints.
- */
-const OVERLAY_PRIORITY = {
-    /** Tooltips, inline popovers */
-    TOOLTIP: 0,
-    /** Dropdown menus, kebab menus, popovers */
-    POPOVER: 10,
-    /** Side panels, detail drawers */
-    DRAWER: 20,
-    /** Modal dialogs, confirmations */
-    DIALOG: 30,
-    /** App-level navigation (sidebar, mobile nav) */
-    NAVIGATION: 40,
-};
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { OVERLAY_PRIORITY, OverlayOrchestrator };
-//# sourceMappingURL=frame-kit-ui-ng-services-overlay-orchestrator.mjs.map

package/fesm2022/frame-kit-ui-ng-services-overlay-orchestrator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"frame-kit-ui-ng-services-overlay-orchestrator.mjs","sources":["../../../../packages/ui-ng/services/overlay-orchestrator/overlay-orchestrator.service.ts","../../../../packages/ui-ng/services/overlay-orchestrator/overlay-orchestrator.types.ts","../../../../packages/ui-ng/services/overlay-orchestrator/frame-kit-ui-ng-services-overlay-orchestrator.ts"],"sourcesContent":["import { computed, Injectable, signal } from '@angular/core';\n\nimport type { OverlayEntry } from './overlay-orchestrator.types';\n\nlet nextOverlayId = 0;\n\n/**\n * Centralized overlay orchestrator.\n *\n * Tracks all open overlays (dialogs, drawers, popovers, navigation, tooltips)\n * in a priority-based stack. When a new overlay opens:\n *\n * - All overlays with LOWER priority are closed automatically.\n * - Overlays with EQUAL or HIGHER priority are left open.\n *\n * This prevents UI conflicts like drawers staying open behind dialogs,\n * or kebab menus persisting when a modal pops up.\n *\n * @example\n * ```ts\n * const id = orchestrator.register({\n *   priority: OVERLAY_PRIORITY.DRAWER,\n *   type: 'drawer',\n *   close: () => drawerRef.close(),\n * });\n *\n * // Later, when the overlay closes:\n * orchestrator.unregister(id);\n * ```\n */\n@Injectable({ providedIn: 'root' })\nexport class OverlayOrchestrator {\n  private readonly entries = signal<OverlayEntry[]>([]);\n\n  /** Whether any overlay is currently open. */\n  readonly hasActiveOverlay = computed(() => this.entries().length > 0);\n\n  /** The topmost (highest priority) overlay. */\n  readonly topOverlay = computed<OverlayEntry | null>(() => {\n    const all = this.entries();\n\n    if (all.length === 0) {\n      return null;\n    }\n\n    return all.reduce((top, entry) =>\n      entry.priority >= top.priority ? entry : top,\n    );\n  });\n\n  /** Current number of active overlays. */\n  readonly count = computed(() => this.entries().length);\n\n  /**\n   * Register an overlay and close all overlays with lower priority.\n   *\n   * @returns The unique overlay ID — pass this to `unregister()` when closing.\n   */\n  register(entry: Omit<OverlayEntry, 'id'>): string {\n    const id = `overlay-${nextOverlayId++}`;\n\n    // Close all overlays with strictly lower priority\n    const current = this.entries();\n    const toClose = current.filter((e) => e.priority < entry.priority);\n\n    for (const overlay of toClose) {\n      overlay.close();\n    }\n\n    // Remove closed overlays and add the new one\n    const remaining = current.filter((e) => e.priority >= entry.priority);\n\n    this.entries.set([...remaining, { ...entry, id }]);\n\n    return id;\n  }\n\n  /**\n   * Unregister an overlay by ID. Call this when the overlay closes.\n   */\n  unregister(id: string): void {\n    this.entries.update((entries) => entries.filter((e) => e.id !== id));\n  }\n\n  /**\n   * Check if an overlay with the given priority or higher is currently open.\n   * Useful for guards that want to prevent opening lower-priority overlays.\n   */\n  hasOverlayAtOrAbove(priority: number): boolean {\n    return this.entries().some((e) => e.priority >= priority);\n  }\n\n  /**\n   * Check if any overlay of a specific type is open.\n   */\n  hasOverlayOfType(type: string): boolean {\n    return this.entries().some((e) => e.type === type);\n  }\n\n  /**\n   * Close all overlays. Closes from lowest to highest priority.\n   */\n  closeAll(): void {\n    const sorted = [...this.entries()].sort((a, b) => a.priority - b.priority);\n\n    for (const entry of sorted) {\n      entry.close();\n    }\n\n    this.entries.set([]);\n  }\n\n  /**\n   * Close all overlays at or below the given priority.\n   */\n  closeAtOrBelow(priority: number): void {\n    const current = this.entries();\n    const toClose = current.filter((e) => e.priority <= priority);\n\n    for (const overlay of toClose) {\n      overlay.close();\n    }\n\n    this.entries.update((entries) =>\n      entries.filter((e) => e.priority > priority),\n    );\n  }\n}\n","/**\n * Default priority levels for common overlay types.\n * Higher number = higher priority = stays open when lower-priority overlays open.\n *\n * Consumers can use any number — these are conventions, not constraints.\n */\nexport const OVERLAY_PRIORITY = {\n  /** Tooltips, inline popovers */\n  TOOLTIP: 0,\n\n  /** Dropdown menus, kebab menus, popovers */\n  POPOVER: 10,\n\n  /** Side panels, detail drawers */\n  DRAWER: 20,\n\n  /** Modal dialogs, confirmations */\n  DIALOG: 30,\n\n  /** App-level navigation (sidebar, mobile nav) */\n  NAVIGATION: 40,\n} as const;\n\nexport interface OverlayEntry {\n  /** Unique identifier for this overlay instance */\n  id: string;\n\n  /** Priority level — higher stays open, lower gets closed */\n  priority: number;\n\n  /** Overlay type label (for debugging/logging) */\n  type: string;\n\n  /** Called by the orchestrator to close this overlay */\n  close: () => void;\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/services/overlay-orchestrator/README.md

@@ -1,184 +0,0 @@
-# OverlayOrchestrator
-
-A centralized service for managing overlay interactions (dialogs, drawers, popovers, navigation panels, tooltips) using a priority-based stack. Prevents UI conflicts like drawers staying open behind dialogs, or menus persisting when modals appear.
-
----
-
-## Initialization
-
-The `OverlayOrchestrator` is provided at the root level (`providedIn: 'root'`). No setup is needed — inject it wherever you need overlay coordination.
-
-```ts
-import { OverlayOrchestrator, OVERLAY_PRIORITY } from '@frame-kit/ui-ng';
-```
-
-### Built-in Integration
-
-`DialogService` and `DrawerService` automatically register with the orchestrator. Opening a dialog auto-closes any open drawer or popover. Opening a drawer auto-closes any open popover. No consumer code is needed for these — it works out of the box.
-
-### Registering Custom Overlays
-
-For overlays not managed by `DialogService` or `DrawerService` (e.g., custom popovers, app navigation panels, kebab menus), register them manually:
-
-```ts
-@Component({ ... })
-export class MyComponent {
-  private readonly orchestrator = inject(OverlayOrchestrator);
-  private overlayId: string | null = null;
-
-  open(): void {
-    // Register with a priority — closes all lower-priority overlays
-    this.overlayId = this.orchestrator.register({
-      priority: OVERLAY_PRIORITY.POPOVER,
-      type: "my-popover",
-      close: () => this.close(),
-    });
-  }
-
-  close(): void {
-    if (this.overlayId) {
-      this.orchestrator.unregister(this.overlayId);
-      this.overlayId = null;
-    }
-
-    // ... your close logic
-  }
-}
-```
-
-### Registering App Navigation
-
-The app shell sidebar should register at the highest priority so it always opens on top:
-
-```ts
-@Component({ ... })
-export class AppShellComponent {
-  private readonly orchestrator = inject(OverlayOrchestrator);
-  private navOverlayId: string | null = null;
-
-  openNav(): void {
-    this.navOverlayId = this.orchestrator.register({
-      priority: OVERLAY_PRIORITY.NAVIGATION,
-      type: "navigation",
-      close: () => this.closeNav(),
-    });
-  }
-
-  closeNav(): void {
-    if (this.navOverlayId) {
-      this.orchestrator.unregister(this.navOverlayId);
-      this.navOverlayId = null;
-    }
-
-    // ... your close logic
-  }
-}
-```
-
-### Guarding Before Opening
-
-Check if a higher-priority overlay is already open before opening yours:
-
-```ts
-if (!this.orchestrator.hasOverlayAtOrAbove(OVERLAY_PRIORITY.DIALOG)) {
-  this.openDrawer();
-}
-```
-
----
-
-## API
-
-### OverlayOrchestrator (Injectable)
-
-#### Methods
-
-| Method                | Signature                                     | Description                                                                    |
-| --------------------- | --------------------------------------------- | ------------------------------------------------------------------------------ |
-| `register`            | `(entry: Omit<OverlayEntry, 'id'>) => string` | Register an overlay. Auto-closes lower-priority overlays. Returns a unique ID. |
-| `unregister`          | `(id: string) => void`                        | Remove an overlay by ID. Call when the overlay closes.                         |
-| `closeAll`            | `() => void`                                  | Close all overlays, lowest priority first.                                     |
-| `closeAtOrBelow`      | `(priority: number) => void`                  | Close all overlays at or below the given priority.                             |
-| `hasOverlayAtOrAbove` | `(priority: number) => boolean`               | Check if any overlay at or above a priority is open.                           |
-| `hasOverlayOfType`    | `(type: string) => boolean`                   | Check if any overlay of a given type is open.                                  |
-
-#### Signals (Reactive)
-
-| Signal             | Type                           | Description                        |
-| ------------------ | ------------------------------ | ---------------------------------- |
-| `hasActiveOverlay` | `Signal<boolean>`              | Whether any overlay is open.       |
-| `topOverlay`       | `Signal<OverlayEntry \| null>` | The highest-priority open overlay. |
-| `count`            | `Signal<number>`               | Number of active overlays.         |
-
----
-
-## Priority Levels
-
-Default priority constants are provided via `OVERLAY_PRIORITY`. You can use any number — these are conventions, not constraints.
-
-```ts
-import { OVERLAY_PRIORITY } from '@frame-kit/ui-ng';
-
-OVERLAY_PRIORITY.TOOLTIP; // 0  — tooltips, inline hints
-OVERLAY_PRIORITY.POPOVER; // 10 — dropdown menus, kebab menus
-OVERLAY_PRIORITY.DRAWER; // 20 — side panels, detail drawers
-OVERLAY_PRIORITY.DIALOG; // 30 — modal dialogs, confirmations
-OVERLAY_PRIORITY.NAVIGATION; // 40 — app-level navigation sidebar
-```
-
-### Custom Priorities
-
-Use any number to fine-tune behavior:
-
-```ts
-// A toast notification that sits between popover and drawer
-orchestrator.register({
-  priority: 15,
-  type: 'toast',
-  close: () => this.dismissToast(),
-});
-```
-
----
-
-## OverlayEntry Interface
-
-```ts
-interface OverlayEntry {
-  id: string; // Auto-generated unique ID
-  priority: number; // Higher = stays open longer
-  type: string; // Label for debugging/querying
-  close: () => void; // Called by orchestrator to close
-}
-```
-
----
-
-## Behavior Rules
-
-1. **Opening a new overlay closes all overlays with LOWER priority.**
-   - Opening a dialog (30) closes drawers (20), popovers (10), tooltips (0).
-   - Opening a drawer (20) closes popovers (10) and tooltips (0).
-   - Opening the nav (40) does not close dialogs (30) — they have lower priority.
-
-2. **Overlays with EQUAL or HIGHER priority are left open.**
-   - Opening a second dialog does not close the first dialog.
-   - Opening the nav while a dialog is open leaves the dialog open.
-
-3. **Unregistration is the consumer's responsibility.**
-   - The orchestrator calls `close()` on entries to request closure.
-   - The consumer must call `unregister(id)` when the overlay actually closes.
-   - `DialogService` and `DrawerService` handle this automatically.
-
-4. **Priority is set per instance, not per type.**
-   - The same component can register at different priorities depending on context.
-   - A critical confirmation dialog could register at 35 to stay above normal dialogs.
-
----
-
-## Import
-
-```ts
-import { OverlayOrchestrator, OVERLAY_PRIORITY } from '@frame-kit/ui-ng';
-import type { OverlayEntry } from '@frame-kit/ui-ng';
-```

package/types/frame-kit-ui-ng-services-overlay-orchestrator.d.ts

@@ -1,96 +0,0 @@
-import * as _angular_core from '@angular/core';
-
-/**
- * Default priority levels for common overlay types.
- * Higher number = higher priority = stays open when lower-priority overlays open.
- *
- * Consumers can use any number — these are conventions, not constraints.
- */
-declare const OVERLAY_PRIORITY: {
-    /** Tooltips, inline popovers */
-    readonly TOOLTIP: 0;
-    /** Dropdown menus, kebab menus, popovers */
-    readonly POPOVER: 10;
-    /** Side panels, detail drawers */
-    readonly DRAWER: 20;
-    /** Modal dialogs, confirmations */
-    readonly DIALOG: 30;
-    /** App-level navigation (sidebar, mobile nav) */
-    readonly NAVIGATION: 40;
-};
-interface OverlayEntry {
-    /** Unique identifier for this overlay instance */
-    id: string;
-    /** Priority level — higher stays open, lower gets closed */
-    priority: number;
-    /** Overlay type label (for debugging/logging) */
-    type: string;
-    /** Called by the orchestrator to close this overlay */
-    close: () => void;
-}
-
-/**
- * Centralized overlay orchestrator.
- *
- * Tracks all open overlays (dialogs, drawers, popovers, navigation, tooltips)
- * in a priority-based stack. When a new overlay opens:
- *
- * - All overlays with LOWER priority are closed automatically.
- * - Overlays with EQUAL or HIGHER priority are left open.
- *
- * This prevents UI conflicts like drawers staying open behind dialogs,
- * or kebab menus persisting when a modal pops up.
- *
- * @example
- * ```ts
- * const id = orchestrator.register({
- *   priority: OVERLAY_PRIORITY.DRAWER,
- *   type: 'drawer',
- *   close: () => drawerRef.close(),
- * });
- *
- * // Later, when the overlay closes:
- * orchestrator.unregister(id);
- * ```
- */
-declare class OverlayOrchestrator {
-    private readonly entries;
-    /** Whether any overlay is currently open. */
-    readonly hasActiveOverlay: _angular_core.Signal<boolean>;
-    /** The topmost (highest priority) overlay. */
-    readonly topOverlay: _angular_core.Signal<OverlayEntry | null>;
-    /** Current number of active overlays. */
-    readonly count: _angular_core.Signal<number>;
-    /**
-     * Register an overlay and close all overlays with lower priority.
-     *
-     * @returns The unique overlay ID — pass this to `unregister()` when closing.
-     */
-    register(entry: Omit<OverlayEntry, 'id'>): string;
-    /**
-     * Unregister an overlay by ID. Call this when the overlay closes.
-     */
-    unregister(id: string): void;
-    /**
-     * Check if an overlay with the given priority or higher is currently open.
-     * Useful for guards that want to prevent opening lower-priority overlays.
-     */
-    hasOverlayAtOrAbove(priority: number): boolean;
-    /**
-     * Check if any overlay of a specific type is open.
-     */
-    hasOverlayOfType(type: string): boolean;
-    /**
-     * Close all overlays. Closes from lowest to highest priority.
-     */
-    closeAll(): void;
-    /**
-     * Close all overlays at or below the given priority.
-     */
-    closeAtOrBelow(priority: number): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OverlayOrchestrator, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OverlayOrchestrator>;
-}
-
-export { OVERLAY_PRIORITY, OverlayOrchestrator };
-export type { OverlayEntry };