@mono-lit/helper 0.0.1 → 0.0.3

package/dist/src/components/button/index.shadow.d.ts

@@ -1,5 +1,6 @@
 /// <reference path="../../../vue.d.ts" />
-export { MonoButtonShadow } from './mono-button.shadow.js';
-export { MonoButtonCore } from './button-core.js';
-export type { ButtonSize, ButtonColor, ButtonVariant, ButtonRounded, ButtonIconPosition, ButtonBadgeColor, ButtonProps, ButtonAffixProps, ButtonEvents, IconProps, } from './button-types.js';
-export { generateBadgeClasses, processIconContent, validateButtonProps, } from './button-utils.js';
+import { ButtonAffixProps, ButtonBadgeColor, ButtonColor, ButtonEvents, ButtonIconPosition, ButtonProps, ButtonRounded, ButtonSize, ButtonVariant, IconProps } from "./button-types.js";
+import { MonoButtonCore } from "./button-core.js";
+import { generateBadgeClasses, processIconContent, validateButtonProps } from "./button-utils.js";
+import { MonoButtonShadow } from "./mono-button.shadow.js";
+export { type ButtonAffixProps, type ButtonBadgeColor, type ButtonColor, type ButtonEvents, type ButtonIconPosition, type ButtonProps, type ButtonRounded, type ButtonSize, type ButtonVariant, type IconProps, MonoButtonCore, MonoButtonShadow, generateBadgeClasses, processIconContent, validateButtonProps };

package/dist/src/components/button/mono-button-dropdown.d.ts

@@ -1,5 +1,9 @@
-import { LitElement, TemplateResult } from 'lit';
-declare const MonoButtonDropdown_base: import('../../composables/hybird-prop').Constructor<import('./button-dropdown-core.js').MonoButtonDropdownCoreInterface> & typeof LitElement;
+import { Constructor } from "../../composables/hybird-prop.js";
+import { MonoButtonDropdownCoreInterface } from "./button-dropdown-core.js";
+import "./mono-button.js";
+import { LitElement, TemplateResult } from "lit";
+//#region src/components/button/mono-button-dropdown.d.ts
+declare const MonoButtonDropdown_base: Constructor<MonoButtonDropdownCoreInterface> & typeof LitElement;
 /**
  * Light-DOM `mono-button-dropdown` (default build,
  * `@mono-lit/helper/ui/button-dropdown`).
@@ -13,23 +17,24 @@ declare const MonoButtonDropdown_base: import('../../composables/hybird-prop').C
  * build shares it and only swaps the embedded button's tag.
  */
 export declare class MonoButtonDropdown extends MonoButtonDropdown_base {
-    static styles: import('lit').CSSResult[];
-    protected createRenderRoot(): HTMLElement;
-    /**
-     * The panel is a STATIC element here, not something a helper returns.
-     *
-     * `PopupPortalController` moves it into a `<body>` portal on open and never
-     * moves it back. A node produced inside a `${}` expression sits in a
-     * `ChildPart` range, and ejecting it from that range breaks Lit on the next
-     * render ("this `ChildPart` has no `parentNode`"). As a fixed template node it
-     * has no range to leave — which is exactly why `mono-dropdown` is shaped this
-     * way too.
-     */
-    protected render(): TemplateResult;
+  static styles: import("lit").CSSResult[];
+  protected createRenderRoot(): HTMLElement;
+  /**
+   * The panel is a STATIC element here, not something a helper returns.
+   *
+   * `PopupPortalController` moves it into a `<body>` portal on open and never
+   * moves it back. A node produced inside a `${}` expression sits in a
+   * `ChildPart` range, and ejecting it from that range breaks Lit on the next
+   * render ("this `ChildPart` has no `parentNode`"). As a fixed template node it
+   * has no range to leave — which is exactly why `mono-dropdown` is shaped this
+   * way too.
+   */
+  protected render(): TemplateResult;
 }
 declare global {
-    interface HTMLElementTagNameMap {
-        'mono-button-dropdown': MonoButtonDropdown;
-    }
+  interface HTMLElementTagNameMap {
+    'mono-button-dropdown': MonoButtonDropdown;
+  }
 }
