@mono-lit/helper 0.0.1 → 0.0.3

package/dist/src/components/menu/menu-types.d.ts

@@ -1,3 +1,4 @@
+//#region src/components/menu/menu-types.d.ts
 /**
  * Menu (recursive nav list) Component Type Definitions
  */
@@ -24,112 +25,112 @@ export type MenuBadgeColor = 'default' | 'primary' | 'success' | 'danger' | 'war
  * - `'subheader'` — small label heading for the section beneath.
  */
 export interface MenuItemBase {
-    id: string;
-    type?: 'item' | 'group' | 'divider' | 'subheader';
-    title?: string;
-    subtitle?: string;
-    icon?: string;
-    appendIcon?: string;
-    badge?: string | number;
-    badgeColor?: MenuBadgeColor;
-    href?: string;
-    disabled?: boolean;
-    /**
-     * Nested menu rows.
-     * Used by both normal items and group items.
-     */
-    items?: MenuItem[];
-    /** Group items only — initial expansion state. */
-    defaultOpen?: boolean;
+  id: string;
+  type?: 'item' | 'group' | 'divider' | 'subheader';
+  title?: string;
+  subtitle?: string;
+  icon?: string;
+  appendIcon?: string;
+  badge?: string | number;
+  badgeColor?: MenuBadgeColor;
+  href?: string;
+  disabled?: boolean;
+  /**
+   * Nested menu rows.
+   * Used by both normal items and group items.
+   */
+  items?: MenuItem[];
+  /** Group items only — initial expansion state. */
+  defaultOpen?: boolean;
 }
 export type MenuItem = MenuItemBase;
 export interface MenuCssClass {
-    root?: string;
-    list?: string;
-    item?: string;
-    itemActive?: string;
-    itemDisabled?: string;
-    action?: string;
-    icon?: string;
-    appendIcon?: string;
-    content?: string;
-    title?: string;
-    subtitle?: string;
-    badge?: string;
-    group?: string;
-    groupHeader?: string;
-    groupBody?: string;
-    groupChevron?: string;
-    divider?: string;
-    subheader?: string;
+  root?: string;
+  list?: string;
+  item?: string;
+  itemActive?: string;
+  itemDisabled?: string;
+  action?: string;
+  icon?: string;
+  appendIcon?: string;
+  content?: string;
+  title?: string;
+  subtitle?: string;
+  badge?: string;
+  group?: string;
+  groupHeader?: string;
+  groupBody?: string;
+  groupChevron?: string;
+  divider?: string;
+  subheader?: string;
 }
 export type MenuChangeEventDetail = {
-    modelValue: string | string[];
-    oldValue: string | string[];
-    value: string;
-    item: MenuItem;
-    selected: boolean;
-    sourceEvent?: Event;
+  modelValue: string | string[];
+  oldValue: string | string[];
+  value: string;
+  item: MenuItem;
+  selected: boolean;
+  sourceEvent?: Event;
 };
 export type MenuChangeEvent = CustomEvent<MenuChangeEventDetail>;
 export type MenuClickEventDetail = {
-    value: string;
-    item: MenuItem;
-    sourceEvent?: Event;
+  value: string;
+  item: MenuItem;
+  sourceEvent?: Event;
 };
 export type MenuClickEvent = CustomEvent<MenuClickEventDetail>;
 export type MenuToggleGroupEventDetail = {
-    groupId: string;
-    open: boolean;
-    oldOpen: boolean;
-    group: MenuItem;
-    sourceEvent?: Event;
+  groupId: string;
+  open: boolean;
+  oldOpen: boolean;
+  group: MenuItem;
+  sourceEvent?: Event;
 };
 export type MenuToggleGroupEvent = CustomEvent<MenuToggleGroupEventDetail>;
 export interface MenuProps {
-    /** Menu items rendered as a recursive list. */
-    items?: MenuItem[];
-    /** Selected item id, or array of ids when multiple. */
-    modelValue?: string | string[];
-    'model-value'?: string | string[];
-    modelvalue?: string | string[];
-    /** Allows selecting multiple items at once. */
-    multiple?: boolean;
-    /** Vertical spacing density of menu rows. */
-    density?: MenuDensity;
-    /** Theme color applied to active and accent states. */
-    color?: MenuColor;
-    /** Renders rows as navigation links. */
-    nav?: boolean;
-    /** Enables item selection and listbox semantics. */
-    selectable?: boolean;
-    /** Disables interaction across the whole menu. */
-    disabled?: boolean;
-    /**
-     * Controlled mode — the parent owns `modelValue` (e.g. bound to the current
-     * route). Clicks emit `click` but the highlight doesn't move until
-     * `modelValue` updates. Use with Vue Router so the active item can't jump
-     * ahead of an async navigation.
-     */
-    controlled?: boolean;
-    /** Per-part class overrides for internal elements. */
-    cssClass?: MenuCssClass;
-    cssclass?: MenuCssClass;
-    'css-class'?: MenuCssClass | string;
-    /** Plain root class string applied to the menu. */
-    cssClassName?: string;
+  /** Menu items rendered as a recursive list. */
+  items?: MenuItem[];
+  /** Selected item id, or array of ids when multiple. */
+  modelValue?: string | string[];
+  'model-value'?: string | string[];
+  modelvalue?: string | string[];
+  /** Allows selecting multiple items at once. */
+  multiple?: boolean;
+  /** Vertical spacing density of menu rows. */
+  density?: MenuDensity;
+  /** Theme color applied to active and accent states. */
+  color?: MenuColor;
+  /** Renders rows as navigation links. */
+  nav?: boolean;
+  /** Enables item selection and listbox semantics. */
+  selectable?: boolean;
+  /** Disables interaction across the whole menu. */
+  disabled?: boolean;
+  /**
+   * Controlled mode — the parent owns `modelValue` (e.g. bound to the current
+   * route). Clicks emit `click` but the highlight doesn't move until
+   * `modelValue` updates. Use with Vue Router so the active item can't jump
+   * ahead of an async navigation.
+   */
+  controlled?: boolean;
+  /** Per-part class overrides for internal elements. */
+  cssClass?: MenuCssClass;
+  cssclass?: MenuCssClass;
+  'css-class'?: MenuCssClass | string;
+  /** Plain root class string applied to the menu. */
+  cssClassName?: string;
 }
 export interface MenuEvents {
-    change: MenuChangeEvent;
-    click: MenuClickEvent;
-    'toggle-group': MenuToggleGroupEvent;
-    toggleGroup: MenuToggleGroupEvent;
-    'mno-change': MenuChangeEvent;
-    mnoChange: MenuChangeEvent;
-    'mno-click': MenuClickEvent;
-    mnoClick: MenuClickEvent;
-    'mno-toggle-group': MenuToggleGroupEvent;
-    mnoToggleGroup: MenuToggleGroupEvent;
+  change: MenuChangeEvent;
+  click: MenuClickEvent;
+  'toggle-group': MenuToggleGroupEvent;
+  toggleGroup: MenuToggleGroupEvent;
+  'mno-change': MenuChangeEvent;
+  mnoChange: MenuChangeEvent;
+  'mno-click': MenuClickEvent;
+  mnoClick: MenuClickEvent;
+  'mno-toggle-group': MenuToggleGroupEvent;
+  mnoToggleGroup: MenuToggleGroupEvent;
 }
 /**
  * `<mono-menu-list>` `type` semantics:
@@ -152,44 +153,45 @@ export interface MenuEvents {
  */
 export type MonoMenuListType = 'children' | 'item' | 'group' | 'divider' | 'subheader';
 export interface MenuListProps {
-    /**
-     * In list mode:
-     *   <mono-menu-list :items.prop="items" />
-     *
-     * In direct single-row mode:
-     *   <mono-menu-list type="group" title="Sales" :items.prop="children" />
-     * Here, `items` becomes the built item's `children`.
-     *
-     * In declarative mode, child `<mono-menu-list>` elements (or any other HTML)
-     * compose the row's body — arbitrary depth supported.
-     */
-    items?: MenuItem[];
-    /** Render one full item object, useful with Vue `v-for`. */
-    item?: MenuItem;
-    /** Render mode, or the synthesised item's type in direct mode. */
-    type?: MonoMenuListType;
-    /** Direct single-row props. `item-type` is a legacy alias for `type` in declarative mode. */
-    itemType?: MenuItem['type'];
-    'item-type'?: MenuItem['type'];
-    /** Row title text. */
-    title?: string;
-    /** Secondary text shown beneath the title. */
-    subtitle?: string;
-    /** Leading icon shown before the title. */
-    icon?: string;
-    /** Trailing icon shown after the title. */
-    appendIcon?: string;
-    'append-icon'?: string;
-    /** Badge content shown on the row. */
-    badge?: string | number;
-    /** Color theme of the badge. */
-    badgeColor?: MenuBadgeColor;
-    'badge-color'?: MenuBadgeColor;
-    /** Link target for navigation rows. */
-    href?: string;
-    /** Disables interaction with the row. */
-    disabled?: boolean;
-    /** Initial expansion state for group rows. */
-    defaultOpen?: boolean;
-    'default-open'?: boolean;
+  /**
+   * In list mode:
+   *   <mono-menu-list :items.prop="items" />
+   *
+   * In direct single-row mode:
+   *   <mono-menu-list type="group" title="Sales" :items.prop="children" />
+   * Here, `items` becomes the built item's `children`.
+   *
+   * In declarative mode, child `<mono-menu-list>` elements (or any other HTML)
+   * compose the row's body — arbitrary depth supported.
+   */
+  items?: MenuItem[];
+  /** Render one full item object, useful with Vue `v-for`. */
+  item?: MenuItem;
+  /** Render mode, or the synthesised item's type in direct mode. */
+  type?: MonoMenuListType;
+  /** Direct single-row props. `item-type` is a legacy alias for `type` in declarative mode. */
+  itemType?: MenuItem['type'];
+  'item-type'?: MenuItem['type'];
+  /** Row title text. */
+  title?: string;
+  /** Secondary text shown beneath the title. */
+  subtitle?: string;
+  /** Leading icon shown before the title. */
+  icon?: string;
+  /** Trailing icon shown after the title. */
+  appendIcon?: string;
+  'append-icon'?: string;
+  /** Badge content shown on the row. */
+  badge?: string | number;
+  /** Color theme of the badge. */
+  badgeColor?: MenuBadgeColor;
+  'badge-color'?: MenuBadgeColor;
+  /** Link target for navigation rows. */
+  href?: string;
+  /** Disables interaction with the row. */
+  disabled?: boolean;
+  /** Initial expansion state for group rows. */
+  defaultOpen?: boolean;
+  'default-open'?: boolean;
 }
