@mk-kit/ui 0.34.0

package/types/mk-kit-ui-data.d.ts

@@ -0,0 +1,2580 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import * as _mk_kit_ui_core from '@mk-kit/ui/core';
+import { MkTone, MkSize, MkCodeLanguage } from '@mk-kit/ui/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as _mk_kit_ui_data from '@mk-kit/ui/data';
+import { MkDropEvent } from '@mk-kit/ui/dnd';
+
+/** Surface treatment for a {@link MkCard}. */
+type MkCardVariant = 'elevated' | 'outlined' | 'filled';
+/** Internal padding scale for a {@link MkCard}. */
+type MkCardPadding = 'none' | 'sm' | 'md' | 'lg';
+/**
+ * Card — a themed surface container that groups related content. Compose it
+ * with the projected `mk-card-header`, `mk-card-title` and `mk-card-footer`
+ * parts, or drop plain content straight into the body.
+ *
+ * ```html
+ * <mk-card variant="elevated">
+ *   <mk-card-header>
+ *     <mk-card-title>Monthly revenue</mk-card-title>
+ *   </mk-card-header>
+ *   Body content goes here.
+ *   <mk-card-footer>
+ *     <button mkButton variant="ghost">Details</button>
+ *   </mk-card-footer>
+ * </mk-card>
+ * ```
+ */
+declare class MkCard {
+    /** Surface treatment: raised shadow, hairline border, or tinted fill. */
+    readonly variant: _angular_core.InputSignal<MkCardVariant>;
+    /** Internal spacing applied to the body, header and footer. */
+    readonly padding: _angular_core.InputSignal<MkCardPadding>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCard, "mk-card", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["mk-card-header, [mkCardHeader]", "*", "mk-card-footer, [mkCardFooter]"], true, never>;
+}
+
+/**
+ * Card header region — a padded band separated from the body by a hairline
+ * border. Typically wraps a {@link MkCardTitle} and optional actions.
+ */
+declare class MkCardHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCardHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCardHeader, "mk-card-header, [mkCardHeader]", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Card title — semantic heading text for a card header. Renders as bold,
+ * emphasised text; wrap the projected content in your own heading element if a
+ * specific heading level is required for the document outline.
+ */
+declare class MkCardTitle {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCardTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCardTitle, "mk-card-title", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Card footer region — a padded band separated from the body by a hairline
+ * border, usually holding actions aligned to the end.
+ */
+declare class MkCardFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCardFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCardFooter, "mk-card-footer, [mkCardFooter]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/** Axis a {@link MkDivider} is drawn along. */
+type MkDividerOrientation = 'horizontal' | 'vertical';
+/**
+ * Divider — a themed separator rule. Renders horizontally by default; set
+ * `orientation="vertical"` for an inline vertical rule. Project content to
+ * label a horizontal divider (the label sits centred between two rules).
+ *
+ * ```html
+ * <mk-divider />
+ * <mk-divider>OR</mk-divider>
+ * <mk-divider orientation="vertical" />
+ * ```
+ */
+declare class MkDivider {
+    /** Axis the rule is drawn along. */
+    readonly orientation: _angular_core.InputSignal<MkDividerOrientation>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDivider, "mk-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Visual treatment for a {@link MkBadge}. */
+type MkBadgeVariant = 'solid' | 'soft' | 'outline';
+/**
+ * Badge — a compact status pill, typically for counts or short state labels.
+ * Set `dot` for a minimal notification indicator with no text.
+ *
+ * ```html
+ * <mk-badge tone="success">Active</mk-badge>
+ * <mk-badge tone="danger" variant="solid">3</mk-badge>
+ * <mk-badge tone="danger" dot aria-label="Unread messages" />
+ * ```
+ */
+declare class MkBadge {
+    /** Semantic color tone. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Visual treatment. */
+    readonly variant: _angular_core.InputSignal<MkBadgeVariant>;
+    /** Size scale. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Render as a tiny dot (no text) for notification indicators. */
+    readonly dot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkBadge, "mk-badge", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Visual treatment for a {@link MkTag}. */
+type MkTagVariant = 'solid' | 'soft' | 'outline';
+/**
+ * Tag — a non-interactive label for categories, keywords or metadata. Unlike
+ * {@link MkChip} it carries no interaction; use it purely for display.
+ *
+ * ```html
+ * <mk-tag>Design</mk-tag>
+ * <mk-tag tone="info" variant="outline">Beta</mk-tag>
+ * ```
+ */
+declare class MkTag {
+    /** Semantic color tone. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Visual treatment. */
+    readonly variant: _angular_core.InputSignal<MkTagVariant>;
+    /** Size scale. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTag, "mk-tag", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Outline shape of an {@link MkAvatar}. */
+type MkAvatarShape = 'circle' | 'rounded';
+/** Presence status shown as a corner dot on an {@link MkAvatar}. */
+type MkAvatarStatus = 'online' | 'offline' | 'away' | 'busy';
+/**
+ * Avatar — a user/entity image that gracefully falls back to initials derived
+ * from `name`, or to a projected icon. The whole avatar is exposed as a single
+ * labelled image to assistive tech.
+ *
+ * ```html
+ * <mk-avatar name="Ada Lovelace" src="/ada.jpg" status="online" />
+ * <mk-avatar name="Grace Hopper" />          <!-- initials fallback -->
+ * <mk-avatar><svg>…</svg></mk-avatar>        <!-- icon fallback -->
+ * ```
+ */
+declare class MkAvatar {
+    /** Image URL. When it fails to load the avatar falls back automatically. */
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    /** Display name; drives the initials fallback and the default alt text. */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** Explicit accessible label. Defaults to `name`, else "Avatar". */
+    readonly alt: _angular_core.InputSignal<string | undefined>;
+    /** Size scale. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Outline shape. */
+    readonly shape: _angular_core.InputSignal<MkAvatarShape>;
+    /** Presence indicator dot; omit for none. */
+    readonly status: _angular_core.InputSignal<MkAvatarStatus | undefined>;
+    /** True once the provided image has failed to load. */
+    private readonly imgFailed;
+    protected readonly showImage: _angular_core.Signal<boolean>;
+    /** Up-to-two-letter initials derived from `name`. */
+    protected readonly initials: _angular_core.Signal<string>;
+    protected readonly label: _angular_core.Signal<string>;
+    protected onError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkAvatar, "mk-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Avatar group — overlaps a set of {@link MkAvatar} children and, when `max`
+ * is set, collapses the overflow into a trailing "+N" bubble.
+ *
+ * ```html
+ * <mk-avatar-group [max]="3">
+ *   <mk-avatar name="Ada Lovelace" />
+ *   <mk-avatar name="Grace Hopper" />
+ *   <mk-avatar name="Alan Turing" />
+ *   <mk-avatar name="Katherine Johnson" />
+ * </mk-avatar-group>
+ * ```
+ */
+declare class MkAvatarGroup {
+    /** Maximum avatars to show before collapsing the rest into "+N". */
+    readonly max: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Size of the overflow bubble (match your avatars' size). */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    private readonly items;
+    protected readonly overflowCount: _angular_core.Signal<number>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkAvatarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkAvatarGroup, "mk-avatar-group", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+/**
+ * List — a vertical stack of {@link MkListItem}s with `role="list"` semantics.
+ *
+ * ```html
+ * <mk-list>
+ *   <mk-list-item>Dashboard</mk-list-item>
+ *   <mk-list-item interactive (activated)="open()">Settings</mk-list-item>
+ * </mk-list>
+ * ```
+ */
+declare class MkList {
+    /** Draw hairline separators between items. */
+    readonly bordered: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkList, "mk-list", never, { "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * List item — a row inside {@link MkList}. Project leading/trailing adornments
+ * with the `mkListLeading` / `mkListTrailing` attributes. Set `interactive`
+ * to make the row focusable and clickable (Enter/Space activate it).
+ *
+ * ```html
+ * <mk-list-item interactive [selected]="active()" (activated)="pick()">
+ *   <mk-avatar mkListLeading name="Ada" />
+ *   Ada Lovelace
+ *   <mk-badge mkListTrailing tone="success">New</mk-badge>
+ * </mk-list-item>
+ * ```
+ */
+declare class MkListItem {
+    /** Make the row focusable/clickable with hover + keyboard activation. */
+    readonly interactive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Highlight the row as the current selection. */
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable interaction and dim the row. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted on click / Enter / Space when `interactive`. */
+    readonly activated: _angular_core.OutputEmitterRef<void>;
+    protected onClick(): void;
+    protected onKeydown(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkListItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkListItem, "mk-list-item", never, { "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "activated": "activated"; }, never, ["[mkListLeading]", "*", "[mkListTrailing]"], true, never>;
+}
+
+/**
+ * EmptyState — a centered placeholder for "nothing here yet" situations: empty
+ * tables, no search results, a fresh dashboard, a cleared inbox. Provide a
+ * `title` (and usually a `description`), an `icon` or projected media, and
+ * call-to-action buttons via the actions slot.
+ *
+ * Slots: `[mkEmptyStateMedia]` (custom illustration, overrides `icon`), default
+ * content (extra body), `[mkEmptyStateActions]` (buttons).
+ *
+ * ```html
+ * <mk-empty-state icon="search" title="No results"
+ *   description="Try adjusting your filters.">
+ *   <button mkButton mkEmptyStateActions variant="outline">Clear filters</button>
+ * </mk-empty-state>
+ * ```
+ */
+declare class MkEmptyState {
+    /** Name of a registered icon shown above the title (ignored if media is projected). */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Main heading, e.g. "No invoices yet". */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Supporting sentence under the title. */
+    readonly description: _angular_core.InputSignal<string>;
+    /** Overall scale of the block. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    protected readonly iconSize: () => 28 | 48 | 36;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkEmptyState, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkEmptyState, "mk-empty-state", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["[mkEmptyStateMedia]", "*", "[mkEmptyStateActions]"], true, never>;
+}
+
+/**
+ * Timeline — a vertical sequence of chronological events (activity feeds, order
+ * status, audit logs). A container for `<mk-timeline-item>`s that draws the
+ * connecting rail; exposed to assistive tech as a list.
+ *
+ * ```html
+ * <mk-timeline>
+ *   <mk-timeline-item tone="success" time="09:30" heading="Order placed">
+ *     Payment confirmed.
+ *   </mk-timeline-item>
+ *   <mk-timeline-item time="10:15" heading="Packed">In the warehouse.</mk-timeline-item>
+ * </mk-timeline>
+ * ```
+ */
+declare class MkTimeline {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTimeline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTimeline, "mk-timeline", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A single event in an `<mk-timeline>`: a tone-coloured marker (optionally an
+ * icon), an optional time/label and heading, and projected body content.
+ *
+ * ```html
+ * <mk-timeline-item tone="danger" icon="error" time="2m ago" heading="Build failed">
+ *   3 tests failed on <code>main</code>.
+ * </mk-timeline-item>
+ * ```
+ */
+declare class MkTimelineItem {
+    /** Semantic colour of the marker dot. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Name of a registered icon rendered inside the marker. */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Time or label shown above the heading (e.g. "09:30", "2m ago"). */
+    readonly time: _angular_core.InputSignal<string>;
+    /** Event title. */
+    readonly heading: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTimelineItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTimelineItem, "mk-timeline-item", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "time": { "alias": "time"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Direction of a {@link MkStatCard} delta. */
+type MkStatTrend = 'up' | 'down' | 'neutral';
+/**
+ * Stat card — a compact KPI tile for dashboards. Shows a label, a primary
+ * value and an optional trend delta. The trend is conveyed by an arrow glyph
+ * and a screen-reader phrase in addition to colour, so it never relies on
+ * colour alone.
+ *
+ * ```html
+ * <mk-stat-card
+ *   label="Revenue"
+ *   value="$48.2k"
+ *   [delta]="'+12%'"
+ *   deltaTrend="up"
+ *   hint="vs. last month">
+ *   <svg mkStatIcon>…</svg>
+ * </mk-stat-card>
+ * ```
+ */
+declare class MkStatCard {
+    /** Metric name shown above the value. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** The primary metric value. */
+    readonly value: _angular_core.InputSignal<string | number>;
+    /** Change indicator (e.g. `'+12%'` or `-4`). Omit to hide the delta row. */
+    readonly delta: _angular_core.InputSignal<string | number | undefined>;
+    /** Trend direction; colourises the delta and picks the arrow glyph. */
+    readonly deltaTrend: _angular_core.InputSignal<MkStatTrend>;
+    /** Small supporting note under the delta (e.g. "vs. last month"). */
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    protected readonly labelId: string;
+    protected readonly hasDelta: _angular_core.Signal<boolean>;
+    /** Arrow glyph for the current trend. */
+    protected readonly arrow: _angular_core.Signal<"↑" | "↓" | "→">;
+    /** Screen-reader phrase describing the trend. */
+    protected readonly trendLabel: _angular_core.Signal<"Trending up" | "Trending down" | "No change">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkStatCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkStatCard, "mk-stat-card", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "delta": { "alias": "delta"; "required": false; "isSignal": true; }; "deltaTrend": { "alias": "deltaTrend"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; }, {}, never, ["[mkStatIcon]"], true, never>;
+}
+
+/** Layout direction of a {@link MkProfileCard}. */
+type MkProfileCardOrientation = 'vertical' | 'horizontal';
+/**
+ * Profile meta row — a stats strip projected into a {@link MkProfileCard}
+ * between the body and the actions. Direct children are laid out as
+ * evenly-spaced, centre-aligned cells with subtle separators between them.
+ *
+ * ```html
+ * <div mkProfileMeta>
+ *   <div><strong>128</strong> posts</div>
+ *   <div><strong>2.4k</strong> followers</div>
+ * </div>
+ * ```
+ */
+declare class MkProfileMeta {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkProfileMeta, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkProfileMeta, "[mkProfileMeta]", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Profile actions row — buttons projected into the footer area of a
+ * {@link MkProfileCard}. Centred in vertical orientation; pinned to the end
+ * in horizontal orientation.
+ *
+ * ```html
+ * <div mkProfileActions>
+ *   <button mkButton>Follow</button>
+ *   <button mkButton variant="outline">Message</button>
+ * </div>
+ * ```
+ */
+declare class MkProfileActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkProfileActions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkProfileActions, "[mkProfileActions]", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Profile card — a person/entity summary on a bordered surface: an optional
+ * cover banner, an {@link MkAvatar} (with automatic initials fallback derived
+ * from `name`), the display name, a muted subtitle, free-form body content and
+ * two optional slots for a meta/stats row and an actions row.
+ *
+ * Orientations:
+ * - `vertical` (default) — centred column; when `coverSrc` is set a 3:1 banner
+ *   spans the card top and the avatar overlaps its bottom edge with a
+ *   surface-coloured ring.
+ * - `horizontal` — avatar on the left, text in the middle, actions pinned to
+ *   the end. The cover banner is intentionally NOT rendered in this
+ *   orientation (a side-by-side row has no top edge for it to crown).
+ *
+ * The name renders as emphasised generic text (like `mk-card-title`, no
+ * hard-coded heading level) so the card never disrupts the document outline.
+ *
+ * ```html
+ * <mk-profile-card
+ *   name="Ada Lovelace"
+ *   subtitle="Analytical Engine Programmer"
+ *   avatarSrc="/ada.jpg"
+ *   coverSrc="/cover.jpg">
+ *   First programmer. Wrote notes G through... well, all of them.
+ *   <div mkProfileMeta>
+ *     <div><strong>128</strong> posts</div>
+ *     <div><strong>2.4k</strong> followers</div>
+ *     <div><strong>310</strong> following</div>
+ *   </div>
+ *   <div mkProfileActions>
+ *     <button mkButton>Follow</button>
+ *     <button mkButton variant="outline">Message</button>
+ *   </div>
+ * </mk-profile-card>
+ * ```
+ */
+declare class MkProfileCard {
+    /** Display name. Also drives the avatar's initials fallback and alt text. */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Muted supporting line under the name (role, handle, email…). */
+    readonly subtitle: _angular_core.InputSignal<string>;
+    /** Avatar image URL; when empty the avatar falls back to initials. */
+    readonly avatarSrc: _angular_core.InputSignal<string>;
+    /**
+     * Cover banner image URL rendered as a ~3:1 band across the card top
+     * (vertical orientation only). When set, the avatar overlaps the banner's
+     * bottom edge with a surface-coloured ring.
+     */
+    readonly coverSrc: _angular_core.InputSignal<string>;
+    /** Layout: centred column (`vertical`) or avatar-left row (`horizontal`). */
+    readonly orientation: _angular_core.InputSignal<MkProfileCardOrientation>;
+    /** Avatar size scale, forwarded to {@link MkAvatar}. */
+    readonly avatarSize: _angular_core.InputSignal<MkSize>;
+    /** Id of the name element, wired to the host's `aria-labelledby`. */
+    protected readonly nameId: string;
+    /** Cover renders only in vertical orientation. */
+    protected readonly showCover: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkProfileCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkProfileCard, "mk-profile-card", ["mkProfileCard"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "avatarSrc": { "alias": "avatarSrc"; "required": false; "isSignal": true; }; "coverSrc": { "alias": "coverSrc"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "avatarSize": { "alias": "avatarSize"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[mkProfileMeta]", "[mkProfileActions]"], true, never>;
+}
+
+/**
+ * Progress bar — a determinate (0–100) or indeterminate progress indicator
+ * with `role="progressbar"`. `aria-valuenow` is omitted while indeterminate.
+ * The indeterminate animation respects `prefers-reduced-motion`.
+ *
+ * ```html
+ * <mk-progress-bar [value]="uploaded()" label="Uploading" showValue />
+ * <mk-progress-bar indeterminate label="Loading" />
+ * ```
+ */
+declare class MkProgressBar {
+    /** Completion percentage 0–100 (ignored while indeterminate). */
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show an animated indeterminate bar with no known completion. */
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Semantic color tone of the fill. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Track thickness. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Optional visible caption; also labels the bar for assistive tech. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Show the numeric percentage next to the label (determinate only). */
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly labelId: string;
+    /** Value clamped into the valid 0–100 range and rounded. */
+    protected readonly clamped: _angular_core.Signal<number>;
+    /**
+     * Inline transform for the determinate fill. Scaling instead of animating
+     * `width` keeps the transition compositor-only (no layout per frame).
+     */
+    protected readonly fillTransform: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkProgressBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkProgressBar, "mk-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * ProgressRing — a circular progress indicator. Determinate by default (an arc
+ * proportional to `value`); set `indeterminate` for a spinner-style preloader
+ * when progress is unknown. Themed by `tone`, sized by `size`.
+ *
+ * ```html
+ * <mk-progress-ring [value]="uploaded()" showLabel />
+ * <mk-progress-ring indeterminate tone="neutral" [size]="24" />
+ * <mk-progress-ring [value]="72" tone="success"><mk-icon name="check" /></mk-progress-ring>
+ * ```
+ */
+declare class MkProgressRing {
+    /** Current progress value (clamped to `[0, max]`). Ignored when indeterminate. */
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Maximum value. Default `100`. */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Diameter in px. Default `48`. */
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Ring thickness in px. Default `4`. */
+    readonly thickness: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Semantic colour of the progress arc. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Show a rotating arc for unknown-duration work (a circular preloader). */
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the percentage in the centre. */
+    readonly showLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible label (recommended, especially when indeterminate). */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly clampedValue: _angular_core.Signal<number>;
+    protected readonly fraction: _angular_core.Signal<number>;
+    protected readonly percent: _angular_core.Signal<number>;
+    protected readonly radius: _angular_core.Signal<number>;
+    protected readonly circumference: _angular_core.Signal<number>;
+    /** Dash offset that reveals `fraction` of the circle. */
+    protected readonly dashOffset: _angular_core.Signal<number>;
+    protected readonly center: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkProgressRing, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkProgressRing, "mk-progress-ring", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Spinner — a circular indeterminate loading indicator. Exposes `role="status"`
+ * with a visually-hidden label so assistive tech announces the loading state.
+ * The animation slows under `prefers-reduced-motion`.
+ *
+ * ```html
+ * <mk-spinner />
+ * <mk-spinner size="lg" tone="neutral" label="Fetching results" />
+ * ```
+ */
+declare class MkSpinner {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Size scale. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Semantic color tone. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Visually-hidden status label announced to screen readers. */
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSpinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSpinner, "mk-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Shared, framework-agnostic helpers for the mk-kit SVG charts. Pure functions
+ * only — no Angular, no DOM — so they stay trivially testable and reusable.
+ */
+/** A named data series for multi-series charts. */
+interface MkChartSeries {
+    /** Legend/tooltip label (identity — always shown, never colour-alone). */
+    name: string;
+    /** The values, one per category/x position. */
+    data: number[];
+    /** Optional explicit colour; defaults to the validated palette by index. */
+    color?: string;
+}
+/** A single slice for the donut/pie chart. */
+interface MkChartSlice {
+    /** Slice label. */
+    name: string;
+    /** Slice value (summed to compute proportions). */
+    value: number;
+    /** Optional explicit colour; defaults to the palette by index. */
+    color?: string;
+}
+/** A resolved 2-D point in SVG user space. */
+interface MkPoint {
+    x: number;
+    y: number;
+}
+/** Number of hues in the validated categorical palette (`--mk-chart-1..8`). */
+declare const MK_CHART_PALETTE_SIZE = 8;
+/**
+ * Categorical colour for a series index — a CSS reference to the validated
+ * `--mk-chart-N` token. Assigned in fixed order and wrapped past 8 (prefer
+ * folding a 9th series into "Other" over relying on the wrap).
+ */
+declare function mkChartColor(index: number): string;
+/** Build a linear scale mapping `[d0,d1]` (domain) onto `[r0,r1]` (range). */
+declare function mkLinearScale(d0: number, d1: number, r0: number, r1: number): (value: number) => number;
+/**
+ * "Nice" rounded tick values covering `[min,max]` with roughly `count` steps —
+ * used for value axes so gridlines land on human numbers.
+ */
+declare function mkNiceTicks(min: number, max: number, count?: number): number[];
+/** Straight-segment SVG path (`M … L …`) through the given points. */
+declare function mkLinePath(points: readonly MkPoint[]): string;
+/**
+ * Closed area path under a line: the line, dropped to `baselineY` at each end.
+ */
+declare function mkAreaPath(points: readonly MkPoint[], baselineY: number): string;
+/**
+ * SVG arc path for a donut/pie slice between two angles (radians, clockwise
+ * from 12 o'clock). `inner` of 0 yields a pie wedge; > 0 yields a ring segment.
+ */
+declare function mkArcPath(cx: number, cy: number, outer: number, inner: number, startAngle: number, endAngle: number): string;
+/** Compact number formatting for axes/tooltips (1.2k, 3.4M). */
+declare function mkFormatCompact(value: number): string;
+
+/** Visual form of a {@link MkSparkline}. */
+type MkSparklineType = 'line' | 'area' | 'bar';
+/**
+ * Sparkline — a tiny, axis-less trend chart sized to sit inline in a table
+ * cell, stat card or list row. Single series only; it's a *mark*, so it carries
+ * no legend or tooltip (give context with the surrounding label + `label`).
+ *
+ * ```html
+ * <mk-sparkline [data]="[3,5,4,7,6,9,8]" type="area" />
+ * <mk-sparkline [data]="visits()" [width]="80" showDot
+ *   color="var(--mk-success)" label="Weekly visits" />
+ * ```
+ */
+declare class MkSparkline {
+    /** The values to plot (left → right). */
+    readonly data: _angular_core.InputSignal<readonly number[]>;
+    /** Visual form. */
+    readonly type: _angular_core.InputSignal<MkSparklineType>;
+    /** Any CSS colour; defaults to the first chart hue. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Intrinsic width in px (the SVG scales with its box). */
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Intrinsic height in px. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Line/area stroke width. */
+    readonly strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Draw a dot on the last point (line/area only). */
+    readonly showDot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fixed domain minimum (defaults to the data min). */
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    /** Fixed domain maximum (defaults to the data max). */
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    /** Accessible label; a data summary is generated when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    private readonly pad;
+    private readonly domain;
+    protected readonly points: _angular_core.Signal<MkPoint[]>;
+    protected readonly linePath: _angular_core.Signal<string>;
+    protected readonly areaPath: _angular_core.Signal<string>;
+    /** Bar geometry for the `bar` type. */
+    protected readonly bars: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[]>;
+    protected readonly lastPoint: _angular_core.Signal<MkPoint | null>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSparkline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSparkline, "mk-sparkline", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "showDot": { "alias": "showDot"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface BarRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    color: string;
+    seriesIndex: number;
+    categoryIndex: number;
+    value: number;
+}
+interface GridLine {
+    value: number;
+    label: string;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    labelX: number;
+    labelY: number;
+}
+interface Band {
+    label: string;
+    labelX: number;
+    labelY: number;
+    /** SVG transform when the axis is tilted; `null` when labels sit flat. */
+    transform: string | null;
+}
+/** Bar orientation. */
+type MkBarOrientation = 'vertical' | 'horizontal';
+/**
+ * BarChart — compares a measure across categories with one or more series
+ * (grouped or `stacked`), `vertical` (default) or `horizontal`. Dependency-free
+ * SVG on the validated `--mk-chart-*` palette; ships a legend for ≥ 2 series, a
+ * value axis with gridlines, per-bar hover tooltips and a screen-reader table.
+ *
+ * ```html
+ * <mk-bar-chart orientation="horizontal"
+ *   [categories]="['Q1','Q2','Q3','Q4']"
+ *   [series]="[{ name: 'Revenue', data: [12,19,15,22] }]" />
+ * ```
+ */
+declare class MkBarChart {
+    /** Measured host width (falls back to `width` before first measure). */
+    private readonly autoWidth;
+    /** The viewBox width the geometry is drawn against. */
+    protected readonly drawWidth: _angular_core.Signal<number>;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Category labels along the category axis. */
+    readonly categories: _angular_core.InputSignal<readonly string[]>;
+    /** One or more data series (values align to `categories`). */
+    readonly series: _angular_core.InputSignal<readonly MkChartSeries[]>;
+    /** Bar direction. */
+    readonly orientation: _angular_core.InputSignal<MkBarOrientation>;
+    /** Intrinsic width in viewBox units — the fallback before the host is
+     *  measured, and the fixed drawing width when `responsive` is off. */
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Match the viewBox width to the host's actual width so `height` means
+     * pixels and a wide container no longer stretches the chart vertically.
+     * Set false to pin the drawing to `width` (the pre-0.8 behaviour).
+     */
+    readonly responsive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Intrinsic height. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Stack series into one bar per category instead of grouping. */
+    readonly stacked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show gridlines behind the bars. */
+    readonly showGrid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the legend on/off (defaults to on when there are ≥ 2 series). */
+    readonly showLegend: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Category-label tilt in degrees. `'auto'` (the default) leaves labels flat
+     * while they fit and tilts them 45° when they would collide — the axis of a
+     * narrow chart is otherwise an unreadable smear. A number pins the angle
+     * (0 = always flat, 30/45 = always tilted); values are clamped to 0…90.
+     *
+     * Tilting reserves the extra vertical room it needs, so `height` still means
+     * the height you asked for. When even tilted labels cannot fit, the chart
+     * thins them — every Nth label is dropped rather than overlapped.
+     */
+    readonly labelAngle: _angular_core.InputSignal<number | "auto">;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly hovered: _angular_core.WritableSignal<BarRect | null>;
+    /** Tap-to-pin: a touch tap on a bar pins the tooltip until a tap lands
+     *  outside the chart (mouse hover in/out is unaffected). */
+    private readonly tapPin;
+    protected readonly horizontal: _angular_core.Signal<boolean>;
+    /** Widest category label, in estimated px. */
+    private readonly widestLabelPx;
+    /**
+     * The tilt actually applied. `auto` stays flat while the labels fit their
+     * band and tilts 45° otherwise; an explicit number always wins (clamped).
+     * Horizontal bars put categories on the Y axis, where tilting makes no
+     * sense, so they are always flat.
+     */
+    protected readonly resolvedAngle: _angular_core.Signal<number>;
+    /**
+     * Show every Nth label. Tilting buys room but not unlimited room: at 45° a
+     * label still occupies `width * cos(45°)` horizontally, so a 24-category
+     * chart in a card can need thinning on top of the tilt. Dropping labels
+     * beats overlapping them — the bars all still draw.
+     */
+    protected readonly labelStep: _angular_core.Signal<number>;
+    private readonly margin;
+    protected readonly plot: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    protected readonly colors: _angular_core.Signal<string[]>;
+    protected readonly legendVisible: _angular_core.Signal<boolean>;
+    private readonly maxValue;
+    protected readonly ticks: _angular_core.Signal<number[]>;
+    private readonly tickMax;
+    /** Pixel position along the value axis for a value. */
+    private readonly valuePos;
+    /** Gridlines + value-axis labels (orientation-aware). */
+    protected readonly gridRows: _angular_core.Signal<GridLine[]>;
+    /** Category-axis labels. */
+    protected readonly bands: _angular_core.Signal<Band[]>;
+    /** All bar rectangles (grouped or stacked, vertical or horizontal). */
+    protected readonly bars: _angular_core.Signal<BarRect[]>;
+    protected readonly legend: _angular_core.Signal<{
+        name: string;
+        color: string;
+    }[]>;
+    /** Tooltip position (percent of viewBox) + content for the hovered bar. */
+    protected readonly tooltip: _angular_core.Signal<{
+        left: number;
+        top: number;
+        category: string;
+        series: string;
+        color: string;
+        value: string;
+        multi: boolean;
+    } | null>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    protected setHover(bar: BarRect | null): void;
+    protected pinHover(bar: BarRect, event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkBarChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkBarChart, "mk-bar-chart", never, { "categories": { "alias": "categories"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "labelAngle": { "alias": "labelAngle"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * LineChart — a line (or `area`) chart for change over time / ordered
+ * categories, with one or more series. Dependency-free SVG on the validated
+ * `--mk-chart-*` palette; ships a legend for ≥ 2 series, a value axis, a
+ * hover crosshair with a shared tooltip, and a screen-reader data table.
+ *
+ * ```html
+ * <mk-line-chart area
+ *   [categories]="months"
+ *   [series]="[{ name: 'Sessions', data: sessions() }]" />
+ * ```
+ */
+declare class MkLineChart {
+    /** Measured host width (falls back to `width` before first measure). */
+    private readonly autoWidth;
+    /** The viewBox width the geometry is drawn against. */
+    protected readonly drawWidth: _angular_core.Signal<number>;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Ordered category labels along the x axis. */
+    readonly categories: _angular_core.InputSignal<readonly string[]>;
+    /** One or more data series (values align to `categories`). */
+    readonly series: _angular_core.InputSignal<readonly MkChartSeries[]>;
+    /** Intrinsic width in viewBox units — the fallback before the host is
+     *  measured, and the fixed drawing width when `responsive` is off. */
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Match the viewBox width to the host's actual width so `height` means
+     * pixels and a wide container no longer stretches the chart vertically.
+     * Set false to pin the drawing to `width` (the pre-0.8 behaviour).
+     */
+    readonly responsive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Intrinsic height. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Fill the area under each line. */
+    readonly area: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Stack the series (cumulative bands) — implies filled areas. */
+    readonly stacked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Draw a dot at every data point. */
+    readonly showDots: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show gridlines. */
+    readonly showGrid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the legend on/off (defaults to on when there are ≥ 2 series). */
+    readonly showLegend: _angular_core.InputSignal<boolean | undefined>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly hoverIndex: _angular_core.WritableSignal<number | null>;
+    /** Tap-to-pin: a touch tap on a hit band pins the tooltip until a tap lands
+     *  outside the chart (mouse hover in/out is unaffected). */
+    private readonly tapPin;
+    protected readonly plot: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    protected readonly colors: _angular_core.Signal<string[]>;
+    protected readonly legendVisible: _angular_core.Signal<boolean>;
+    private readonly extent;
+    protected readonly ticks: _angular_core.Signal<number[]>;
+    private readonly domain;
+    private readonly toY;
+    private readonly xAt;
+    protected readonly gridRows: _angular_core.Signal<{
+        value: number;
+        label: string;
+        y: number;
+    }[]>;
+    /** Per-series rendered geometry (points + line + area paths). */
+    protected readonly rendered: _angular_core.Signal<{
+        name: string;
+        color: string;
+        points: MkPoint[];
+        line: string;
+        area: string;
+    }[]>;
+    /** Whether to paint the filled areas. */
+    protected readonly fillAreas: _angular_core.Signal<boolean>;
+    /** Transparent hit bands (one per category) driving the shared tooltip. */
+    protected readonly hitBands: _angular_core.Signal<{
+        index: number;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }[]>;
+    protected readonly crosshairX: _angular_core.Signal<number | null>;
+    protected readonly legend: _angular_core.Signal<{
+        name: string;
+        color: string;
+    }[]>;
+    /** Hovered-point markers + tooltip payload for the active category. */
+    protected readonly activePoints: _angular_core.Signal<{
+        color: string;
+        name: string;
+        x: number;
+        y: number;
+        value: number;
+    }[]>;
+    protected readonly tooltip: _angular_core.Signal<{
+        left: number;
+        top: number;
+        category: string;
+        rows: {
+            color: string;
+            name: string;
+            value: string;
+        }[];
+        multi: boolean;
+    } | null>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    protected setHover(index: number | null): void;
+    protected pinHover(index: number, event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkLineChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkLineChart, "mk-line-chart", never, { "categories": { "alias": "categories"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface SliceGeom {
+    name: string;
+    value: number;
+    color: string;
+    path: string;
+    percent: number;
+    midAngle: number;
+    index: number;
+}
+/**
+ * DonutChart — proportions of a whole as a ring (or a full pie when
+ * `thickness` covers the radius). Dependency-free SVG on the validated
+ * `--mk-chart-*` palette; ships a value/percent legend, per-slice hover
+ * tooltips, an optional centre label, and a screen-reader data table.
+ *
+ * ```html
+ * <mk-donut-chart centerLabel="1,240" centerSublabel="Total"
+ *   [slices]="[{ name: 'Direct', value: 540 }, { name: 'Search', value: 700 }]" />
+ * ```
+ */
+declare class MkDonutChart {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The slices; each `value` contributes to the whole. */
+    readonly slices: _angular_core.InputSignal<readonly MkChartSlice[]>;
+    /** Diameter in viewBox units (the SVG scales to its container). */
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Ring thickness. Set `0` (or ≥ radius) for a full pie. */
+    readonly thickness: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show the legend with values + percentages. */
+    readonly showLegend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Big centre label (e.g. a total). Donut only. */
+    readonly centerLabel: _angular_core.InputSignal<string>;
+    /** Small centre caption under the label. */
+    readonly centerSublabel: _angular_core.InputSignal<string>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly hovered: _angular_core.WritableSignal<number | null>;
+    /** Tap-to-pin: a touch tap on a slice pins the tooltip until a tap lands
+     *  outside the chart (mouse hover in/out is unaffected). */
+    private readonly tapPin;
+    protected readonly total: _angular_core.Signal<number>;
+    protected readonly center: _angular_core.Signal<number>;
+    protected readonly outerRadius: _angular_core.Signal<number>;
+    protected readonly innerRadius: _angular_core.Signal<number>;
+    protected readonly geom: _angular_core.Signal<SliceGeom[]>;
+    protected readonly legend: _angular_core.Signal<{
+        name: string;
+        color: string;
+        value: string;
+        percent: number;
+    }[]>;
+    protected readonly tooltip: _angular_core.Signal<{
+        left: number;
+        top: number;
+        name: string;
+        color: string;
+        value: string;
+        percent: number;
+    } | null>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    protected setHover(index: number | null): void;
+    protected pinHover(index: number, event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDonutChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDonutChart, "mk-donut-chart", never, { "slices": { "alias": "slices"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "centerLabel": { "alias": "centerLabel"; "required": false; "isSignal": true; }; "centerSublabel": { "alias": "centerSublabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Gauge — a single-metric radial dial (a KPI: "68% of quota"). Dependency-free
+ * SVG: a track arc with a value arc filled proportionally to `value` on the
+ * `[min, max]` scale, and a centred value + label. The sweep is configurable
+ * (`arc`, default 270°). Exposes `role="meter"` for assistive tech.
+ *
+ * ```html
+ * <mk-gauge [value]="68" label="of quota" unit="%" />
+ * ```
+ */
+declare class MkGauge {
+    /** The current value. */
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Scale minimum. */
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Scale maximum. */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Sweep of the arc in degrees (30–360). */
+    readonly arc: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Intrinsic size (viewBox units; the SVG scales to its container). */
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Arc thickness. */
+    readonly thickness: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Value-arc colour. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Track (background arc) colour. */
+    readonly trackColor: _angular_core.InputSignal<string>;
+    /** Label under the value. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Unit appended to the value (e.g. `%`). */
+    readonly unit: _angular_core.InputSignal<string>;
+    /** Override the centred value text. */
+    readonly valueText: _angular_core.InputSignal<string>;
+    private readonly TAU;
+    protected readonly cx: _angular_core.Signal<number>;
+    protected readonly cy: _angular_core.Signal<number>;
+    private readonly rOuter;
+    private readonly rInner;
+    /** Value clamped to [min, max] then normalised to 0–1. */
+    protected readonly fraction: _angular_core.Signal<number>;
+    private readonly sweep;
+    /** Arc starts after half the gap, measured clockwise from 6 o'clock. */
+    private readonly startAngle;
+    protected readonly trackPath: _angular_core.Signal<string>;
+    protected readonly valuePath: _angular_core.Signal<string>;
+    protected readonly centerText: _angular_core.Signal<string>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkGauge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkGauge, "mk-gauge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "arc": { "alias": "arc"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "valueText": { "alias": "valueText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A single plotted point. `size` (optional) turns it into a bubble. */
+interface MkScatterPoint {
+    x: number;
+    y: number;
+    /** Value driving the bubble radius when `bubble` sizing is used. */
+    size?: number;
+    /** Optional label shown in the tooltip. */
+    label?: string;
+}
+/** A named group of scatter points sharing a colour. */
+interface MkScatterSeries {
+    name: string;
+    color?: string;
+    points: readonly MkScatterPoint[];
+}
+interface RenderedPoint {
+    cx: number;
+    cy: number;
+    r: number;
+    color: string;
+    seriesName: string;
+    x: number;
+    y: number;
+    label?: string;
+}
+/**
+ * ScatterChart — plot (x, y) points across two numeric axes to reveal
+ * correlation and clusters. Give each point a `size` to render a bubble chart.
+ * Dependency-free SVG on the validated `--mk-chart-*` palette; ships nice-tick
+ * axes, a legend for ≥ 2 series, a per-point hover tooltip and a screen-reader
+ * data table.
+ *
+ * ```html
+ * <mk-scatter-chart
+ *   xLabel="Spend" yLabel="Revenue"
+ *   [series]="[{ name: 'Q3', points: pts() }]" />
+ * ```
+ */
+declare class MkScatterChart {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** One or more point series. */
+    readonly series: _angular_core.InputSignal<readonly MkScatterSeries[]>;
+    /** Intrinsic width (viewBox units; the SVG scales to its container). */
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Intrinsic height. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Radius of each point when not sizing by `size`. */
+    readonly pointRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Size points by their `size` value (bubble chart). */
+    readonly bubble: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Largest bubble radius when `bubble` is on. */
+    readonly maxRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show gridlines. */
+    readonly showGrid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the legend on/off (defaults to on when there are ≥ 2 series). */
+    readonly showLegend: _angular_core.InputSignal<boolean | undefined>;
+    /** x-axis title. */
+    readonly xLabel: _angular_core.InputSignal<string>;
+    /** y-axis title. */
+    readonly yLabel: _angular_core.InputSignal<string>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly hoverKey: _angular_core.WritableSignal<string | null>;
+    /** Tap-to-pin: a touch tap on a point pins the tooltip until a tap lands
+     *  outside the chart (mouse hover in/out is unaffected). */
+    private readonly tapPin;
+    protected readonly plot: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    protected readonly colors: _angular_core.Signal<string[]>;
+    protected readonly legendVisible: _angular_core.Signal<boolean>;
+    private readonly allPoints;
+    private readonly xExtent;
+    private readonly yExtent;
+    protected readonly xTicks: _angular_core.Signal<number[]>;
+    protected readonly yTicks: _angular_core.Signal<number[]>;
+    private readonly xScale;
+    private readonly yScale;
+    private readonly sizeExtent;
+    private radiusFor;
+    /** Gridlines + axis-tick geometry. */
+    protected readonly xGrid: _angular_core.Signal<{
+        value: number;
+        label: string;
+        x: number;
+        y1: number;
+        y2: number;
+    }[]>;
+    protected readonly yGrid: _angular_core.Signal<{
+        value: number;
+        label: string;
+        y: number;
+        x1: number;
+        x2: number;
+    }[]>;
+    /** Every point positioned for rendering. */
+    protected readonly points: _angular_core.Signal<RenderedPoint[]>;
+    protected keyOf(index: number): string;
+    protected readonly legend: _angular_core.Signal<{
+        name: string;
+        color: string;
+    }[]>;
+    protected readonly tooltip: _angular_core.Signal<{
+        left: number;
+        top: number;
+        color: string;
+        title: string;
+        x: string;
+        y: string;
+    } | null>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    protected setHover(key: string | null): void;
+    protected pinHover(key: string, event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkScatterChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkScatterChart, "mk-scatter-chart", never, { "series": { "alias": "series"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "pointRadius": { "alias": "pointRadius"; "required": false; "isSignal": true; }; "bubble": { "alias": "bubble"; "required": false; "isSignal": true; }; "maxRadius": { "alias": "maxRadius"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "xLabel": { "alias": "xLabel"; "required": false; "isSignal": true; }; "yLabel": { "alias": "yLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface HeatCell {
+    value: number | null;
+    display: string;
+    xLabel: string;
+    bg: string;
+    strong: boolean;
+}
+interface HeatRow {
+    label: string;
+    cells: HeatCell[];
+}
+/**
+ * Heatmap — a matrix of cells shaded by value intensity, for correlation
+ * grids, activity-by-time tables and the like. Rendered as a semantic
+ * `<table>` (so it is inherently screen-reader friendly) with cell colours
+ * mixed from `accent` over the surface via `color-mix`, so it tracks the theme.
+ *
+ * ```html
+ * <mk-heatmap
+ *   [xLabels]="hours" [yLabels]="days" [data]="matrix()" showValues />
+ * ```
+ */
+declare class MkHeatmap {
+    /** Column labels (x axis). */
+    readonly xLabels: _angular_core.InputSignal<readonly string[]>;
+    /** Row labels (y axis). */
+    readonly yLabels: _angular_core.InputSignal<readonly string[]>;
+    /** Row-major matrix: `data[row][col]`. Use `null` for a blank cell. */
+    readonly data: _angular_core.InputSignal<readonly (readonly (number | null)[])[]>;
+    /** Override the low end of the colour domain (defaults to the data min). */
+    readonly min: _angular_core.InputSignal<number | null>;
+    /** Override the high end of the colour domain (defaults to the data max). */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Base colour mixed over the surface for intensity. */
+    readonly accent: _angular_core.InputSignal<string>;
+    /** Print each cell's value inside it. */
+    readonly showValues: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the min→max colour scale legend. */
+    readonly showScale: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Formatter for cell + legend values. */
+    readonly format: _angular_core.InputSignal<(value: number) => string>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    private readonly domain;
+    /** Fraction (0–1) of the domain a value sits at. */
+    private ratio;
+    protected readonly rows: _angular_core.Signal<HeatRow[]>;
+    /** Legend swatches from 0 → 1 intensity. */
+    protected readonly scaleStops: _angular_core.Signal<{
+        min: string;
+        max: string;
+        swatches: string[];
+    }>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkHeatmap, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkHeatmap, "mk-heatmap", never, { "xLabels": { "alias": "xLabels"; "required": false; "isSignal": true; }; "yLabels": { "alias": "yLabels"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "accent": { "alias": "accent"; "required": false; "isSignal": true; }; "showValues": { "alias": "showValues"; "required": false; "isSignal": true; }; "showScale": { "alias": "showScale"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** One day's datum for `mk-calendar-heatmap`. */
+interface MkCalendarHeatmapEntry {
+    /**
+     * The day — a `Date`, or a string. `YYYY-MM-DD` strings are parsed as
+     * **local** dates (never UTC-shifted); other strings go through `new Date()`.
+     */
+    date: Date | string;
+    /** The day's value (e.g. an activity count). Multiple entries for the same day are summed. */
+    value: number;
+}
+/** Payload of `mk-calendar-heatmap`'s `cellClick`. */
+interface MkCalendarHeatmapCell {
+    /** The clicked day (local midnight). */
+    date: Date;
+    /** The day's aggregated value (0 when no entry exists). */
+    value: number;
+}
+interface DayCell {
+    key: string;
+    /** `null` for grid padding outside the displayed range. */
+    date: Date | null;
+    value: number;
+    bg: string;
+    title: string | null;
+}
+interface WeekdayRow {
+    label: string;
+    /** Visually show the label (Mon/Wed/Fri style); hidden rows keep it for SR. */
+    showLabel: boolean;
+    cells: DayCell[];
+}
+interface MonthSegment {
+    key: string;
+    label: string;
+    /** Number of week columns the month header spans. */
+    span: number;
+}
+/**
+ * Calendar heatmap — a GitHub-style year of daily squares: weeks as columns,
+ * weekdays as rows, each day shaded by its value. Rendered as a semantic
+ * `<table>` (month headers span their week columns, weekday names are row
+ * headers, every cell carries its formatted value for screen readers) with
+ * intensities mixed from `color` over the surface via `color-mix`, so it
+ * tracks the theme. Values are bucketed linearly against the range maximum
+ * into `levels` steps; days with value 0 (or no entry) render transparent.
+ *
+ * Shows the last 12 months ending today by default; set `year` for a fixed
+ * calendar year.
+ *
+ * ```html
+ * <mk-calendar-heatmap
+ *   [data]="contributions"
+ *   [year]="2026"
+ *   (cellClick)="openDay($event.date)"
+ * />
+ * ```
+ */
+declare class MkCalendarHeatmap {
+    /** The daily values. Days without an entry count as 0. */
+    readonly data: _angular_core.InputSignal<readonly MkCalendarHeatmapEntry[]>;
+    /** Show a fixed calendar year; unset shows the last 12 months ending today. */
+    readonly year: _angular_core.InputSignalWithTransform<number | null, string | number | null>;
+    /** First weekday of the columns: 0 = Sunday … 6 = Saturday. */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Base colour mixed over the surface for intensity. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Number of intensity buckets in the ramp. */
+    readonly levels: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Formatter for each cell's title / screen-reader text (and legend max). */
+    readonly format: _angular_core.InputSignal<((date: Date, value: number) => string) | null>;
+    /** Show the less→more colour ramp legend. */
+    readonly showScale: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Emits the clicked day and its value. */
+    readonly cellClick: _angular_core.OutputEmitterRef<MkCalendarHeatmapCell>;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Aggregated value per day key (duplicate entries are summed). */
+    private readonly values;
+    /** Displayed [start, end] range, both at local midnight, inclusive. */
+    private readonly range;
+    private readonly sanitizedLevels;
+    private readonly layout;
+    protected readonly rows: _angular_core.Signal<WeekdayRow[]>;
+    protected readonly monthSegments: _angular_core.Signal<MonthSegment[]>;
+    /** Legend: 0 → max swatches mixed exactly like the cells. */
+    protected readonly scaleStops: _angular_core.Signal<{
+        min: string;
+        max: string;
+        swatches: string[];
+    }>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    private readonly defaultFormat;
+    protected onCellClick(cell: DayCell): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCalendarHeatmap, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCalendarHeatmap, "mk-calendar-heatmap", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "year": { "alias": "year"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "levels": { "alias": "levels"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "showScale": { "alias": "showScale"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "cellClick": "cellClick"; }, never, never, true, never>;
+}
+
+interface RadarPoint {
+    x: number;
+    y: number;
+}
+interface RadarSeries {
+    name: string;
+    color: string;
+    polygon: string;
+    points: RadarPoint[];
+}
+interface RadarAxis {
+    label: string;
+    x: number;
+    y: number;
+    lx: number;
+    ly: number;
+    anchor: 'start' | 'middle' | 'end';
+}
+/**
+ * RadarChart — a radar / spider chart comparing several series across the same
+ * set of axes (skills, product profiles, survey dimensions). Dependency-free
+ * SVG on the validated `--mk-chart-*` palette; ships concentric grid rings, a
+ * legend for ≥ 2 series and a screen-reader data table.
+ *
+ * ```html
+ * <mk-radar-chart
+ *   [axes]="['Speed','Power','Range','Cost','Ease']"
+ *   [series]="[{ name: 'Model A', data: [8,6,7,5,9] }]" />
+ * ```
+ */
+declare class MkRadarChart {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Axis labels (one spoke each). Series data align to this order. */
+    readonly axes: _angular_core.InputSignal<readonly string[]>;
+    /** One or more series (values align to `axes`). */
+    readonly series: _angular_core.InputSignal<readonly MkChartSeries[]>;
+    /** Domain maximum (defaults to a nice value above the data max). */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Number of concentric grid rings. */
+    readonly levels: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Intrinsic width (viewBox units; the SVG scales to its container). */
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Intrinsic height. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Draw a dot at each vertex. */
+    readonly showDots: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the legend on/off (defaults to on when there are ≥ 2 series). */
+    readonly showLegend: _angular_core.InputSignal<boolean | undefined>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    private readonly cx;
+    private readonly cy;
+    private readonly radius;
+    protected readonly colors: _angular_core.Signal<string[]>;
+    protected readonly legendVisible: _angular_core.Signal<boolean>;
+    private readonly domainMax;
+    /** Angle (radians) of axis `i`, starting at the top and going clockwise. */
+    private angleAt;
+    private pointAt;
+    /** Concentric grid ring polygons (outer → inner). */
+    protected readonly rings: _angular_core.Signal<{
+        key: number;
+        points: string;
+    }[]>;
+    /** Axis spokes + outer labels. */
+    protected readonly axisSpokes: _angular_core.Signal<RadarAxis[]>;
+    /** Per-series polygon + vertex geometry. */
+    protected readonly rendered: _angular_core.Signal<RadarSeries[]>;
+    protected readonly legend: _angular_core.Signal<{
+        name: string;
+        color: string;
+    }[]>;
+    protected readonly ringMax: _angular_core.Signal<string>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRadarChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkRadarChart, "mk-radar-chart", never, { "axes": { "alias": "axes"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "levels": { "alias": "levels"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A single stage of the funnel (ordered largest → smallest conceptually). */
+interface MkFunnelSegment {
+    /** Stage label (e.g. "Visits"). */
+    label: string;
+    /** Stage value; drives the band width. */
+    value: number;
+    /** Optional explicit colour; defaults to the palette by index. */
+    color?: string;
+}
+interface FunnelBand {
+    label: string;
+    value: number;
+    valueLabel: string;
+    /** Conversion relative to the first (top) segment, as a percentage. */
+    percent: number;
+    percentLabel: string;
+    color: string;
+    topWidth: number;
+    bottomWidth: number;
+    polygon: string;
+    labelX: number;
+    labelY: number;
+    subY: number;
+}
+/**
+ * FunnelChart — decreasing stacked trapezoids visualising conversion through a
+ * sequence of stages. Each band's top width tracks its own value and its bottom
+ * width tracks the next stage's value, so consecutive bands connect into a
+ * funnel. Dependency-free SVG on the validated `--mk-chart-*` palette; each band
+ * is labelled with its value and its conversion relative to the top stage, and a
+ * screen-reader table mirrors the data.
+ *
+ * ```html
+ * <mk-funnel-chart
+ *   [segments]="[
+ *     { label: 'Visits', value: 1000 },
+ *     { label: 'Signups', value: 400 },
+ *     { label: 'Paid', value: 120 },
+ *   ]" />
+ * ```
+ */
+declare class MkFunnelChart {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The funnel stages, ordered largest → smallest conceptually. */
+    readonly segments: _angular_core.InputSignal<readonly MkFunnelSegment[]>;
+    /** Intrinsic width (viewBox units; the SVG scales to its container). */
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Intrinsic height. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Force the legend on/off (funnels label each band, so off by default). */
+    readonly showLegend: _angular_core.InputSignal<boolean | undefined>;
+    /** Render the value + conversion text on each band. */
+    readonly showValues: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly plot: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    protected readonly legendVisible: _angular_core.Signal<boolean>;
+    private readonly maxValue;
+    private readonly topValue;
+    /** One trapezoid per stage, stacked top → bottom. */
+    protected readonly bands: _angular_core.Signal<FunnelBand[]>;
+    protected readonly legend: _angular_core.Signal<{
+        name: string;
+        color: string;
+    }[]>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkFunnelChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkFunnelChart, "mk-funnel-chart", never, { "segments": { "alias": "segments"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "showValues": { "alias": "showValues"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A single treemap tile: a labelled rectangle sized by `value`. */
+interface MkTreemapItem {
+    /** Tile label (identity — shown on the tile when it fits, and in the tooltip). */
+    label: string;
+    /** Positive magnitude driving the tile's area. */
+    value: number;
+    /** Optional explicit colour; defaults to the validated palette by index. */
+    color?: string;
+}
+/** A positioned tile in SVG user space, tagged with its source `index`. */
+interface MkTreemapRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    index: number;
+}
+/**
+ * Squarified treemap layout — pack `items` into the rectangle `(x, y, w, h)` as
+ * nested tiles whose areas are proportional to `value`, greedily building rows
+ * along the shorter side so tiles stay close to square. Returns exactly one
+ * rect per input item, tagged with its original `index` (so callers can render
+ * in input order). Framework-agnostic and pure.
+ */
+declare function mkSquarify(items: readonly {
+    value: number;
+}[], x: number, y: number, w: number, h: number): MkTreemapRect[];
+interface RenderedTile {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    color: string;
+    label: string;
+    value: number;
+    valueText: string;
+    pct: string;
+    showText: boolean;
+    showValue: boolean;
+    clipId: string;
+    cx: number;
+    cy: number;
+    index: number;
+}
+/**
+ * Treemap — nested rectangles sized by value, using a squarified layout that
+ * keeps tiles close to square. Dependency-free SVG on the validated
+ * `--mk-chart-*` palette; ships in-tile labels (hidden when a tile is too
+ * small), a hover tooltip with the share of total, and a screen-reader table.
+ *
+ * ```html
+ * <mk-treemap [items]="[{ label: 'Ads', value: 40 }, { label: 'SEO', value: 25 }]" />
+ * ```
+ */
+declare class MkTreemap {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The tiles to pack, largest first (order-independent — sorted internally). */
+    readonly items: _angular_core.InputSignal<readonly MkTreemapItem[]>;
+    /** Intrinsic width (viewBox units; the SVG scales to its container). */
+    readonly width: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Intrinsic height. */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Draw each tile's value beneath its label when the tile is tall enough. */
+    readonly showValues: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible summary; generated from the data when omitted. */
+    readonly label: _angular_core.InputSignal<string>;
+    protected readonly hoverKey: _angular_core.WritableSignal<string | null>;
+    /** Tap-to-pin: a touch tap on a tile pins the tooltip until a tap lands
+     *  outside the chart (mouse hover in/out is unaffected). */
+    private readonly tapPin;
+    protected readonly total: _angular_core.Signal<number>;
+    /** Every tile positioned and decorated for rendering (in input order). */
+    protected readonly tiles: _angular_core.Signal<RenderedTile[]>;
+    protected keyOf(index: number): string;
+    /** Rounded share of the total (e.g. `42%`) for the screen-reader table. */
+    protected shareOf(value: number): string;
+    protected readonly tooltip: _angular_core.Signal<{
+        left: number;
+        top: number;
+        color: string;
+        title: string;
+        value: string;
+        pct: string;
+    } | null>;
+    protected readonly resolvedLabel: _angular_core.Signal<string>;
+    protected setHover(key: string | null): void;
+    protected pinHover(key: string, event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTreemap, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTreemap, "mk-treemap", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "showValues": { "alias": "showValues"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Placeholder geometry for a {@link MkSkeleton}. */
+type MkSkeletonShape = 'text' | 'rect' | 'circle';
+/**
+ * Skeleton — a shimmering placeholder shown while content loads. It is
+ * `aria-hidden`; mark the surrounding region `aria-busy="true"` so assistive
+ * tech knows content is pending. The shimmer stops under
+ * `prefers-reduced-motion`.
+ *
+ * ```html
+ * <mk-skeleton shape="circle" [width]="40" [height]="40" />
+ * <mk-skeleton shape="text" [lines]="3" />
+ * <mk-skeleton shape="rect" width="100%" [height]="180" />
+ * ```
+ */
+declare class MkSkeleton {
+    /** Placeholder geometry. */
+    readonly shape: _angular_core.InputSignal<MkSkeletonShape>;
+    /** Width — a number (px) or any CSS length/percentage string. */
+    readonly width: _angular_core.InputSignal<string | number | undefined>;
+    /** Height — a number (px) or any CSS length/percentage string. */
+    readonly height: _angular_core.InputSignal<string | number | undefined>;
+    /** Number of lines to render for `shape="text"`. */
+    readonly lines: _angular_core.InputSignalWithTransform<number, unknown>;
+    private toCss;
+    protected readonly styleWidth: _angular_core.Signal<string>;
+    protected readonly styleHeight: _angular_core.Signal<string | null>;
+    /** Line index array for the text variant (at least one line). */
+    protected readonly lineArray: _angular_core.Signal<unknown[]>;
+    /** Last line of a multi-line block is shortened for a natural look. */
+    protected lineWidth(index: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSkeleton, "mk-skeleton", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Ready-made loading layouts for {@link MkSkeletonPreset}. */
+type MkSkeletonPresetKind = 'paragraph' | 'card' | 'list' | 'table';
+/**
+ * SkeletonPreset — composite loading placeholders assembled from
+ * {@link MkSkeleton}: a `paragraph`, a media `card`, an avatar `list` or a
+ * `table`. Announces "Loading" to assistive tech; swap it for real content once
+ * loaded.
+ *
+ * ```html
+ * <mk-skeleton-preset preset="card" />
+ * <mk-skeleton-preset preset="list" [rows]="5" />
+ * <mk-skeleton-preset preset="table" [rows]="4" [columns]="5" />
+ * ```
+ */
+declare class MkSkeletonPreset {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Which layout to render. */
+    readonly preset: _angular_core.InputSignal<MkSkeletonPresetKind>;
+    /** Number of rows (paragraph lines / list items / table body rows). */
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Number of columns (table only). */
+    readonly columns: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Accessible loading label. */
+    readonly loadingLabel: _angular_core.InputSignal<string>;
+    protected readonly rowRange: _angular_core.Signal<number[]>;
+    protected readonly colRange: _angular_core.Signal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSkeletonPreset, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSkeletonPreset, "mk-skeleton-preset", never, { "preset": { "alias": "preset"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "loadingLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * InlineEdit — click a piece of text to edit it in place. The display is a
+ * button that swaps to an input on click (or Enter/Space); Enter or blur saves,
+ * Escape reverts. Ideal for editable labels in tables and detail panels.
+ * Implements `ControlValueAccessor` + a two-way `value` model of `string`.
+ *
+ * ```html
+ * <mk-inline-edit [(value)]="title" placeholder="Untitled" />
+ * <mk-inline-edit multiline [(value)]="notes" />
+ * ```
+ */
+declare class MkInlineEdit implements ControlValueAccessor {
+    private readonly injector;
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly displayRef;
+    private readonly inputRef;
+    /** Two-way edited value. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Shown (muted) when the value is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Use a multi-line textarea; Enter inserts a newline, blur/✓ saves. */
+    readonly multiline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Save when the field loses focus (otherwise blur cancels). */
+    readonly saveOnBlur: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible label for the edit trigger + field. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Disable editing. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the invalid visual + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Emitted with the new value when an edit is saved. */
+    readonly saved: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when an edit is cancelled. */
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    protected readonly editing: _angular_core.WritableSignal<boolean>;
+    protected readonly draft: _angular_core.WritableSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly fieldId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly displayText: _angular_core.Signal<string>;
+    protected startEdit(): void;
+    protected onInput(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onBlur(): void;
+    protected save(): void;
+    protected cancel(): void;
+    private restoreFocus;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkInlineEdit, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkInlineEdit, "mk-inline-edit", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiline": { "alias": "multiline"; "required": false; "isSignal": true; }; "saveOnBlur": { "alias": "saveOnBlur"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "saved": "saved"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+/** A duration split into whole day/hour/minute/second parts. */
+interface MkDurationParts {
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+}
+/**
+ * Split a positive millisecond duration into whole days, hours, minutes and
+ * seconds. Negative inputs clamp to zero.
+ *
+ * ```ts
+ * mkSplitDuration(90_061_000); // { days: 1, hours: 1, minutes: 1, seconds: 1 }
+ * ```
+ */
+declare function mkSplitDuration(ms: number): MkDurationParts;
+/**
+ * Countdown — ticks every second and shows the time remaining until a target
+ * instant as days / hours / minutes / seconds. Emits {@link finished} once when
+ * the target passes and then keeps showing zeros (or {@link finishedText}).
+ *
+ * ```html
+ * <mk-countdown [to]="launchDate" (finished)="onLaunch()" />
+ * ```
+ */
+declare class MkCountdown {
+    private readonly document;
+    private readonly isBrowser;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The target instant to count down to. */
+    readonly to: _angular_core.InputSignal<Date | null>;
+    /** Show the days segment; when false, days roll into the hours value. */
+    readonly showDays: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the textual label beneath each value. */
+    readonly showLabels: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Zero-pad values to two digits. */
+    readonly pad: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Text to show instead of zeros once the countdown finishes. */
+    readonly finishedText: _angular_core.InputSignal<string>;
+    /** Fires exactly once when the target instant is reached. */
+    readonly finished: _angular_core.OutputEmitterRef<void>;
+    /** Current wall-clock time, updated every tick. */
+    protected readonly now: _angular_core.WritableSignal<number>;
+    /** Remaining milliseconds, clamped at zero. */
+    protected readonly remaining: _angular_core.Signal<number>;
+    protected readonly parts: _angular_core.Signal<{
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+    }>;
+    protected readonly isDone: _angular_core.Signal<boolean>;
+    /**
+     * Text for the polite live region. Deliberately formatted WITHOUT the
+     * seconds segment so the string (and therefore the announcement) only
+     * changes when a minute rolls over, instead of chattering every second.
+     * When the countdown reaches zero it switches to a final "finished"
+     * announcement ({@link finishedText} when provided).
+     */
+    protected readonly liveText: _angular_core.Signal<string>;
+    private hasFinished;
+    private intervalId?;
+    /** Set once the first render has happened (browser only). */
+    private viewReady;
+    constructor();
+    /**
+     * No ticking while the tab is hidden — every tick is a change-detection
+     * pass in a zoneless app. On return, resync immediately from `Date.now()`
+     * so the display never shows stale time.
+     */
+    private readonly onVisibilityChange;
+    private startInterval;
+    private stopInterval;
+    private tick;
+    protected format(value: number): string;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCountdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCountdown, "mk-countdown", never, { "to": { "alias": "to"; "required": false; "isSignal": true; }; "showDays": { "alias": "showDays"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; "pad": { "alias": "pad"; "required": false; "isSignal": true; }; "finishedText": { "alias": "finishedText"; "required": false; "isSignal": true; }; }, { "finished": "finished"; }, never, never, true, never>;
+}
+
+/** Layout for {@link MkDescriptionList}. */
+type MkDescriptionLayout = 'grid' | 'stacked';
+/**
+ * DescriptionList — a semantic `<dl>` of term/detail pairs for entity-detail and
+ * metadata panels. Project {@link MkDescItem} rows; values may be rich content
+ * (badges, links, …). In `grid` layout terms align in a shared column; in
+ * `stacked` each term sits above its value.
+ *
+ * ```html
+ * <mk-description-list>
+ *   <mk-desc-item term="Status"><mk-badge tone="success">Active</mk-badge></mk-desc-item>
+ *   <mk-desc-item term="Owner">Ada Lovelace</mk-desc-item>
+ * </mk-description-list>
+ * ```
+ */
+declare class MkDescriptionList {
+    /** `grid` aligns terms in a column; `stacked` puts each term above its value. */
+    readonly layout: _angular_core.InputSignal<MkDescriptionLayout>;
+    /** Draw a divider between rows. */
+    readonly divided: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDescriptionList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDescriptionList, "mk-description-list", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "divided": { "alias": "divided"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * A single term/detail row inside {@link MkDescriptionList}. Renders a `<dt>`
+ * (the `term`) and a `<dd>` (the projected value). The host is `display:contents`
+ * so the `<dt>`/`<dd>` participate directly in the list's grid.
+ */
+declare class MkDescItem {
+    /** The term (label) shown in the `<dt>`. */
+    readonly term: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDescItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDescItem, "mk-desc-item", never, { "term": { "alias": "term"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Code — a read-only, themed code block with syntax highlighting, an optional
+ * filename header, line numbers and a copy button. Highlighting reuses the same
+ * dependency-free tokenizer as {@link MkCodeEditor}. For an editable field use
+ * `mk-code-editor` instead.
+ *
+ * ```html
+ * <mk-code language="json" filename="config.json" [code]="json" />
+ * ```
+ */
+declare class MkCode {
+    /** The source to display. */
+    readonly code: _angular_core.InputSignal<string>;
+    /** Language for highlighting. */
+    readonly language: _angular_core.InputSignal<MkCodeLanguage>;
+    /** Optional filename shown in a header bar. */
+    readonly filename: _angular_core.InputSignal<string>;
+    /** Show a line-number gutter. */
+    readonly lineNumbers: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the copy button. */
+    readonly copyable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Soft-wrap long lines instead of scrolling horizontally. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly highlighted: _angular_core.Signal<string>;
+    protected readonly lines: _angular_core.Signal<number[]>;
+    /** Whether to render the header bar (filename and/or copy button). */
+    protected readonly hasHeader: _angular_core.Signal<boolean>;
+    /**
+     * Accessible name of the focusable scroll region: the filename when set,
+     * else a generic "Code". (No MK_I18N key covers this today — the block
+     * editor's `blockCode` string is scoped to the editor palette.)
+     */
+    protected readonly scrollLabel: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCode, "mk-code", never, { "code": { "alias": "code"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "filename": { "alias": "filename"; "required": false; "isSignal": true; }; "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "copyable": { "alias": "copyable"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * VirtualScroll — renders only the rows visible in the viewport (plus a small
+ * overscan), so a list of thousands of fixed-height items stays smooth. Give
+ * the host a height and provide a row template:
+ *
+ * ```html
+ * <mk-virtual-scroll [items]="rows" [itemHeight]="40" style="height: 20rem;">
+ *   <ng-template let-row let-i="index">{{ i }} — {{ row.name }}</ng-template>
+ * </mk-virtual-scroll>
+ * ```
+ */
+declare class MkVirtualScroll {
+    private readonly isBrowser;
+    private readonly viewportRef;
+    /** The full list of items. */
+    readonly items: _angular_core.InputSignal<readonly unknown[]>;
+    /** Fixed height of each row in px. */
+    readonly itemHeight: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Extra rows rendered above/below the viewport to smooth fast scrolls. */
+    readonly overscan: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The row template (`<ng-template let-item let-i="index">`). */
+    protected readonly template: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly scrollTop: _angular_core.WritableSignal<number>;
+    protected readonly viewportHeight: _angular_core.WritableSignal<number>;
+    /** Total scrollable height (sizes the scrollbar). */
+    protected readonly totalHeight: _angular_core.Signal<number>;
+    /**
+     * The [start, end) index window currently rendered. Custom equality means
+     * per-pixel scrolling only re-renders when the window actually shifts.
+     */
+    private readonly range;
+    /** Offset of the first rendered row from the top. */
+    protected readonly offset: _angular_core.Signal<number>;
+    /** The rendered slice, each with its absolute index. */
+    protected readonly visibleItems: _angular_core.Signal<{
+        item: unknown;
+        index: number;
+    }[]>;
+    constructor();
+    private resizeObserver?;
+    ngOnDestroy(): void;
+    private measure;
+    protected onScroll(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkVirtualScroll, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkVirtualScroll, "mk-virtual-scroll", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "overscan": { "alias": "overscan"; "required": false; "isSignal": true; }; }, {}, ["template"], never, true, never>;
+}
+
+/**
+ * A single slide inside {@link MkCarousel}. Mark each slide element with
+ * `mkCarouselSlide`; the carousel wires ARIA + visibility.
+ */
+declare class MkCarouselSlide {
+    readonly el: ElementRef<HTMLElement>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCarouselSlide, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkCarouselSlide, "[mkCarouselSlide]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Carousel — an accessible slides/gallery. Project slides marked with
+ * `mkCarouselSlide`; get prev/next arrows, dot indicators, Arrow-key
+ * navigation, pointer swipe (touch or mouse drag; vertical page scroll stays
+ * native) and optional autoplay that pauses on hover/focus. The current slide
+ * is a two-way `index` model.
+ *
+ * ```html
+ * <mk-carousel ariaLabel="Featured" autoplay>
+ *   <div mkCarouselSlide>…</div>
+ *   <div mkCarouselSlide>…</div>
+ * </mk-carousel>
+ * ```
+ */
+declare class MkCarousel {
+    private readonly isBrowser;
+    private readonly document;
+    private readonly host;
+    private readonly slides;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Two-way current slide index. */
+    readonly index: _angular_core.ModelSignal<number>;
+    /** Accessible label for the carousel region. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Wrap around at the ends. */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the dot indicators. */
+    readonly showDots: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the prev/next arrows. */
+    readonly showArrows: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Advance automatically. Pauses transiently on hover/focus/pointer-down and
+     * shows a persistent pause/play toggle (`userPaused`). Never runs when the
+     * user prefers reduced motion.
+     */
+    readonly autoplay: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Autoplay interval in ms. */
+    readonly interval: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Persistent, user-controlled pause (WCAG 2.2.2). Latched by the pause/play
+     * toggle; the transient hover/focus pause never overrides it. Two-way so
+     * consumers can bind or preset it.
+     */
+    readonly userPaused: _angular_core.ModelSignal<boolean>;
+    /** Transient pause (hover / focus / pointer held down inside the viewport). */
+    protected readonly paused: _angular_core.WritableSignal<boolean>;
+    /** True while the autoplay interval is actually running. */
+    protected readonly playing: _angular_core.WritableSignal<boolean>;
+    /** True while the browser tab is hidden — no advancing (or CD) in the dark. */
+    private readonly pageHidden;
+    /** True while the carousel is fully scrolled out of the viewport. */
+    private readonly offscreen;
+    private timer?;
+    private io?;
+    protected readonly count: _angular_core.Signal<number>;
+    protected readonly dots: _angular_core.Signal<number[]>;
+    protected readonly liveText: _angular_core.Signal<string>;
+    /**
+     * Silence the live region while the slideshow is auto-advancing — otherwise
+     * every auto-advance is announced forever. Announce again as soon as the
+     * user is in control (paused, latched, or autoplay off).
+     */
+    protected readonly liveMode: _angular_core.Signal<"off" | "polite">;
+    /** Resolved text direction ('ltr' until measured in the browser). */
+    private readonly dir;
+    /** Live swipe gesture, or null when no pointer is being tracked. */
+    private swipe;
+    /** Visual drag offset (px) applied on top of the slide position. */
+    private readonly dragOffset;
+    /** True while a horizontal drag is in flight (kills the track transition). */
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    /**
+     * Track offset — in RTL the flex track lays out right-to-left, so moving to
+     * the next slide means translating in the positive X direction. While a
+     * swipe is in flight the pixel drag offset rides on top.
+     */
+    protected readonly trackTransform: _angular_core.Signal<string>;
+    constructor();
+    /** Go to slide `i` (clamped, or wrapped when `loop`). */
+    goTo(i: number): void;
+    next(): void;
+    prev(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected pause(): void;
+    protected resume(): void;
+    /** Latches / releases the persistent pause (the toolbar toggle button). */
+    protected toggleUserPause(): void;
+    /**
+     * Touch users can't hover — holding a pointer down pauses autoplay
+     * transiently. It also arms swipe tracking, except on the carousel's own
+     * controls (play/pause, arrows), which must stay plain tappable buttons.
+     */
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(event: PointerEvent): void;
+    /**
+     * Capture-phase, one-shot click swallow: the browser fires a synthetic click
+     * right after pointerup, which would activate whatever link/button the drag
+     * ended on. The safety timeout covers gestures that produce no click at all.
+     */
+    private suppressNextClick;
+    private prefersReducedMotion;
+    private readonly onVisibilityChange;
+    private stopTimer;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCarousel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCarousel, "mk-carousel", never, { "index": { "alias": "index"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "showArrows": { "alias": "showArrows"; "required": false; "isSignal": true; }; "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "userPaused": { "alias": "userPaused"; "required": false; "isSignal": true; }; }, { "index": "indexChange"; "userPaused": "userPausedChange"; }, ["slides"], ["*"], true, never>;
+}
+
+/**
+ * Dependency-free text diff for {@link MkDiff} — an LCS line diff with optional
+ * intra-line word highlighting. Pure and SSR-safe (no DOM). Suited to revision
+ * comparison ("what changed between save N and N+1").
+ */
+/** The kind of change for a diff row/segment. */
+type MkDiffOp = 'equal' | 'insert' | 'delete';
+/** A word-level segment within a changed line. */
+interface MkDiffSegment {
+    text: string;
+    /** True when this word differs from the paired line. */
+    changed: boolean;
+}
+/** One line of a computed diff. */
+interface MkDiffRow {
+    op: MkDiffOp;
+    text: string;
+    /** 1-based line number in the "before" text (null for inserts). */
+    beforeNo: number | null;
+    /** 1-based line number in the "after" text (null for deletes). */
+    afterNo: number | null;
+    /** Word segments for changed lines (present when word highlighting runs). */
+    segments?: MkDiffSegment[];
+}
+/** Summary counts for a diff. */
+interface MkDiffStats {
+    added: number;
+    removed: number;
+    unchanged: number;
+}
+/** Options for {@link mkComputeDiff}. */
+interface MkDiffOptions {
+    /** Highlight the specific words that changed within paired lines. */
+    wordHighlight?: boolean;
+    /** Treat trailing whitespace as insignificant when comparing lines. */
+    ignoreTrailingWhitespace?: boolean;
+}
+/**
+ * Compute a line diff between `before` and `after`. Returns one {@link MkDiffRow}
+ * per line in document order, with `equal` / `insert` / `delete` ops and 1-based
+ * before/after line numbers. With `wordHighlight` (default true) changed lines
+ * also carry word-level `segments`.
+ */
+declare function mkComputeDiff(before: string, after: string, options?: MkDiffOptions): MkDiffRow[];
+/** Summary counts (added / removed / unchanged lines) for a diff. */
+declare function mkDiffStats(rows: MkDiffRow[]): MkDiffStats;
+
+/** How {@link MkDiff} lays out the comparison. */
+type MkDiffMode = 'unified' | 'split';
+interface SplitRow {
+    left: MkDiffRow | null;
+    right: MkDiffRow | null;
+}
+/**
+ * Diff — a text comparison view for revisions (before ⇄ after). Computes an LCS
+ * line diff with optional intra-line word highlighting and renders a `unified`
+ * (single-column, +/-) or `split` (side-by-side) view with line numbers and an
+ * add/remove summary.
+ *
+ * ```html
+ * <mk-diff [before]="v1" [after]="v2" mode="split" />
+ * ```
+ */
+declare class MkDiff {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The original ("before") text. */
+    readonly before: _angular_core.InputSignal<string>;
+    /** The new ("after") text. */
+    readonly after: _angular_core.InputSignal<string>;
+    /** Layout: single-column `unified` or side-by-side `split`. */
+    readonly mode: _angular_core.InputSignal<MkDiffMode>;
+    /** Highlight the specific words that changed within a line. */
+    readonly wordHighlight: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show line-number gutters. */
+    readonly lineNumbers: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Ignore trailing whitespace when comparing lines. */
+    readonly ignoreTrailingWhitespace: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the +added / −removed summary header. */
+    readonly showStats: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Column labels (split view header / a11y). */
+    readonly beforeLabel: _angular_core.InputSignal<string>;
+    readonly afterLabel: _angular_core.InputSignal<string>;
+    protected readonly rows: _angular_core.Signal<MkDiffRow[]>;
+    protected readonly stats: _angular_core.Signal<_mk_kit_ui_data.MkDiffStats>;
+    /** Rows paired into two columns for the split view. */
+    protected readonly splitRows: _angular_core.Signal<SplitRow[]>;
+    protected marker(op: MkDiffRow['op']): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDiff, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDiff, "mk-diff", never, { "before": { "alias": "before"; "required": false; "isSignal": true; }; "after": { "alias": "after"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "wordHighlight": { "alias": "wordHighlight"; "required": false; "isSignal": true; }; "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "ignoreTrailingWhitespace": { "alias": "ignoreTrailingWhitespace"; "required": false; "isSignal": true; }; "showStats": { "alias": "showStats"; "required": false; "isSignal": true; }; "beforeLabel": { "alias": "beforeLabel"; "required": false; "isSignal": true; }; "afterLabel": { "alias": "afterLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A single draggable card on a {@link MkKanban} board. */
+interface MkKanbanCard {
+    /** Stable identity used for tracking and move events. */
+    id: unknown;
+    /** Text shown by the default card renderer. */
+    title: string;
+    /** Arbitrary extra fields for custom card templates. */
+    [key: string]: unknown;
+}
+/** A column (bucket) of {@link MkKanbanCard}s on a {@link MkKanban} board. */
+interface MkKanbanColumn {
+    /** Stable identity used for tracking and move events. */
+    id: unknown;
+    /** Heading shown in the column header and used as its aria-label. */
+    title: string;
+    /** The ordered cards contained in this column. */
+    cards: MkKanbanCard[];
+}
+/**
+ * Emitted by {@link MkKanban} after a card has been moved (between or within
+ * columns) and the two-way `columns` model has been updated.
+ */
+interface MkKanbanCardMovedEvent {
+    /** The card that was moved. */
+    card: MkKanbanCard;
+    /** `id` of the column the card came from. */
+    from: unknown;
+    /** `id` of the column the card was dropped into. */
+    to: unknown;
+    /** The card's index within the source column before the move. */
+    fromIndex: number;
+    /** The card's index within the destination column after the move. */
+    toIndex: number;
+}
+/**
+ * Kanban board — a horizontal row of columns whose cards can be dragged and
+ * reordered within a column or transferred between columns. Built on the dnd
+ * group's connected `[mkDropList]` / `[mkDrag]` directives, so it inherits both
+ * pointer and keyboard dragging (WCAG 2.1.1) for free.
+ *
+ * Bind `columns` two-way; the model is updated immutably on each drop. Project
+ * an `<ng-template>` to render custom card content — it receives the card as
+ * `$implicit` and the owning column as `column`:
+ *
+ * ```html
+ * <mk-kanban [(columns)]="board" (cardMoved)="onMoved($event)">
+ *   <ng-template #cardTemplate let-card let-column="column">
+ *     <strong>{{ card.title }}</strong>
+ *   </ng-template>
+ * </mk-kanban>
+ * ```
+ */
+declare class MkKanban {
+    /** The board's columns and their cards (two-way). Updated on every drop. */
+    readonly columns: _angular_core.ModelSignal<MkKanbanColumn[]>;
+    /** Disable all dragging on the board. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted after the model is updated when a card is moved. */
+    readonly cardMoved: _angular_core.OutputEmitterRef<MkKanbanCardMovedEvent>;
+    /** Optional consumer-projected card renderer (`$implicit` = card). */
+    protected readonly cardTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    /** Board-scoped prefix so this board's drop-list ids never collide. */
+    private readonly boardId;
+    /** Column count as its own computed so id arrays survive card-only updates. */
+    private readonly columnCount;
+    /** Stable drop-list id per column, positionally matched to `columns()`. */
+    protected readonly listIds: _angular_core.Signal<string[]>;
+    /**
+     * Per-column connected-target ids (every other column's list). One stable
+     * array per column, recomputed only when the column count changes — a fresh
+     * array per change-detection pass would dirty each `MkDropList`'s
+     * `connectedTo` input identity on every cycle.
+     */
+    private readonly connections;
+    /** Ids of every other column's list — the connected transfer targets for `i`. */
+    protected connectedTo(index: number): string[];
+    /**
+     * Apply a drop from the dnd module. Reads the source/target columns from the
+     * event's containers (matched by their drop-list ids), updates the two-way
+     * `columns` model immutably, then emits {@link cardMoved}.
+     */
+    protected onDrop(event: MkDropEvent<MkKanbanCard>): void;
+    /**
+     * Immutably move the card at `fromIndex` of column `fromCol` to `toIndex` of
+     * column `toCol`, updating the model and emitting {@link cardMoved}. Column
+     * indices refer to positions in `columns()`.
+     */
+    private moveCard;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkKanban, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkKanban, "mk-kanban", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "columns": "columnsChange"; "cardMoved": "cardMoved"; }, ["cardTemplate"], never, true, never>;
+}
+
+/**
+ * Dependency-free QR Code encoder.
+ *
+ * A from-scratch implementation of the QR encoding algorithm (ISO/IEC 18004):
+ * byte-mode (UTF-8) data encoding, Reed–Solomon error correction over GF(256),
+ * matrix construction with function patterns, all eight data masks scored by
+ * the four penalty rules, and BCH format/version information.
+ *
+ * Scope: byte mode only, versions 1–10 (module counts 21…57), ECC levels
+ * L/M/Q/H. That covers roughly 7–271 UTF-8 bytes depending on the ECC level.
+ * Numeric/alphanumeric/kanji modes and versions ≥ 11 are intentionally out of
+ * scope — everything is encoded as UTF-8 bytes, which is always valid.
+ *
+ * The single public entry point is {@link mkEncodeQr}, a pure function.
+ */
+type MkQrEcc = 'L' | 'M' | 'Q' | 'H';
+/**
+ * Encode `text` (UTF-8, byte mode) as a QR code module matrix.
+ *
+ * @param text The payload. May be empty.
+ * @param ecc  Error-correction level: `L` (~7%), `M` (~15%), `Q` (~25%), `H` (~30%).
+ * @returns A square `boolean[][]` where `true` marks a dark module. The side
+ *          length is `17 + 4 * version` (21 for v1 … 57 for v10).
+ * @throws If the payload does not fit in versions 1–10 at the chosen ECC level.
+ */
+declare function mkEncodeQr(text: string, ecc: MkQrEcc): boolean[][];
+
+/**
+ * QR Code — a dependency-free QR generator rendered as an SVG. The entire
+ * encoding (byte mode, Reed–Solomon ECC, masking, format info) is implemented
+ * from scratch in {@link mkEncodeQr}; no npm library is used. Dark modules are
+ * drawn as `<rect>`s over a background rectangle that also fills the quiet zone,
+ * so the code is theme-aware (`var(--mk-text)` on `var(--mk-surface)`) and
+ * fully overridable. Exposes `role="img"` with an `aria-label` for assistive
+ * tech.
+ *
+ * Supports versions 1–10 and ECC levels L/M/Q/H (byte mode / UTF-8).
+ *
+ * ```html
+ * <mk-qr-code value="https://example.com" ecc="M" [size]="200" />
+ * ```
+ */
+declare class MkQrCode {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The text to encode (UTF-8, byte mode). */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Error-correction level: `L` (~7%), `M` (~15%), `Q` (~25%), `H` (~30%). */
+    readonly ecc: _angular_core.InputSignal<MkQrEcc>;
+    /** Rendered pixel size of the (square) SVG. */
+    readonly size: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Width of the light margin around the code, in modules (spec recommends 4). */
+    readonly quietZone: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Dark-module colour. */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Background / quiet-zone colour. */
+    readonly background: _angular_core.InputSignal<string>;
+    /**
+     * Accessible label for the image. When omitted, the label carries the
+     * encoded content (`QR code: <value>`) so AT users learn what the code says.
+     */
+    readonly label: _angular_core.InputSignal<string>;
+    /** The label actually exposed on the host: `label`, or a generated default. */
+    protected readonly effectiveLabel: _angular_core.Signal<string>;
+    /** The module matrix (`true` = dark); empty if encoding fails (e.g. too long). */
+    protected readonly matrix: _angular_core.Signal<boolean[][]>;
+    /** Quiet zone clamped to a non-negative integer. */
+    protected readonly quiet: _angular_core.Signal<number>;
+    /** Side length of the viewBox in modules (code + both quiet-zone margins). */
+    protected readonly dimension: _angular_core.Signal<number>;
+    /** Top-left coordinates (in module units) of every dark module. */
+    protected readonly modules: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkQrCode, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkQrCode, "mk-qr-code", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "ecc": { "alias": "ecc"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "quietZone": { "alias": "quietZone"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "background": { "alias": "background"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** One rendered node of the JSON tree. */
+interface MkJsonNode {
+    /** Property name / array index; `null` for the root. */
+    key: string | null;
+    /** Node kind (drives colouring + expandability). */
+    type: 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null' | 'circular';
+    /** Display text for primitives. */
+    display: string;
+    /** Children for objects/arrays. */
+    children: MkJsonNode[];
+    /** Unique path (e.g. `$.users[0].name`) used for expansion tracking. */
+    path: string;
+    /** Nesting depth (root = 0). */
+    depth: number;
+}
+/** Build the node tree for a JSON-ish value (circular refs marked). */
+declare function mkBuildJsonTree(value: unknown): MkJsonNode;
+/**
+ * JsonViewer — a read-only, collapsible tree for JSON-ish data: objects and
+ * arrays fold behind disclosure buttons (with a `{…} n items` preview),
+ * primitives are colour-coded by type, and circular references render as
+ * `[Circular]` instead of recursing. `expandDepth` controls how much is open
+ * initially; `expandAll()` / `collapseAll()` are available on the component.
+ *
+ * The complement of `mk-code-editor`: the editor edits JSON text, this
+ * explores JSON *data* (API responses, entity payloads, config dumps).
+ *
+ * ```html
+ * <mk-json-viewer [data]="response" [expandDepth]="2" />
+ * ```
+ */
+declare class MkJsonViewer {
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** The value to display (any JSON-serialisable data). */
+    readonly data: _angular_core.InputSignal<unknown>;
+    /** How many levels start expanded (root = level 1). */
+    readonly expandDepth: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Accessible label of the tree region. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Paths currently expanded. Mutated in place — a toggle is O(1) instead of
+     * copying the whole set — with `expansionVersion` bumped so signal-driven
+     * bindings re-evaluate. Always read through {@link isExpanded}.
+     */
+    private readonly expanded;
+    /** Bumped on every expansion change; the reactive face of `expanded`. */
+    private readonly expansionVersion;
+    /** The built node tree. */
+    protected readonly root: _angular_core.Signal<MkJsonNode>;
+    /**
+     * Collapsed previews, cached per node so template bindings don't rebuild the
+     * string on every change-detection pass. Keyed weakly: entries die with the
+     * tree when `data` changes.
+     */
+    private readonly previews;
+    constructor();
+    protected isExpanded(path: string): boolean;
+    protected toggle(path: string): void;
+    /** Expand every object/array node. */
+    expandAll(): void;
+    /** Collapse everything (the root stays visible). */
+    collapseAll(): void;
+    /** Swap the expansion set's contents and notify bindings. */
+    private replaceExpanded;
+    /** Collapsed preview, e.g. `{…}` / `[…]` + item count (cached per node). */
+    protected preview(node: MkJsonNode): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkJsonViewer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkJsonViewer, "mk-json-viewer", ["mkJsonViewer"], { "data": { "alias": "data"; "required": true; "isSignal": true; }; "expandDepth": { "alias": "expandDepth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Minimal ANSI SGR parser for {@link MkLogViewer}.
+ *
+ * Understands the SGR (`ESC[…m`) subset that matters for log output — reset
+ * (0), bold (1), italic (3), underline (4), the 22/23/24 "off" codes, the 8
+ * standard + 8 bright foreground colours (30–37 / 90–97, 39 reset) and the
+ * matching backgrounds (40–47 / 100–107, 49 reset). Extended-colour
+ * introducers (38/48;5;… and 38/48;2;r;g;b) are consumed so their arguments
+ * are never misread as other codes, but map to "no colour" (the theme has no
+ * 256-colour palette). Every other escape sequence — cursor movement, erase,
+ * OSC titles, single-character escapes — is stripped rather than rendered as
+ * garbage.
+ *
+ * Colours are emitted as CSS class names (`mk-ansi--fg-red`,
+ * `mk-ansi--bg-bright-blue`, `mk-ansi--bold`, …) themed in
+ * `log-viewer.scss`, not as raw terminal colours.
+ */
+/** One styled run of text within a parsed line. */
+interface MkAnsiSpan {
+    /** The plain text of the run (escape sequences removed). */
+    text: string;
+    /** `mk-ansi--*` class names styling the run; empty for plain text. */
+    classes: readonly string[];
+}
+/**
+ * Parse one log line into styled spans. Pure — same input, same output.
+ * Adjacent runs with identical styling are merged, so a plain line yields a
+ * single span (or none when empty).
+ */
+declare function mkParseAnsi(line: string): MkAnsiSpan[];
+/** Remove every ANSI escape sequence from a line (for copy / search). */
+declare function mkStripAnsi(line: string): string;
+
+/** One render token of a log line: a styled run, optionally a search match. */
+interface MkLogToken {
+    text: string;
+    /** Space-joined `mk-ansi--*` classes ('' for plain text). */
+    cls: string;
+    /** True when the token is part of a search-query match. */
+    mark: boolean;
+}
+interface MkLogLine {
+    /** Absolute index within the (ring-buffered) lines. */
+    index: number;
+    tokens: MkLogToken[];
+}
+/**
+ * LogViewer — a virtualized, tail-following log / terminal pane. Renders only
+ * the visible window of a (ring-buffered) line array, parses ANSI SGR colour
+ * codes into theme-aware spans, follows new output at the bottom until the
+ * user scrolls away, and highlights plain-string search matches.
+ *
+ * ```html
+ * <mk-log-viewer
+ *   [lines]="lines()"
+ *   [(follow)]="follow"
+ *   [query]="search()"
+ *   (matches)="count.set($event)"
+ * />
+ * ```
+ *
+ * Wrap mode (`[wrap]="true"` or the toolbar toggle) soft-wraps long lines;
+ * because wrapped rows have no fixed height, wrap mode renders **without**
+ * virtualization — fine up to a few thousand lines, so keep `maxLines`
+ * modest when wrapping is expected.
+ *
+ * `query` is matched as a case-insensitive plain string — no regex.
+ */
+declare class MkLogViewer {
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly isBrowser;
+    private readonly viewportRef;
+    /** The log lines (may contain ANSI SGR escape sequences). */
+    readonly lines: _angular_core.InputSignal<readonly string[]>;
+    /** Stick to the bottom as new lines arrive (two-way; detaches on scroll-up). */
+    readonly follow: _angular_core.ModelSignal<boolean>;
+    /** Soft-wrap long lines (two-way; disables virtualization — see class docs). */
+    readonly wrap: _angular_core.ModelSignal<boolean>;
+    /** Parse ANSI SGR colour codes; `false` renders lines verbatim. */
+    readonly ansi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Case-insensitive plain-string search; matches are highlighted. */
+    readonly query: _angular_core.InputSignal<string>;
+    /** Ring buffer size: oldest lines are dropped beyond this. */
+    readonly maxLines: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Fixed row height in px (drives virtualization; also sets line-height). */
+    readonly itemHeight: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Hide the built-in toolbar row. */
+    readonly hideToolbar: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible label of the log region. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Emits the total number of `query` matches whenever it changes. */
+    readonly matches: _angular_core.OutputEmitterRef<number>;
+    /** The lines actually shown: the newest `maxLines` of `lines`. */
+    protected readonly buffered: _angular_core.Signal<readonly string[]>;
+    protected readonly scrollTop: _angular_core.WritableSignal<number>;
+    protected readonly viewportHeight: _angular_core.WritableSignal<number>;
+    protected readonly totalHeight: _angular_core.Signal<number>;
+    private readonly range;
+    protected readonly offset: _angular_core.Signal<number>;
+    /** The virtualized window — only ~viewport+overscan lines are parsed. */
+    protected readonly visibleLines: _angular_core.Signal<MkLogLine[]>;
+    /** Wrap mode: every line, non-virtualized (parse memoized per content). */
+    protected readonly wrappedLines: _angular_core.Signal<MkLogLine[]>;
+    /** Total number of case-insensitive plain-string matches of `query`. */
+    readonly matchCount: _angular_core.Signal<number>;
+    /** The full buffer as plain text (escapes stripped) for copy-all. */
+    protected readonly allText: _angular_core.Signal<string>;
+    /**
+     * Wrap-mode parse cache, keyed by line content: appending N lines re-parses
+     * only the N new ones (duplicate lines share one entry — harmless, spans
+     * are immutable render data). Virtual mode skips it: parsing the ~30-row
+     * window per render is cheaper than any bookkeeping.
+     */
+    private readonly parseCache;
+    /** Guards against treating our own scrollTop writes as user scrolling. */
+    private programmaticScroll;
+    private resizeObserver?;
+    constructor();
+    ngOnDestroy(): void;
+    /** Re-enable follow mode and jump to the newest line. */
+    protected resumeFollow(): void;
+    protected onScroll(event: Event): void;
+    private scrollToBottom;
+    private measure;
+    private parse;
+    /** Turn one raw line into render tokens (ANSI spans split at matches). */
+    private renderLine;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkLogViewer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkLogViewer, "mk-log-viewer", ["mkLogViewer"], { "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "follow": { "alias": "follow"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "ansi": { "alias": "ansi"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "maxLines": { "alias": "maxLines"; "required": false; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, { "follow": "followChange"; "wrap": "wrapChange"; "matches": "matches"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Markdown — renders a CommonMark subset (see {@link mkParseMarkdown} for the
+ * exact syntax list) with zero runtime dependencies. Built for admin-app
+ * content: changelogs, AI output, user notes.
+ *
+ * SECURITY MODEL: raw HTML in the source is never passed through — it is
+ * always escaped and shown as text, and link/image URLs are restricted to
+ * http/https/mailto/relative, so the rendered string contains only markup the
+ * renderer itself generates. It is bound via `[innerHTML]` and additionally
+ * passes through Angular's `DomSanitizer` (no `bypassSecurityTrustHtml`),
+ * which keeps every element and attribute the renderer emits.
+ *
+ * ```html
+ * <mk-markdown [source]="changelog" linkTarget="_blank" />
+ * ```
+ */
+declare class MkMarkdown {
+    /** Markdown source text. */
+    readonly source: _angular_core.InputSignal<string>;
+    /** Turn bare `http(s)://…` URLs into links. Off by default. */
+    readonly autolink: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Link target; `'_blank'` also adds `rel="noopener noreferrer"`. */
+    readonly linkTarget: _angular_core.InputSignal<"" | "_blank">;
+    /** The rendered (safe-by-construction) HTML string. */
+    protected readonly html: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkMarkdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkMarkdown, "mk-markdown", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "autolink": { "alias": "autolink"; "required": false; "isSignal": true; }; "linkTarget": { "alias": "linkTarget"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Column alignment of a table, from the delimiter row's colons. */
+type MkMarkdownAlign = 'left' | 'center' | 'right' | null;
+/** Inline (phrasing) node of the markdown AST. */
+type MkMarkdownInline = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'softbreak';
+} | {
+    kind: 'break';
+} | {
+    kind: 'code';
+    code: string;
+} | {
+    kind: 'strong';
+    children: MkMarkdownInline[];
+} | {
+    kind: 'em';
+    children: MkMarkdownInline[];
+} | {
+    kind: 'del';
+    children: MkMarkdownInline[];
+} | {
+    kind: 'link';
+    href: string;
+    children: MkMarkdownInline[];
+} | {
+    kind: 'image';
+    src: string;
+    alt: string;
+};
+/** One `<li>`: tight inline content plus an optional nested list. */
+interface MkMarkdownListItem {
+    children: MkMarkdownInline[];
+    sublist: MkMarkdownList | null;
+}
+/** An ordered or unordered (tight) list block. */
+interface MkMarkdownList {
+    kind: 'list';
+    ordered: boolean;
+    /** First ordinal of an ordered list (`3.` starts at 3). Always 1 for bullets. */
+    start: number;
+    items: MkMarkdownListItem[];
+}
+/** Block-level node of the markdown AST. */
+type MkMarkdownBlock = {
+    kind: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: MkMarkdownInline[];
+} | {
+    kind: 'paragraph';
+    children: MkMarkdownInline[];
+} | {
+    kind: 'code';
+    language: string;
+    code: string;
+} | {
+    kind: 'blockquote';
+    children: MkMarkdownBlock[];
+} | {
+    kind: 'hr';
+} | MkMarkdownList | {
+    kind: 'table';
+    align: MkMarkdownAlign[];
+    header: MkMarkdownInline[][];
+    rows: MkMarkdownInline[][][];
+};
+interface MkMarkdownParseOptions {
+    /** Turn bare `http(s)://…` URLs into links. Off by default. */
+    autolink?: boolean;
+}
+interface MkMarkdownRenderOptions {
+    /** `'_blank'` renders `target="_blank" rel="noopener noreferrer"` on links. */
+    linkTarget?: '' | '_blank';
+}
+/**
+ * Parse markdown source into a typed AST. Pure and dependency-free — safe to
+ * run on a server. Unsafe link/image URLs are already dropped at this stage,
+ * so the AST never carries a `javascript:` (or other non-allow-listed) URL.
+ */
+declare function mkParseMarkdown(src: string, options?: MkMarkdownParseOptions): MkMarkdownBlock[];
+/**
+ * Render a parsed AST to an HTML string. The output contains only tags this
+ * renderer generates (all source text is escaped), so it is safe to bind to
+ * `[innerHTML]` — Angular's sanitizer keeps every element/attribute used here.
+ * Fenced code is highlighted via `mkHighlight` for its known languages.
+ */
+declare function mkRenderMarkdown(blocks: MkMarkdownBlock[], options?: MkMarkdownRenderOptions): string;
+
+export { MK_CHART_PALETTE_SIZE, MkAvatar, MkAvatarGroup, MkBadge, MkBarChart, MkCalendarHeatmap, MkCard, MkCardFooter, MkCardHeader, MkCardTitle, MkCarousel, MkCarouselSlide, MkCode, MkCountdown, MkDescItem, MkDescriptionList, MkDiff, MkDivider, MkDonutChart, MkEmptyState, MkFunnelChart, MkGauge, MkHeatmap, MkInlineEdit, MkJsonViewer, MkKanban, MkLineChart, MkList, MkListItem, MkLogViewer, MkMarkdown, MkProfileActions, MkProfileCard, MkProfileMeta, MkProgressBar, MkProgressRing, MkQrCode, MkRadarChart, MkScatterChart, MkSkeleton, MkSkeletonPreset, MkSparkline, MkSpinner, MkStatCard, MkTag, MkTimeline, MkTimelineItem, MkTreemap, MkVirtualScroll, mkArcPath, mkAreaPath, mkBuildJsonTree, mkChartColor, mkComputeDiff, mkDiffStats, mkEncodeQr, mkFormatCompact, mkLinePath, mkLinearScale, mkNiceTicks, mkParseAnsi, mkParseMarkdown, mkRenderMarkdown, mkSplitDuration, mkSquarify, mkStripAnsi };
+export type { MkAnsiSpan, MkAvatarShape, MkAvatarStatus, MkBadgeVariant, MkBarOrientation, MkCalendarHeatmapCell, MkCalendarHeatmapEntry, MkCardPadding, MkCardVariant, MkChartSeries, MkChartSlice, MkDescriptionLayout, MkDiffMode, MkDiffOp, MkDiffOptions, MkDiffRow, MkDiffSegment, MkDiffStats, MkDividerOrientation, MkDurationParts, MkFunnelSegment, MkJsonNode, MkKanbanCard, MkKanbanCardMovedEvent, MkKanbanColumn, MkLogToken, MkMarkdownAlign, MkMarkdownBlock, MkMarkdownInline, MkMarkdownList, MkMarkdownListItem, MkMarkdownParseOptions, MkMarkdownRenderOptions, MkPoint, MkProfileCardOrientation, MkQrEcc, MkScatterPoint, MkScatterSeries, MkSkeletonPresetKind, MkSkeletonShape, MkSparklineType, MkStatTrend, MkTagVariant, MkTreemapItem, MkTreemapRect };