-export {};
+//#endregion
+export {};

package/dist/src/components/button/mono-button-dropdown.shadow.d.ts

@@ -1,5 +1,9 @@
-import { LitElement, TemplateResult } from 'lit';
-declare const MonoButtonDropdownShadow_base: import('../../composables/hybird-prop').Constructor<import('./button-dropdown-core.js').MonoButtonDropdownCoreInterface> & typeof LitElement;
+import { Constructor } from "../../composables/hybird-prop.js";
+import { MonoButtonDropdownCoreInterface } from "./button-dropdown-core.js";
+import "./mono-button.shadow.js";
+import { LitElement, TemplateResult } from "lit";
+//#region src/components/button/mono-button-dropdown.shadow.d.ts
+declare const MonoButtonDropdownShadow_base: Constructor<MonoButtonDropdownCoreInterface> & typeof LitElement;
 /**
  * Shadow-DOM `mono-button-dropdown` — `@mono-lit/helper/ui/shadow/button-dropdown`,
  * registered as the DISTINCT tag `mono-shadow-button-dropdown` so it can coexist
@@ -13,33 +17,34 @@ declare const MonoButtonDropdownShadow_base: import('../../composables/hybird-pr
  * positions it in place for shadow builds — so it inherits these styles normally.
  */
 export declare class MonoButtonDropdownShadow extends MonoButtonDropdownShadow_base {
-    static styles: import('lit').CSSResult[];
-    protected _buttonTag(): string;
-    /**
-     * Shadow buttons project through a native `<slot>` — they never relocate their
-     * children — so entry content can stay a Lit template here, which also keeps
-     * this build SSR-safe (no `document.createElement` at render time).
-     */
-    protected _declarativeItems(): boolean;
-    /**
-     * `buttons[].icon` is DATA-driven, so the icon element is created inside this
-     * shadow root — where the page's `i-mdi-*` utilities don't reach, leaving the
-     * entries icon-less. `withShadowUtilityStyles` can't cover it: that path
-     * deliberately excludes icon selectors so the two strategies don't collide.
-     *
-     * `adoptIconStyles` is the matching mechanism — one shared, LIVE constructable
-     * sheet that keeps repopulating until it has captured real `.i-…` glyph rules,
-     * so adopting early (before UnoCSS has loaded) still paints once it does.
-     * Called from both hooks for exactly that reason.
-     */
-    protected firstUpdated(changed: Map<string, unknown>): void;
-    protected updated(changed: Map<string, unknown>): void;
-    /** Panel written statically for the same reason as the light build. */
-    protected render(): TemplateResult;
+  static styles: import("lit").CSSResult[];
+  protected _buttonTag(): string;
+  /**
+   * Shadow buttons project through a native `<slot>` — they never relocate their
+   * children — so entry content can stay a Lit template here, which also keeps
+   * this build SSR-safe (no `document.createElement` at render time).
+   */
+  protected _declarativeItems(): boolean;
+  /**
+   * `buttons[].icon` is DATA-driven, so the icon element is created inside this
+   * shadow root — where the page's `i-mdi-*` utilities don't reach, leaving the
+   * entries icon-less. `withShadowUtilityStyles` can't cover it: that path
+   * deliberately excludes icon selectors so the two strategies don't collide.
+   *
+   * `adoptIconStyles` is the matching mechanism — one shared, LIVE constructable
+   * sheet that keeps repopulating until it has captured real `.i-…` glyph rules,
+   * so adopting early (before UnoCSS has loaded) still paints once it does.
+   * Called from both hooks for exactly that reason.
+   */
+  protected firstUpdated(changed: Map<string, unknown>): void;
+  protected updated(changed: Map<string, unknown>): void;
+  /** Panel written statically for the same reason as the light build. */
+  protected render(): TemplateResult;
 }
 declare global {
-    interface HTMLElementTagNameMap {
-        'mono-shadow-button-dropdown': MonoButtonDropdownShadow;
-    }
+  interface HTMLElementTagNameMap {
+    'mono-shadow-button-dropdown': MonoButtonDropdownShadow;
+  }
 }