+//#endregion

package/dist/src/components/menu/menu-utils.d.ts

@@ -1,5 +1,6 @@
-import { MenuItem, MenuProps } from './menu-types.js';
-export { isIconifyClass } from '../../composables/icon.js';
+import { isIconifyClass } from "../../composables/icon.js";
+import { MenuItem, MenuProps } from "./menu-types.js";
+//#region src/components/menu/menu-utils.d.ts
 export declare function isItem(node: MenuItem): boolean;
 export declare function isGroup(node: MenuItem): boolean;
 export declare function isDivider(node: MenuItem): boolean;
@@ -26,13 +27,13 @@ export declare function findItem(items: MenuItem[], id: string): MenuItem | null
 export declare function getMenuAlias(input: string | undefined | null, max?: number): string;
 export declare function collectDefaultOpenGroups(items: MenuItem[]): string[];
 export declare function generateMenuRootClasses(props: {
-    density: string;
-    color: string;
-    nav: boolean;
-    selectable: boolean;
-    disabled: boolean;
-    cssClassName?: string;
-    rootExtra?: string;
+  density: string;
+  color: string;
+  nav: boolean;
+  selectable: boolean;
+  disabled: boolean;
+  cssClassName?: string;
+  rootExtra?: string;
 }): string;
 export declare function validateMenuProps(props: MenuProps): string[];
 /**
@@ -45,9 +46,11 @@ export declare function validateMenuProps(props: MenuProps): string[];
  * cannot drift apart.
  */
 export declare function menuRootAttrs(props: {
-    density: string;
-    color: string;
+  density: string;
+  color: string;
 }): {
-    density: string | null;
-    color: string | null;
+  density: string | null;
+  color: string | null;
 };
