@malva-ui/core 0.1.12

package/badge/lib/badge-icon.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from "@angular/core";
+/** Which side of the badge label a `[mlvBadgeIcon]` renders on. */
+export type MlvBadgeIconPosition = 'start' | 'end';
+/**
+ * Marks a projected element as the badge's icon slot. The badge sizes it from
+ * its own density-driven font size and adds the label gap, so consumers do not
+ * have to hand-tune `width`/`height` per density.
+ *
+ * The icon is decorative by default (`aria-hidden="true"`): a badge normally
+ * repeats the icon's meaning in its label. When the icon is the badge's only
+ * content, give the badge itself an accessible name.
+ *
+ * @example
+ * ```html
+ * <mlv-badge tone="success" muted>
+ *   <svg lucideCheck mlvBadgeIcon />
+ *   Published
+ * </mlv-badge>
+ *
+ * <mlv-badge tone="info">
+ *   Syncing
+ *   <svg lucideRefreshCw mlvBadgeIcon position="end" />
+ * </mlv-badge>
+ * ```
+ */
+export declare class MlvBadgeIcon {
+    /**
+     * Where the icon sits relative to the badge label. `'start'` (the default)
+     * keeps it leading; `'end'` moves it after the label. Both are reordered by
+     * CSS, so the icon can stay wherever it reads best in the template.
+     */
+    readonly position: import("@angular/core").InputSignal<MlvBadgeIconPosition>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvBadgeIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvBadgeIcon, "[mlvBadgeIcon]", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/badge/malva-ui-core-badge.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/badge" />
+export * from './index';

package/bottom-nav/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/bottom-nav/bottom-nav';

package/bottom-nav/lib/bottom-nav/bottom-nav.d.ts

@@ -0,0 +1,99 @@
+import type { MlvNavItem } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+/** MlvLayout direction for icon and label within each navigation item. */
+export type MlvBottomNavStacking = 'vertical' | 'horizontal';
+/** Controls when item labels are visible. */
+export type MlvBottomNavLabelVisibility = 'always' | 'active-only';
+/**
+ * Fixed bottom navigation bar for mobile contexts.
+ * Renders up to 5 items; overflows into a synthetic "More" item
+ * that opens a menu with the hidden items.
+ *
+ * Supports two activation modes:
+ * - **Router mode** (default): active state is driven by `routerLinkActive`.
+ *   Items are rendered as `<a>` elements with `routerLink`.
+ * - **Managed mode**: when `activeIndex` is provided, active state is
+ *   controlled by the consumer. Items are rendered as `<button>` elements
+ *   and clicks emit on the `itemClick` output.
+ *
+ * Also supports vertical/horizontal stacking, active-only label visibility,
+ * and per-item disabled state.
+ *
+ * @example
+ * <mlv-bottom-nav *mlvBreakpointDown="'md'" [items]="navItems" />
+ *
+ * @example
+ * <mlv-bottom-nav [items]="navItems" [activeIndex]="selected" (itemClick)="selected = $event" />
+ */
+export declare class MlvBottomNav {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvBottomNavI18n>;
+    /**
+     * Navigation items to display.
+     * Up to 5 items are shown; if more than 5 are provided,
+     * the first 4 are rendered and a "More" button opens a menu with the overflow items.
+     */
+    readonly items: import("@angular/core").InputSignal<MlvNavItem[]>;
+    /** Accessible label for the nav landmark. */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * MlvLayout direction for icon and label within each item.
+     * - `'vertical'` (default): icon on top, label below.
+     * - `'horizontal'`: icon on the left, label on the right, vertically centered.
+     */
+    readonly stacking: import("@angular/core").InputSignal<MlvBottomNavStacking>;
+    /**
+     * Controls when item labels are visible.
+     * - `'always'` (default): labels are always shown on all items.
+     * - `'active-only'`: labels are hidden by default and smoothly revealed
+     *   only on the active (current route) item. The "More" button label
+     *   is always visible regardless of this setting.
+     */
+    readonly labelVisibility: import("@angular/core").InputSignal<MlvBottomNavLabelVisibility>;
+    /**
+     * Index of the active item in managed mode.
+     * When provided (even as `0`), the component switches to managed mode:
+     * items render as `<button>` elements instead of `<a routerLink>` and
+     * the active class is driven by this index rather than the router.
+     */
+    readonly activeIndex: import("@angular/core").InputSignal<number | undefined>;
+    /**
+     * Emits the index of the clicked item in managed mode.
+     * Not emitted for disabled items or in router mode.
+     */
+    readonly itemClick: import("@angular/core").OutputEmitterRef<number>;
+    /** @private Router for programmatic navigation from overflow menu items. */
+    private readonly _router;
+    /**
+     * @protected Whether the component is in managed (non-router) mode.
+     * True when `activeIndex` has been explicitly provided.
+     */
+    protected readonly _isManaged: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Items displayed as direct nav links in the bar.
+     * All items if total <= MAX_VISIBLE, otherwise the first (MAX_VISIBLE - 1).
+     */
+    protected readonly _displayItems: import("@angular/core").Signal<MlvNavItem[]>;
+    /**
+     * @protected Items that overflow into the "More" menu.
+     * Empty if total <= MAX_VISIBLE.
+     */
+    protected readonly _overflowItems: import("@angular/core").Signal<MlvNavItem[]>;
+    /**
+     * @protected Whether the bar has overflow items requiring a "More" button.
+     */
+    protected readonly _hasOverflow: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Handles click on a visible item in managed mode.
+     * Emits the item's index on `itemClick`.
+     */
+    protected _onItemClick(index: number): void;
+    /**
+     * @protected Handles click on an overflow menu item.
+     * In managed mode, emits the global index on `itemClick`.
+     * In router mode, navigates to the item's route.
+     */
+    protected _onOverflowItemClick(overflowIndex: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvBottomNav, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvBottomNav, "mlv-bottom-nav", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "stacking": { "alias": "stacking"; "required": false; "isSignal": true; }; "labelVisibility": { "alias": "labelVisibility"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}

package/bottom-nav/malva-ui-core-bottom-nav.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/bottom-nav" />
+export * from './index';

package/breadcrumb/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/breadcrumb/breadcrumb';
+export * from './lib/breadcrumb/breadcrumb-item';
+export * from './lib/breadcrumb/breadcrumb-item-host';
+export * from './lib/breadcrumb/breadcrumb-separator';
+export * from './lib/breadcrumb/breadcrumb.types';

package/breadcrumb/lib/breadcrumb/breadcrumb-item-host.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from "@angular/core";
+/**
+ * Attribute directive that can be applied to any `<a>` or `<li>` element as an
+ * alternative to using the `<mlv-breadcrumb-item>` component. Applies the
+ * correct BEM classes without replacing the native element.
+ *
+ * Use this when you need to preserve native element semantics (e.g., when
+ * working with a router `<a>` element inside a list item, or when composing
+ * with third-party link components).
+ *
+ * @example Applied to a native anchor inside an `<li>`
+ * ```html
+ * <nav mlvBreadcrumb>
+ *   <ol class="mlv-breadcrumb__list">
+ *     <li mlvBreadcrumbItem class="mlv-breadcrumb__item">
+ *       <a mlvBreadcrumbItem class="mlv-breadcrumb__link" href="/">Home</a>
+ *     </li>
+ *   </ol>
+ * </nav>
+ * ```
+ *
+ * @example Applied to a `<li>` element
+ * ```html
+ * <li mlvBreadcrumbItem>
+ *   <a class="mlv-breadcrumb__link" href="/products">Products</a>
+ * </li>
+ * ```
+ */
+export declare class MlvBreadcrumbItemHost {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvBreadcrumbItemHost, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvBreadcrumbItemHost, "[mlvBreadcrumbItem]", never, {}, {}, never, never, true, never>;
+}

package/breadcrumb/lib/breadcrumb/breadcrumb-item.d.ts

@@ -0,0 +1,41 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+/**
+ * Individual breadcrumb item component.
+ *
+ * Renders a navigable link (via `routerLink` or `href`) or plain text when
+ * the item is the current page or is disabled.
+ *
+ * The last item in the breadcrumb list should have `current` set to `true`,
+ * which adds `aria-current="page"` and renders non-interactive text.
+ *
+ * @example Basic usage
+ * ```html
+ * <mlv-breadcrumb-item href="/home">Home</mlv-breadcrumb-item>
+ * <mlv-breadcrumb-item [routerLink]="['/products']">Products</mlv-breadcrumb-item>
+ * <mlv-breadcrumb-item [current]="true">Widget Pro</mlv-breadcrumb-item>
+ * ```
+ */
+export declare class MlvBreadcrumbItem {
+    /**
+     * Angular router link for navigation.
+     * Supports string or string array (same as `[routerLink]`).
+     */
+    readonly routerLink: import("@angular/core").InputSignal<string | string[] | null>;
+    /**
+     * Standard `href` for anchor-based navigation.
+     * Use when not using Angular Router.
+     */
+    readonly href: import("@angular/core").InputSignal<string | null>;
+    /**
+     * When `true`, marks this item as the current page.
+     * Renders as non-interactive text with `aria-current="page"`.
+     */
+    readonly current: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * When `true`, disables navigation and renders the item as plain text.
+     */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvBreadcrumbItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvBreadcrumbItem, "mlv-breadcrumb-item", never, { "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/breadcrumb/lib/breadcrumb/breadcrumb-separator.d.ts

@@ -0,0 +1,31 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Structural directive that marks an `<ng-template>` as a custom separator
+ * to be rendered between breadcrumb items.
+ *
+ * When no `[mlvSeparator]` directive is present inside `nav[mlvBreadcrumb]`,
+ * the component falls back to a `LucideChevronRight` icon.
+ *
+ * @example Custom text separator
+ * ```html
+ * <nav mlvBreadcrumb [items]="items">
+ *   <ng-template mlvSeparator>›</ng-template>
+ * </nav>
+ * ```
+ *
+ * @example Custom icon separator
+ * ```html
+ * <nav mlvBreadcrumb [items]="items">
+ *   <ng-template mlvSeparator>
+ *     <svg lucideSlash [size]="14" />
+ *   </ng-template>
+ * </nav>
+ * ```
+ */
+export declare class MlvBreadcrumbSeparator {
+    /** The template reference for the custom separator content. */
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvBreadcrumbSeparator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvBreadcrumbSeparator, "[mlvSeparator]", never, {}, {}, never, never, true, never>;
+}

package/breadcrumb/lib/breadcrumb/breadcrumb.d.ts

@@ -0,0 +1,151 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import { MlvPopup } from '@malva-ui/core/popup';
+import { MlvBreadcrumbItem } from './breadcrumb-item';
+import { MlvBreadcrumbSeparator } from './breadcrumb-separator';
+import type { MlvBreadcrumbEntry } from './breadcrumb.types';
+import type { MlvDensity } from '@malva-ui/cdk/density';
+import * as i0 from "@angular/core";
+/**
+ * Navigation breadcrumb component.
+ *
+ * Use with `nav[mlvBreadcrumb]` selector applied to a `<nav>` element.
+ * Renders a list of breadcrumb trail items with a customisable separator,
+ * optional overflow truncation with a popover for hidden items, and router
+ * integration.
+ *
+ * Supports two usage modes:
+ * 1. **Data-driven** — pass an array of `MlvBreadcrumbEntry` objects via `[items]`.
+ * 2. **Projected** — nest `<mlv-breadcrumb-item>` elements directly.
+ *
+ * The separator can be customised by placing `<ng-template mlvSeparator>` inside
+ * the `<nav>`. When no separator directive is present, a `LucideChevronRight` icon
+ * is used as the default.
+ *
+ * @example Data-driven
+ * ```html
+ * <nav mlvBreadcrumb [items]="breadcrumbs"></nav>
+ * ```
+ *
+ * @example Custom separator via structural directive
+ * ```html
+ * <nav mlvBreadcrumb [items]="breadcrumbs">
+ *   <ng-template mlvSeparator>›</ng-template>
+ * </nav>
+ * ```
+ *
+ * @example Projected items
+ * ```html
+ * <nav mlvBreadcrumb>
+ *   <mlv-breadcrumb-item href="/">Home</mlv-breadcrumb-item>
+ *   <mlv-breadcrumb-item [routerLink]="['/products']">Products</mlv-breadcrumb-item>
+ *   <mlv-breadcrumb-item [current]="true">Widget Pro</mlv-breadcrumb-item>
+ * </nav>
+ * ```
+ *
+ * @example With overflow truncation
+ * ```html
+ * <nav mlvBreadcrumb [items]="longBreadcrumbs" [maxItems]="4"></nav>
+ * ```
+ */
+export declare class MlvBreadcrumb {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvBreadcrumbI18n>;
+    /** @private Resolver for ICU parameterized i18n strings. */
+    private readonly _resolver;
+    /**
+     * @protected Resolved aria-label for the overflow ellipsis button, e.g.
+     * "Show 3 more breadcrumb items".
+     */
+    protected readonly _showMoreLabel: import("@angular/core").Signal<string>;
+    /** @private Document reference used for focus navigation checks. */
+    private readonly _document;
+    /**
+     * Data-driven list of breadcrumb items.
+     * When provided, items are rendered from this array.
+     * The last item in the array is automatically treated as the current page.
+     */
+    readonly items: import("@angular/core").InputSignal<MlvBreadcrumbEntry[]>;
+    /**
+     * Density applied to the overflow popover's item list.
+     *
+     * The popover is portaled to the CDK overlay container, outside the
+     * component's DOM tree, so ancestor density classes cannot cascade into it.
+     * Forwarded to the overflow `mlv-popup`, which stamps the resolved
+     * `mlv--{density}` class on the detached panel. When omitted, the global
+     * `MlvDensityService` density applies.
+     */
+    readonly mlvDensity: import("@angular/core").InputSignal<MlvDensity | undefined>;
+    /**
+     * Maximum number of items to display before truncating.
+     * When the total count exceeds this value, the middle items are collapsed
+     * into an ellipsis (`…`) button. Clicking the button opens a popover
+     * listing all hidden items. Always shows the first and last items.
+     * Set to `0` to disable truncation (show all items). Defaults to `0`.
+     */
+    readonly maxItems: import("@angular/core").InputSignal<number>;
+    /**
+     * When `true`, makes the separator `aria-hidden` to prevent screen readers
+     * from announcing it. Defaults to `true`.
+     */
+    readonly hideSeparatorFromScreenReaders: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @protected Custom separator template projected via `<ng-template mlvSeparator>`.
+     * When absent, a `LucideChevronRight` icon is rendered as the default separator.
+     */
+    protected readonly _separatorDef: import("@angular/core").Signal<MlvBreadcrumbSeparator | undefined>;
+    /**
+     * @protected Projected `mlv-breadcrumb-item` elements from content.
+     * Used when the component is operated in projected mode instead of data-driven.
+     */
+    protected readonly _projectedItems: import("@angular/core").Signal<readonly MlvBreadcrumbItem[]>;
+    /** @protected Ellipsis trigger used to restore focus after keyboard close. */
+    protected readonly _overflowTriggerRef: import("@angular/core").Signal<HTMLButtonElement | undefined>;
+    /**
+     * @private The focusable overflow-popover link elements, in DOM order. They are
+     * rendered by this component's own template (inside `mlvPopupContent`), so a
+     * signal view query resolves them — even though the popover content renders in
+     * a detached overlay. Replaces a `getElementById` + `querySelectorAll` lookup.
+     */
+    private readonly _overflowNavItems;
+    /** @protected Stable id applied to the overflow list element (menu container). */
+    protected readonly _overflowListId: string;
+    /**
+     * @protected The computed visible items for data-driven mode, with overflow applied.
+     * Returns the full list when `maxItems` is 0 or not set.
+     */
+    protected readonly _visibleItems: import("@angular/core").Signal<(MlvBreadcrumbEntry & {
+        _isEllipsis?: boolean;
+    })[]>;
+    /**
+     * @protected The hidden items that are collapsed behind the ellipsis.
+     * These are shown in the popover when the ellipsis button is clicked.
+     */
+    protected readonly _hiddenItems: import("@angular/core").Signal<MlvBreadcrumbEntry[]>;
+    /**
+     * @protected Whether the component is used in data-driven mode (items provided via input).
+     * When false, rendered items come from projected `<mlv-breadcrumb-item>` elements.
+     */
+    protected readonly _isDataDriven: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Moves focus to the first actionable item after the overflow popup opens.
+     */
+    protected _focusFirstOverflowItem(): void;
+    /**
+     * @protected Handles arrow-key navigation within the overflow popup.
+     */
+    protected _onOverflowKeydown(event: KeyboardEvent, popup: MlvPopup): void;
+    /**
+     * @protected Closes the overflow popup after an item is activated.
+     */
+    protected _closeOverflowPopup(popup: MlvPopup): void;
+    /**
+     * @private Focuses an overflow item by index when it exists.
+     */
+    private _focusOverflowItem;
+    /**
+     * @private Returns currently rendered focusable overflow item elements.
+     */
+    private _overflowItemElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvBreadcrumb, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvBreadcrumb, "nav[mlvBreadcrumb]", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "mlvDensity": { "alias": "mlvDensity"; "required": false; "isSignal": true; }; "maxItems": { "alias": "maxItems"; "required": false; "isSignal": true; }; "hideSeparatorFromScreenReaders": { "alias": "hideSeparatorFromScreenReaders"; "required": false; "isSignal": true; }; }, {}, ["_separatorDef", "_projectedItems"], ["*"], true, never>;
+}

package/breadcrumb/lib/breadcrumb/breadcrumb.types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Represents a single breadcrumb navigation item.
+ *
+ * Use this interface when providing items data-driven via the `items` input
+ * on `MlvBreadcrumb`.
+ */
+export interface MlvBreadcrumbEntry {
+    /** Display label for this breadcrumb step. */
+    label: string;
+    /**
+     * Router link for Angular router navigation.
+     * Passed directly to `[routerLink]` on the anchor element.
+     * Use either `routerLink` or `href`, not both.
+     */
+    routerLink?: string | string[];
+    /**
+     * Raw href for standard anchor navigation.
+     * Use either `href` or `routerLink`, not both.
+     */
+    href?: string;
+    /**
+     * When `true`, marks this item as disabled — rendered as plain text
+     * without a link, and not navigable.
+     */
+    disabled?: boolean;
+}

package/breadcrumb/malva-ui-core-breadcrumb.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/breadcrumb" />
+export * from './index';

package/button/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/button/button';
+export * from './lib/button.directives';
+export * from './lib/button-group/button-group';
+export * from './lib/button-split/button-split';
+export * from './lib/button-toggle/button-toggle';
+export * from './lib/button-variant.token';
+export * from './lib/button-close/button-close';

package/button/lib/button/button.d.ts

@@ -0,0 +1,61 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import { MlvButtonAfter, MlvButtonBefore } from '../button.directives';
+import type { MlvButtonShape, MlvButtonVariant } from '../button.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@malva-ui/cdk/density";
+export type { MlvButtonShape, MlvButtonVariant } from '../button.types';
+export declare class MlvButton {
+    /**
+     * Visual treatment for this button. When omitted, the closest button group,
+     * split button, or toggle supplies it; otherwise the fallback depends on the
+     * shape — `secondary` for the icon-only `square`/`circle` shapes and
+     * `primary` for every other shape.
+     */
+    readonly variant: import("@angular/core").InputSignal<MlvButtonVariant | undefined>;
+    /** Shape of the button. Circle and square are intended for icon-only actions. */
+    readonly shape: import("@angular/core").InputSignal<MlvButtonShape>;
+    /** Whether the native button is disabled. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the button is waiting for an asynchronous action to complete. */
+    readonly loading: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @private Optional ancestor-provided default visual treatment. */
+    private readonly _variantAccessor;
+    /**
+     * The visual treatment after resolving local, inherited, and default values.
+     *
+     * The final fallback is shape-aware: a bare `square`/`circle` button is an
+     * icon action, and rendering a row of them as saturated `primary` CTAs was
+     * never the intent, so they fall back to the neutral `secondary` treatment.
+     * An explicit `variant` and an ancestor `MLV_BUTTON_VARIANT` both still win.
+     */
+    readonly effectiveVariant: import("@angular/core").Signal<MlvButtonVariant>;
+    /** @protected Whether `shape` is one of the square/circle icon-only shapes. */
+    protected readonly _iconShape: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected True for a circle/square button whose content is only an icon —
+     * either marked with `mlvButtonIcon` or inferred from an empty label slot.
+     * Drives the icon-only modifier.
+     */
+    protected readonly _iconOnly: import("@angular/core").Signal<boolean>;
+    /** @protected Template slot rendered before the button text. */
+    protected readonly beforeRef: import("@angular/core").Signal<MlvButtonBefore | undefined>;
+    /** @protected Template slot rendered after the button text. */
+    protected readonly afterRef: import("@angular/core").Signal<MlvButtonAfter | undefined>;
+    /** @private Projected icon directive, used to detect icon-only buttons. */
+    private readonly _iconDirective;
+    /** @private The label slot, read back after render to detect icon-only content. */
+    private readonly _textRef;
+    /**
+     * @private Whether the default content slot rendered any non-whitespace text.
+     *
+     * Starts `true` so a button that never reaches a browser render — server-side
+     * rendering, where `afterRenderEffect` does not run — keeps the pre-inference
+     * behaviour instead of guessing icon-only.
+     */
+    private readonly _hasProjectedText;
+    constructor();
+    /** @protected Prevents activation while the button is disabled or loading. */
+    protected _handleClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvButton, "button[mlvButton], a[mlvButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, ["beforeRef", "afterRef", "_iconDirective"], ["*"], true, [{ directive: typeof i1.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}

package/button/lib/button-close/button-close.d.ts

@@ -0,0 +1,24 @@
+import { MlvDensityDirective } from '@malva-ui/cdk/density';
+import type { MlvButtonShape, MlvButtonVariant } from '../button/button';
+import * as i0 from "@angular/core";
+import * as i1 from "@malva-ui/cdk/density";
+export declare class MlvButtonClose {
+    /**
+     * Visual treatment for the inner button. Defaults to `transparent`; binding
+     * `undefined` allows the standard button variant inheritance to take over.
+     */
+    readonly variant: import("@angular/core").InputSignal<MlvButtonVariant | undefined>;
+    /** Shape of the inner close button. */
+    readonly shape: import("@angular/core").InputSignal<MlvButtonShape>;
+    /** Accessible name applied to the inner native button. */
+    readonly ariaLabel: import("@angular/core").InputSignal<string>;
+    /**
+     * @protected Resolved host-directive density forwarded to the inner button.
+     *
+     * The full five-step directive, not one of the clamped variants: a close
+     * button matches the dimensions of an icon-only `mlvButton` at every density.
+     */
+    protected readonly _density: MlvDensityDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvButtonClose, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvButtonClose, "mlv-button-close", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}

package/button/lib/button-group/button-group.d.ts

@@ -0,0 +1,21 @@
+import type { MlvButtonVariant } from '../button.types';
+import type { MlvButtonVariantAccessor } from '../button-variant.token';
+import * as i0 from "@angular/core";
+/**
+ * Visually joins related buttons and provides a shared variant to children.
+ * Use the native `aria-label` or `aria-labelledby` attribute to name the group
+ * when its purpose is not clear from surrounding content.
+ */
+export declare class MlvButtonGroup implements MlvButtonVariantAccessor {
+    /**
+     * Default visual treatment for descendant buttons. An individual button can
+     * still override it with its own `variant` input.
+     */
+    readonly variant: import("@angular/core").InputSignal<MlvButtonVariant | undefined>;
+    /** @private Optional variant supplied by an enclosing button container. */
+    private readonly _parentVariant;
+    /** The shared variant inherited by descendants without a local override. */
+    readonly effectiveVariant: import("@angular/core").Signal<MlvButtonVariant>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvButtonGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvButtonGroup, "mlv-button-group", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/button/lib/button-split/button-split.d.ts

@@ -0,0 +1,21 @@
+import type { MlvButtonVariant } from '../button.types';
+import type { MlvButtonVariantAccessor } from '../button-variant.token';
+import * as i0 from "@angular/core";
+/**
+ * Joins a primary action and its related secondary trigger into one control.
+ * The component owns layout and shared styling; consumers keep control of the
+ * two projected native buttons and any menu or popup attached to the trigger.
+ */
+export declare class MlvButtonSplit implements MlvButtonVariantAccessor {
+    /**
+     * Default visual treatment for both projected buttons. Either child can
+     * override it with a local `variant` input.
+     */
+    readonly variant: import("@angular/core").InputSignal<MlvButtonVariant | undefined>;
+    /** @private Optional variant supplied by an enclosing button container. */
+    private readonly _parentVariant;
+    /** The shared variant inherited by projected buttons. */
+    readonly effectiveVariant: import("@angular/core").Signal<MlvButtonVariant>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvButtonSplit, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvButtonSplit, "mlv-button-split", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/button/lib/button-toggle/button-toggle.d.ts

@@ -0,0 +1,33 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvDensity } from '@malva-ui/cdk/density';
+import type { MlvButtonShape, MlvButtonVariant } from '../button.types';
+import type { MlvButtonVariantAccessor } from '../button-variant.token';
+import * as i0 from "@angular/core";
+/** A two-state button that exposes native `aria-pressed` semantics. */
+export declare class MlvButtonToggle implements MlvButtonVariantAccessor {
+    /** Two-way bindable pressed state reflected by the inner native button. */
+    readonly pressed: import("@angular/core").ModelSignal<boolean>;
+    /** Whether the inner native button is disabled. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Visual treatment for the toggle. When omitted, it inherits the closest
+     * button container variant and otherwise falls back to `primary`.
+     */
+    readonly variant: import("@angular/core").InputSignal<MlvButtonVariant | undefined>;
+    /** Shape of the inner button. */
+    readonly shape: import("@angular/core").InputSignal<MlvButtonShape>;
+    /** Density level forwarded to the inner button. */
+    readonly mlvDensity: import("@angular/core").InputSignal<MlvDensity | undefined>;
+    /** Accessible name for an icon-only toggle. */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /** Id reference(s) naming the inner native button. */
+    readonly ariaLabelledBy: import("@angular/core").InputSignal<string | undefined>;
+    /** @private Optional variant supplied by an enclosing button container. */
+    private readonly _parentVariant;
+    /** The visual treatment inherited by the inner button. */
+    readonly effectiveVariant: import("@angular/core").Signal<MlvButtonVariant>;
+    /** Toggles the pressed state unless the control is disabled. */
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvButtonToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvButtonToggle, "mlv-button-toggle", never, { "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "mlvDensity": { "alias": "mlvDensity"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; }, { "pressed": "pressedChange"; }, never, ["*"], true, never>;
+}

package/button/lib/button-variant.token.d.ts

@@ -0,0 +1,13 @@
+import type { Signal } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { MlvButtonVariant } from './button.types';
+/**
+ * Contract implemented by button containers that provide a default variant to
+ * descendant buttons.
+ */
+export interface MlvButtonVariantAccessor {
+    /** The resolved variant descendants should use when they have no override. */
+    readonly effectiveVariant: Signal<MlvButtonVariant>;
+}
+/** Optional ancestor that supplies a default variant to descendant buttons. */
+export declare const MLV_BUTTON_VARIANT: InjectionToken<MlvButtonVariantAccessor>;