-export {};
+//#endregion
+export {};

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

@@ -1,5 +1,8 @@
-import { LitElement, TemplateResult } from 'lit';
-declare const MonoButton_base: import('../../composables/hybird-prop').Constructor<import('./button-core.js').MonoButtonCoreInterface> & typeof LitElement;
+import { Constructor } from "../../composables/hybird-prop.js";
+import { MonoButtonCoreInterface } from "./button-core.js";
+import { LitElement, TemplateResult } from "lit";
+//#region src/components/button/mono-button.d.ts
+declare const MonoButton_base: Constructor<MonoButtonCoreInterface> & typeof LitElement;
 /**
  * Light-DOM `mono-button` (default build, `@mono-lit/helper/ui/button`).
  *
@@ -19,105 +22,106 @@ declare const MonoButton_base: import('../../composables/hybird-prop').Construct
  * document loads only one.
  */
 export declare class MonoButton extends MonoButton_base {
-    static styles: import('lit').CSSResult[];
-    protected createRenderRoot(): HTMLElement;
-    private _buckets;
-    private _slotsCaptured;
-    private _guardedAffixes;
-    /**
-     * Capture is one-shot, so a `slot="prepend"` child the consumer appends AFTER
-     * connect would never be seen. These re-run it when one turns up — the icon
-     * slot never needed it because an icon is written inline with the button, but
-     * an affix is exactly the kind of thing a `v-if` reveals later.
-     */
-    private _lateAffix;
-    /**
-     * Light-DOM refinement: `rounded="full"` auto-icon-only only when the default slot is
-     * empty. `bucketHasContent` (not a length check) so a bucket holding nothing but
-     * framework anchors still counts as empty.
-     */
-    protected _defaultIsEmpty(): boolean;
-    private _renderBadge;
-    /**
-     * The `[data-mono-slot]` targets must be **structurally stable** across every
-     * re-render.
-     *
-     * These are light-DOM elements holding nodes the *consumer's* framework
-     * created and still tracks. Toggling `loading` used to swap between two
-     * template branches, so Lit destroyed the target `<span>` — taking the
-     * consumer's nodes with it — and `updated()` re-appended them into a brand-new
-     * one. Vue's vnodes then referenced detached nodes, and the next patch died
-     * with `TypeError: can't access property "__vnode", el is null`.
-     *
-     * So visibility is expressed with the existing `.button-icon.hidden` class
-     * (`display: none !important`), never by adding or removing the target. With
-     * the span stable, `_placeSlot` finds its nodes already in place and mutates
-     * nothing at all on a loading toggle.
-     */
-    private _renderIconOnlyContent;
-    /**
-     * Icon slot class, hidden in place while loading rather than unmounted — but
-     * only in overlay mode. Inline loading keeps the icon, so the button doesn't
-     * reshuffle its contents just to show progress.
-     */
-    /**
-     * The icon box, which is also where the spinner is drawn.
-     *
-     * `spinning` paints the ring and hides whatever is slotted inside; `empty` collapses the box
-     * when there is neither. The span itself is ALWAYS rendered — see `_renderNormalContent`.
-     */
-    private _iconClass;
-    private _renderNormalContent;
-    private _renderContent;
-    protected render(): TemplateResult;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    /**
-     * Claim a `slot="prepend"` / `slot="append"` child that arrived after connect.
-     *
-     * Deliberately NOT `captureLightSlots` a second time. This build renders into
-     * the host (`createRenderRoot` → `this`), so by now the host's children include
-     * Lit's own `<div class="mono-button">` — a re-capture would bucket that as
-     * default content and detach it, wiping the rendered button. `LateSlotWatcher`
-     * hands back only the direct child carrying the slot name, which is all that is
-     * wanted here.
-     */
-    private _recaptureAffix;
-    /**
-     * Stop a nested control's click at the affix boundary — the plain `click`
-     * and the `mno-click` / `mnoClick` aliases alike.
-     *
-     * An affix can hold a whole `<mono-button>` or a dropdown caret. Sibling
-     * placement keeps its clicks out of `_handleClick`, but they would still
-     * bubble to the HOST, where a consumer's `@click` is this button's action —
-     * a split button's caret would run the button's handler. So an affix's click
-     * ends here: its own handlers (deeper) and any document-level CAPTURE
-     * listener have already run. Same guard `mono-button-dropdown` puts on its
-     * embedded buttons.
-     */
-    private _guardAffixEvents;
-    private _captureSlots;
-    /**
-     * An affix zone renders only when its slot has content, so an affix-free button
-     * keeps byte-identical markup. That conditional is safe here — unlike the icon
-     * span, whose target must never unmount — because capture runs BEFORE the
-     * synchronous first render in `connectedCallback`, and because the flags only
-     * ever go false→true: captured nodes stay captured, so a target that exists
-     * once is never taken away from under the consumer's nodes.
-     */
-    private _renderAffix;
-    /**
-     * Apply sizing to the HOST (`mono-button` is inline-block). The `.sized` class
-     * makes the wrapper + inner control fill the host, so width/height set here
-     * cascade down. Props that aren't set are removed so they don't linger.
-     */
-    private _applyHostSize;
-    protected updated(changed: Map<string, unknown>): void;
-    private _placeSlot;
+  static styles: import("lit").CSSResult[];
+  protected createRenderRoot(): HTMLElement;
+  private _buckets;
+  private _slotsCaptured;
+  private _guardedAffixes;
+  /**
+   * Capture is one-shot, so a `slot="prepend"` child the consumer appends AFTER
+   * connect would never be seen. These re-run it when one turns up — the icon
+   * slot never needed it because an icon is written inline with the button, but
+   * an affix is exactly the kind of thing a `v-if` reveals later.
+   */
+  private _lateAffix;
+  /**
+   * Light-DOM refinement: `rounded="full"` auto-icon-only only when the default slot is
+   * empty. `bucketHasContent` (not a length check) so a bucket holding nothing but
+   * framework anchors still counts as empty.
+   */
+  protected _defaultIsEmpty(): boolean;
+  private _renderBadge;
+  /**
+   * The `[data-mono-slot]` targets must be **structurally stable** across every
+   * re-render.
+   *
+   * These are light-DOM elements holding nodes the *consumer's* framework
+   * created and still tracks. Toggling `loading` used to swap between two
+   * template branches, so Lit destroyed the target `<span>` — taking the
+   * consumer's nodes with it — and `updated()` re-appended them into a brand-new
+   * one. Vue's vnodes then referenced detached nodes, and the next patch died
+   * with `TypeError: can't access property "__vnode", el is null`.
+   *
+   * So visibility is expressed with the existing `.button-icon.hidden` class
+   * (`display: none !important`), never by adding or removing the target. With
+   * the span stable, `_placeSlot` finds its nodes already in place and mutates
+   * nothing at all on a loading toggle.
+   */
+  private _renderIconOnlyContent;
+  /**
+   * Icon slot class, hidden in place while loading rather than unmounted — but
+   * only in overlay mode. Inline loading keeps the icon, so the button doesn't
+   * reshuffle its contents just to show progress.
+   */
+  /**
+   * The icon box, which is also where the spinner is drawn.
+   *
+   * `spinning` paints the ring and hides whatever is slotted inside; `empty` collapses the box
+   * when there is neither. The span itself is ALWAYS rendered — see `_renderNormalContent`.
+   */
+  private _iconClass;
+  private _renderNormalContent;
+  private _renderContent;
+  protected render(): TemplateResult;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  /**
+   * Claim a `slot="prepend"` / `slot="append"` child that arrived after connect.
+   *
+   * Deliberately NOT `captureLightSlots` a second time. This build renders into
+   * the host (`createRenderRoot` → `this`), so by now the host's children include
+   * Lit's own `<div class="mono-button">` — a re-capture would bucket that as
+   * default content and detach it, wiping the rendered button. `LateSlotWatcher`
+   * hands back only the direct child carrying the slot name, which is all that is
+   * wanted here.
+   */
+  private _recaptureAffix;
+  /**
+   * Stop a nested control's click at the affix boundary — the plain `click`
+   * and the `mno-click` / `mnoClick` aliases alike.
+   *
+   * An affix can hold a whole `<mono-button>` or a dropdown caret. Sibling
+   * placement keeps its clicks out of `_handleClick`, but they would still
+   * bubble to the HOST, where a consumer's `@click` is this button's action —
+   * a split button's caret would run the button's handler. So an affix's click
+   * ends here: its own handlers (deeper) and any document-level CAPTURE
+   * listener have already run. Same guard `mono-button-dropdown` puts on its
+   * embedded buttons.
+   */
+  private _guardAffixEvents;
+  private _captureSlots;
+  /**
+   * An affix zone renders only when its slot has content, so an affix-free button
+   * keeps byte-identical markup. That conditional is safe here — unlike the icon
+   * span, whose target must never unmount — because capture runs BEFORE the
+   * synchronous first render in `connectedCallback`, and because the flags only
+   * ever go false→true: captured nodes stay captured, so a target that exists
+   * once is never taken away from under the consumer's nodes.
+   */
+  private _renderAffix;
+  /**
+   * Apply sizing to the HOST (`mono-button` is inline-block). The `.sized` class
+   * makes the wrapper + inner control fill the host, so width/height set here
+   * cascade down. Props that aren't set are removed so they don't linger.
+   */
+  private _applyHostSize;
+  protected updated(changed: Map<string, unknown>): void;
+  private _placeSlot;
 }
 declare global {
-    interface HTMLElementTagNameMap {
-        'mono-button': MonoButton;
-    }
+  interface HTMLElementTagNameMap {
+    'mono-button': MonoButton;
+  }
 }