+//#endregion
+export { isIconifyClass };

package/dist/src/components/menu/mono-menu-list.d.ts

@@ -1,118 +1,120 @@
-import { LitElement, TemplateResult } from 'lit';
-import { MenuItem, MenuBadgeColor, MonoMenuListType } from './menu-types.js';
+import { MenuBadgeColor, MenuItem, MonoMenuListType } from "./menu-types.js";
+import { LitElement, TemplateResult } from "lit";
+//#region src/components/menu/mono-menu-list.d.ts
 export declare class MonoMenuList extends LitElement {
-    protected createRenderRoot(): HTMLElement;
-    /**
-     * For normal list mode:
-     *   <mono-menu-list :items.prop="items" />
-     *
-     * For direct single-row mode (one row built from element props):
-     *   <mono-menu-list type="group" title="Sales" :items.prop="children" />
-     *
-     * For declarative composition (any depth, any HTML inside):
-     *   <mono-menu-list type="group" title="Group">
-     *     <mono-menu-list type="children" title="Item A"></mono-menu-list>
-     *     <mono-menu-list type="group" title="Subgroup">…</mono-menu-list>
-     *   </mono-menu-list>
-     *
-     * In single-row mode, this `items` array becomes the built item's `children`.
-     */
-    items: MenuItem[];
-    /** New behavior: render exactly one menu row from a full object. */
-    item?: MenuItem;
-    /** Render mode / declarative MenuItem.type — see header doc. */
-    type: MonoMenuListType;
-    /** Direct single-row props. Legacy alias for `type` in declarative mode. */
-    itemType?: MenuItem['type'];
-    title: string;
-    subtitle: string;
-    icon: string;
-    appendIcon: string;
-    badge?: string | number;
-    badgeColor?: MenuBadgeColor;
-    href: string;
-    disabled: boolean;
-    defaultOpen: boolean;
-    private _parent;
-    private _parentList;
-    private _rootList;
-    private _nestedChildren;
-    /** Captured DOM children, re-placed into [data-mono-slot="body"] after render. */
-    private _capturedChildren;
-    /** Idempotency guard — initial capture must run once per element lifetime,
-     *  not again on reconnect (otherwise Lit's marker comments get hijacked). */
-    private _childrenCaptured;
-    /** Standalone group-open state — only honored on the root-most list. */
-    private _standaloneOpen;
-    private _childObserver;
-    private readonly _autoId;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    willUpdate(changed: Map<PropertyKey, unknown>): void;
-    protected updated(_changed: Map<PropertyKey, unknown>): void;
-    getMenuItems(): MenuItem[];
-    /** @internal called by a nested `<mono-menu-list>` from its connectedCallback. */
-    _registerNestedChild(child: MonoMenuList): void;
-    /** @internal */
-    _unregisterNestedChild(child: MonoMenuList): void;
-    /** Standalone (no `<mono-menu>`) group-open queries — root-most list owns the set. */
-    isGroupOpenStandalone(id: string): boolean;
-    /** Seed a default-open id into the standalone state set. */
-    seedStandaloneOpen(id: string): void;
-    toggleGroupStandalone(id: string): void;
-    private _findRootList;
-    private _captureInitialChildren;
-    /**
-     * Capture external Element children that landed on the host AFTER Lit's
-     * most recent render — typically because a framework (Vue/React) inserted
-     * nodes via `v-for`, `v-if`, etc. We deliberately skip non-Element nodes
-     * (text / comment) because Lit places its own marker comments around the
-     * rendered region and stealing those breaks the part graph.
-     */
-    private _captureExternalSiblings;
-    private _setupChildObserver;
-    private _placeBodySlot;
-    private _hasCapturedChildren;
-    private _hasDirectItemProps;
-    /**
-     * Declarative mode: `type` describes MenuItem.type and the body is composed
-     * from captured DOM children instead of `items`.
-     *
-     * The order of the checks is the contract. Captured children win outright —
-     * they ARE the body. An explicit `items` array comes next, and specifically
-     * BEATS direct props: the previous order returned `true` as soon as any direct
-     * prop was set, so `<mono-menu-list type="group" title="Sales" :items.prop="kids">`
-     * — the single-row form documented in the class header and in `MenuListProps` —
-     * landed in declarative mode. `_buildDeclarativeItem()` drops `items` on
-     * purpose, so that row rendered an empty `[data-mono-slot="body"]` nothing was
-     * ever placed into, and `_buildDirectItem()` (the one branch that does carry
-     * `items`) was unreachable.
-     *
-     * It doubles as a safety net for the element form: a group whose DOM children
-     * never made it into `_capturedChildren` now falls back to its `items` array
-     * rather than rendering a chevron over an empty body.
-     */
-    private _isDeclarativeMode;
-    private _typeAsMenuItemType;
-    private _normalizeItem;
-    private _buildDirectItem;
-    private _buildDeclarativeItem;
-    private _getEffectiveItems;
-    private _seedDefaultOpenIntoParent;
-    /**
-     * A group is "active" while any descendant row is the selected one.
-     * `renderMenuGroup` puts `.mono-menu-group.active` on such a header and
-     * menu.css already styles it — the class simply never appeared, because
-     * nothing supplied this callback.
-     */
-    private _hasSelectedDescendant;
-    private _buildContext;
-    private _renderSingleRow;
-    private _seedDefaultOpenIntoStandalone;
-    protected render(): TemplateResult;
+  protected createRenderRoot(): HTMLElement;
+  /**
+   * For normal list mode:
+   *   <mono-menu-list :items.prop="items" />
+   *
+   * For direct single-row mode (one row built from element props):
+   *   <mono-menu-list type="group" title="Sales" :items.prop="children" />
+   *
+   * For declarative composition (any depth, any HTML inside):
+   *   <mono-menu-list type="group" title="Group">
+   *     <mono-menu-list type="children" title="Item A"></mono-menu-list>
+   *     <mono-menu-list type="group" title="Subgroup">…</mono-menu-list>
+   *   </mono-menu-list>
+   *
+   * In single-row mode, this `items` array becomes the built item's `children`.
+   */
+  items: MenuItem[];
+  /** New behavior: render exactly one menu row from a full object. */
+  item?: MenuItem;
+  /** Render mode / declarative MenuItem.type — see header doc. */
+  type: MonoMenuListType;
+  /** Direct single-row props. Legacy alias for `type` in declarative mode. */
+  itemType?: MenuItem['type'];
+  title: string;
+  subtitle: string;
+  icon: string;
+  appendIcon: string;
+  badge?: string | number;
+  badgeColor?: MenuBadgeColor;
+  href: string;
+  disabled: boolean;
+  defaultOpen: boolean;
+  private _parent;
+  private _parentList;
+  private _rootList;
+  private _nestedChildren;
+  /** Captured DOM children, re-placed into [data-mono-slot="body"] after render. */
+  private _capturedChildren;
+  /** Idempotency guard — initial capture must run once per element lifetime,
+   *  not again on reconnect (otherwise Lit's marker comments get hijacked). */
+  private _childrenCaptured;
+  /** Standalone group-open state — only honored on the root-most list. */
+  private _standaloneOpen;
+  private _childObserver;
+  private readonly _autoId;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  willUpdate(changed: Map<PropertyKey, unknown>): void;
+  protected updated(_changed: Map<PropertyKey, unknown>): void;
+  getMenuItems(): MenuItem[];
+  /** @internal called by a nested `<mono-menu-list>` from its connectedCallback. */
+  _registerNestedChild(child: MonoMenuList): void;
+  /** @internal */
+  _unregisterNestedChild(child: MonoMenuList): void;
+  /** Standalone (no `<mono-menu>`) group-open queries — root-most list owns the set. */
+  isGroupOpenStandalone(id: string): boolean;
+  /** Seed a default-open id into the standalone state set. */
+  seedStandaloneOpen(id: string): void;
+  toggleGroupStandalone(id: string): void;
+  private _findRootList;
+  private _captureInitialChildren;
+  /**
+   * Capture external Element children that landed on the host AFTER Lit's
+   * most recent render — typically because a framework (Vue/React) inserted
+   * nodes via `v-for`, `v-if`, etc. We deliberately skip non-Element nodes
+   * (text / comment) because Lit places its own marker comments around the
+   * rendered region and stealing those breaks the part graph.
+   */
+  private _captureExternalSiblings;
+  private _setupChildObserver;
+  private _placeBodySlot;
+  private _hasCapturedChildren;
+  private _hasDirectItemProps;
+  /**
+   * Declarative mode: `type` describes MenuItem.type and the body is composed
+   * from captured DOM children instead of `items`.
+   *
+   * The order of the checks is the contract. Captured children win outright —
+   * they ARE the body. An explicit `items` array comes next, and specifically
+   * BEATS direct props: the previous order returned `true` as soon as any direct
+   * prop was set, so `<mono-menu-list type="group" title="Sales" :items.prop="kids">`
+   * — the single-row form documented in the class header and in `MenuListProps` —
+   * landed in declarative mode. `_buildDeclarativeItem()` drops `items` on
+   * purpose, so that row rendered an empty `[data-mono-slot="body"]` nothing was
+   * ever placed into, and `_buildDirectItem()` (the one branch that does carry
+   * `items`) was unreachable.
+   *
+   * It doubles as a safety net for the element form: a group whose DOM children
+   * never made it into `_capturedChildren` now falls back to its `items` array
+   * rather than rendering a chevron over an empty body.
+   */
+  private _isDeclarativeMode;
+  private _typeAsMenuItemType;
+  private _normalizeItem;
+  private _buildDirectItem;
+  private _buildDeclarativeItem;
+  private _getEffectiveItems;
+  private _seedDefaultOpenIntoParent;
+  /**
+   * A group is "active" while any descendant row is the selected one.
+   * `renderMenuGroup` puts `.mono-menu-group.active` on such a header and
+   * menu.css already styles it — the class simply never appeared, because
+   * nothing supplied this callback.
+   */
+  private _hasSelectedDescendant;
+  private _buildContext;
+  private _renderSingleRow;
+  private _seedDefaultOpenIntoStandalone;
+  protected render(): TemplateResult;
 }
 declare global {
-    interface HTMLElementTagNameMap {
-        'mono-menu-list': MonoMenuList;
-    }
+  interface HTMLElementTagNameMap {
+    'mono-menu-list': MonoMenuList;
+  }
 }