-export {};
+//#endregion
+export {};

package/dist/src/components/button/mono-button.shadow.d.ts

@@ -1,5 +1,8 @@
-import { LitElement, TemplateResult } from 'lit';
-declare const MonoButtonShadow_base: import('../../composables/hybird-prop').Constructor<import('./button-core.js').MonoButtonCoreInterface> & typeof LitElement;
+import { Constructor } from "../../composables/hybird-prop.js";
+import { MonoButtonCoreInterface } from "./button-core.js";
+import { LitElement, TemplateResult } from "lit";
+//#region src/components/button/mono-button.shadow.d.ts
+declare const MonoButtonShadow_base: Constructor<MonoButtonCoreInterface> & typeof LitElement;
 /**
  * Shadow-DOM `mono-button` (the opt-in SSR build, `@mono-lit/helper/ui/shadow/button`).
  *
@@ -17,40 +20,41 @@ declare const MonoButtonShadow_base: import('../../composables/hybird-prop').Con
  * `mono-button`, so a document loads only one.
  */
 export declare class MonoButtonShadow extends MonoButtonShadow_base {
-    static styles: import('lit').CSSResult[];
-    connectedCallback(): void;
-    firstUpdated(changed: Map<string, unknown>): void;
-    protected updated(changed: Map<string, unknown>): void;
-    private _iconSlot;
-    private _slotHasContent;
-    /**
-     * An affix zone. Unlike the light build's conditional target, the wrapper is
-     * ALWAYS rendered here: the native `<slot>` has to exist for DSD to project
-     * into it and for the scan to see it, so emptiness is a `?data-empty`
-     * attribute the shadow-only CSS hides — the same shape the icon region uses.
-     *
-     * `stopPropagation` on `click` / `mno-click` keeps a nested control's own
-     * click from surfacing as this button's action (a split button's caret must
-     * not run the button's `@click`); see the light build's `_guardAffixEvents`.
-     */
-    private _renderAffix;
-    private _affixSlot;
-    private _onAffixSlotChange;
-    private _onIconSlotChange;
-    /** Host sizing (client-only; mirrors the light build's `_applyHostSize`). */
-    private _applyHostSize;
-    private _renderBadge;
-    /**
-     * The icon box, which is also where the spinner is drawn.
-     *
-     * `spinning` paints the ring and hides the slotted icon; `data-empty` collapses the box when
-     * there is neither. Matches the light build exactly — the two used to differ here, with light
-     * keeping the span and shadow unmounting it.
-     */
-    private _iconSpan;
-    private _renderIconOnlyContent;
-    private _renderNormalContent;
-    private _renderContent;
-    protected render(): TemplateResult;
+  static styles: import("lit").CSSResult[];
+  connectedCallback(): void;
+  firstUpdated(changed: Map<string, unknown>): void;
+  protected updated(changed: Map<string, unknown>): void;
+  private _iconSlot;
+  private _slotHasContent;
+  /**
+   * An affix zone. Unlike the light build's conditional target, the wrapper is
+   * ALWAYS rendered here: the native `<slot>` has to exist for DSD to project
+   * into it and for the scan to see it, so emptiness is a `?data-empty`
+   * attribute the shadow-only CSS hides — the same shape the icon region uses.
+   *
+   * `stopPropagation` on `click` / `mno-click` keeps a nested control's own
+   * click from surfacing as this button's action (a split button's caret must
+   * not run the button's `@click`); see the light build's `_guardAffixEvents`.
+   */
+  private _renderAffix;
+  private _affixSlot;
+  private _onAffixSlotChange;
+  private _onIconSlotChange;
+  /** Host sizing (client-only; mirrors the light build's `_applyHostSize`). */
+  private _applyHostSize;
+  private _renderBadge;
+  /**
+   * The icon box, which is also where the spinner is drawn.
+   *
+   * `spinning` paints the ring and hides the slotted icon; `data-empty` collapses the box when
+   * there is neither. Matches the light build exactly — the two used to differ here, with light
+   * keeping the span and shadow unmounting it.
+   */
+  private _iconSpan;
+  private _renderIconOnlyContent;
+  private _renderNormalContent;
+  private _renderContent;
+  protected render(): TemplateResult;
 }
-export {};
+//#endregion
+export {};

package/dist/src/components/card/card-core.d.ts

@@ -1,63 +1,65 @@
-import { LitElement } from 'lit';
-import { CardSize, CardVariant, CardColor, CardRounded, CardMediaPosition, CardCssClass } from './card-types.js';
-import { Constructor } from '../../composables/hybird-prop';
-import { buildSizeStyle, CssSizeValue } from '../../composables/css-size';
+import { Constructor } from "../../composables/hybird-prop.js";
+import { CssSizeValue, buildSizeStyle } from "../../composables/css-size.js";
+import { CardColor, CardCssClass, CardMediaPosition, CardRounded, CardSize, CardVariant } from "./card-types.js";
+import { LitElement } from "lit";
+//#region src/components/card/card-core.d.ts
 type CardRootElement = HTMLDivElement | HTMLAnchorElement;
 /** Slot regions the card lays out. `default` is the unnamed body region. */
 export type CardSlotName = 'media' | 'icon' | 'title' | 'subtitle' | 'header' | 'actions' | 'footer' | 'default';
 /** Public + shared-protected surface added by the core mixin. */
 export declare class MonoCardCoreInterface {
-    size: CardSize;
-    variant: CardVariant;
-    color: CardColor;
-    rounded?: CardRounded;
-    mediaPosition: CardMediaPosition;
-    /** Header headline. `heading` is the old name, kept as an alias. */
-    title: string;
-    /** Header secondary line. `subheading` is the old name, kept as an alias. */
-    subtitle: string;
-    /** @deprecated alias of `title` */
-    heading?: string;
-    /** @deprecated alias of `subtitle` */
-    subheading?: string;
-    bordered: boolean;
-    hoverable: boolean;
-    clickable: boolean;
-    selected: boolean;
-    disabled: boolean;
-    loading: boolean;
-    width?: CssSizeValue;
-    height?: CssSizeValue;
-    minWidth?: CssSizeValue;
-    maxWidth?: CssSizeValue;
-    minHeight?: CssSizeValue;
-    maxHeight?: CssSizeValue;
-    headerDivider: boolean;
-    footerDivider: boolean;
-    href?: string;
-    target?: string;
-    ariaLabelText?: string;
-    cssClass: CardCssClass;
-    focus(): void;
-    blur(): void;
-    click(): void;
-    protected _hasMedia: boolean;
-    protected _hasIcon: boolean;
-    protected _hasTitle: boolean;
-    protected _hasSubtitle: boolean;
-    protected _hasHeaderSlot: boolean;
-    protected _hasActions: boolean;
-    protected _hasFooter: boolean;
-    protected _hasDefault: boolean;
-    protected _cardElement?: CardRootElement;
-    protected _cls(base: string, key: keyof CardCssClass): string;
-    protected _sizeStyle(): ReturnType<typeof buildSizeStyle>;
-    protected get _isInteractive(): boolean;
-    protected get _isDisabled(): boolean;
-    protected get _hasHeader(): boolean;
-    protected get _cardClasses(): string;
-    protected _handleClick(event: MouseEvent): void;
-    protected _handleKeyDown(event: KeyboardEvent): void;
+  size: CardSize;
+  variant: CardVariant;
+  color: CardColor;
+  rounded?: CardRounded;
+  mediaPosition: CardMediaPosition;
+  /** Header headline. `heading` is the old name, kept as an alias. */
+  title: string;
+  /** Header secondary line. `subheading` is the old name, kept as an alias. */
+  subtitle: string;
+  /** @deprecated alias of `title` */
+  heading?: string;
+  /** @deprecated alias of `subtitle` */
+  subheading?: string;
+  bordered: boolean;
+  hoverable: boolean;
+  clickable: boolean;
+  selected: boolean;
+  disabled: boolean;
+  loading: boolean;
+  width?: CssSizeValue;
+  height?: CssSizeValue;
+  minWidth?: CssSizeValue;
+  maxWidth?: CssSizeValue;
+  minHeight?: CssSizeValue;
+  maxHeight?: CssSizeValue;
+  headerDivider: boolean;
+  footerDivider: boolean;
+  href?: string;
+  target?: string;
+  ariaLabelText?: string;
+  cssClass: CardCssClass;
+  focus(): void;
+  blur(): void;
+  click(): void;
+  protected _hasMedia: boolean;
+  protected _hasIcon: boolean;
+  protected _hasTitle: boolean;
+  protected _hasSubtitle: boolean;
+  protected _hasHeaderSlot: boolean;
+  protected _hasActions: boolean;
+  protected _hasFooter: boolean;
+  protected _hasDefault: boolean;
+  protected _cardElement?: CardRootElement;
+  protected _cls(base: string, key: keyof CardCssClass): string;
+  protected _sizeStyle(): ReturnType<typeof buildSizeStyle>;
+  protected get _isInteractive(): boolean;
+  protected get _isDisabled(): boolean;
+  protected get _hasHeader(): boolean;
+  protected get _noSubtitle(): boolean;
+  protected get _cardClasses(): string;
+  protected _handleClick(event: MouseEvent): void;
+  protected _handleKeyDown(event: KeyboardEvent): void;
 }
 /**
  * `MonoCardCore` — all render-mode-agnostic logic for `mono-card`: reactive
@@ -71,4 +73,5 @@ export declare class MonoCardCoreInterface {
  * `focus/blur/click` + the `HTMLAnchorElement` check only run client-side.
  */
 export declare const MonoCardCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoCardCoreInterface> & T;
-export {};
+//#endregion
+export {};