+//#endregion

package/dist/src/components/menu/mono-menu.d.ts

@@ -1,5 +1,8 @@
-import { LitElement, TemplateResult } from 'lit';
-declare const MonoMenu_base: import('../../composables/hybird-prop').Constructor<import('./menu-core.js').MonoMenuCoreInterface> & typeof LitElement;
+import { Constructor } from "../../composables/hybird-prop.js";
+import { MonoMenuCoreInterface } from "./menu-core.js";
+import { LitElement, TemplateResult } from "lit";
+//#region src/components/menu/mono-menu.d.ts
+declare const MonoMenu_base: Constructor<MonoMenuCoreInterface> & typeof LitElement;
 /**
  * Light-DOM `mono-menu` (`@mono-lit/helper/ui/menu`).
  *
@@ -10,30 +13,31 @@ declare const MonoMenu_base: import('../../composables/hybird-prop').Constructor
  * lives in `MonoMenuCore`.
  */
 export declare class MonoMenu extends MonoMenu_base {
-    static styles: import('lit').CSSResult[];
-    protected createRenderRoot(): HTMLElement;
-    private _slotsCaptured;
-    private _hasBodySlot;
-    /** Captured nodes for the whole-body slot — `slot="body"`. */
-    private _slotBody;
-    private _orphanHolder?;
-    connectedCallback(): void;
-    private _captureSlots;
-    protected updated(changed: Map<string, unknown>): void;
-    private _placeIconSlots;
-    private _placeBodySlot;
-    /**
-     * When any prop that influences the rendered content of descendant
-     * `<mono-menu-list>` instances changes, ask each registered child to
-     * re-render so they stay in lockstep with the parent.
-     */
-    private _notifyListChildren;
-    /** Light body — declarative `slot="body"` placeholder, else items-driven. */
-    protected _renderBody(): TemplateResult;
+  static styles: import("lit").CSSResult[];
+  protected createRenderRoot(): HTMLElement;
+  private _slotsCaptured;
+  private _hasBodySlot;
+  /** Captured nodes for the whole-body slot — `slot="body"`. */
+  private _slotBody;
+  private _orphanHolder?;
+  connectedCallback(): void;
+  private _captureSlots;
+  protected updated(changed: Map<string, unknown>): void;
+  private _placeIconSlots;
+  private _placeBodySlot;
+  /**
+   * When any prop that influences the rendered content of descendant
+   * `<mono-menu-list>` instances changes, ask each registered child to
+   * re-render so they stay in lockstep with the parent.
+   */
+  private _notifyListChildren;
+  /** Light body — declarative `slot="body"` placeholder, else items-driven. */
+  protected _renderBody(): TemplateResult;
 }
 declare global {
-    interface HTMLElementTagNameMap {
-        'mono-menu': MonoMenu;
-    }
+  interface HTMLElementTagNameMap {
+    'mono-menu': MonoMenu;
+  }
 }
-export {};
+//#endregion
+export {};