@mk-kit/ui 0.34.0

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

@@ -0,0 +1,3586 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, Signal, ElementRef, TemplateRef, OnInit } from '@angular/core';
+import * as _mk_kit_ui_core from '@mk-kit/ui/core';
+import { MkFieldContext, MkSize, MkVariant, MkTone, MkCodeLanguage, MkPlacement } from '@mk-kit/ui/core';
+export { MkCodeLanguage, mkHighlight } from '@mk-kit/ui/core';
+import { AbstractControl, ControlValueAccessor, Validator, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { MkDropEvent } from '@mk-kit/ui/dnd';
+import { MkTreeNode } from '@mk-kit/ui/navigation';
+export { MkTreeNode } from '@mk-kit/ui/navigation';
+export * from '@mk-kit/ui/checkbox';
+
+/**
+ * FormField — an accessible wrapper that provides a real `<label>`, optional
+ * hint text, error text and a required indicator for any nested control
+ * (`input[mkInput]`, `mk-select`, `mk-checkbox`, …).
+ *
+ * It generates stable ids (via `mkUniqueId`) and exposes them so nested
+ * controls can wire `aria-labelledby` / `aria-describedby` / `aria-invalid`
+ * automatically by injecting this component. While an error shows, the hint is
+ * hidden and the error is announced through a `role="alert"` region.
+ *
+ * ## Automatic errors
+ *
+ * When the projected control is bound to a form (`formControlName`,
+ * `[formControl]` or `[(ngModel)]`) the field adopts its `NgControl` and shows
+ * the first validation error by itself — no `[error]` binding needed. Messages
+ * come from the `validation` i18n table and can be reworded per field with
+ * `errorMessages`. As with `mat-error`, an error only appears once the control
+ * is touched or dirty, or its form has been submitted; `errorOn` changes that.
+ * `required` and the disabled styling are derived from the control too.
+ *
+ * ```html
+ * <!-- automatic: message + required marker come from the validators -->
+ * <mk-form-field label="Email">
+ *   <input mkInput type="email" formControlName="email" />
+ * </mk-form-field>
+ *
+ * <!-- per-field wording -->
+ * <mk-form-field label="Age" [errorMessages]="{ min: 'You must be 18 or over' }">
+ *   <mk-number-input formControlName="age" [min]="18" />
+ * </mk-form-field>
+ *
+ * <!-- fully manual: an explicit [error] always wins -->
+ * <mk-form-field label="Email" hint="We never share it." required
+ *   [error]="emailError()">
+ *   <input mkInput type="email" [(ngModel)]="email" />
+ * </mk-form-field>
+ * ```
+ */
+declare class MkFormField implements MkFieldContext {
+    private readonly i18n;
+    private readonly parentForm;
+    private readonly parentFormGroup;
+    /** Visible field label. Rendered as a real `<label for>`. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Optional helper text shown below the control (hidden while an error shows). */
+    readonly hint: _angular_core.InputSignal<string>;
+    /**
+     * Explicit error message. When non-null it overrides the automatic message
+     * derived from the projected control; `''` suppresses errors entirely.
+     */
+    readonly error: _angular_core.InputSignal<string | null>;
+    /**
+     * Per-field wording for automatic errors, keyed by `ValidationErrors` key.
+     * Each value is either a fixed string or a function of the error payload.
+     */
+    readonly errorMessages: _angular_core.InputSignal<Readonly<Record<string, string | ((err: any) => string)>> | null>;
+    /**
+     * When automatic errors become visible. `touched` (the default) matches
+     * Material: after the control is touched or dirty, or the form is submitted.
+     * `dirty` waits for an actual edit; `always` shows as soon as it is invalid.
+     */
+    readonly errorOn: _angular_core.InputSignal<"always" | "touched" | "dirty">;
+    /**
+     * Marks the field required (adds an indicator + `aria-required`). Derived
+     * from the projected control's validators when it is bound to a form.
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Visually reflect a disabled control. Derived from the projected control
+     * when it is bound to a form.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size; nested controls inherit it. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** The projected control's form binding, when it has one. */
+    private readonly ngControl;
+    /**
+     * Bumped on every change of the bound control so the computed state below
+     * re-reads it. `AbstractControl` is not signal-based, so this bridges its
+     * event stream into the reactive graph.
+     */
+    private readonly controlTick;
+    /** Id for the nested interactive control — adopt on your control element. */
+    readonly controlId: string;
+    /** Id of the `<label>` element (for `aria-labelledby`). */
+    readonly labelId: string;
+    /** Id of the hint element. */
+    readonly hintId: string;
+    /** Id of the error element. */
+    readonly errorId: string;
+    constructor();
+    /** Whether the surrounding form (if any) has been submitted. */
+    private readonly submitted;
+    /** The automatic message for the bound control, when one should show. */
+    private readonly autoError;
+    /** The message actually rendered — an explicit `error` always wins. */
+    readonly errorText: _angular_core.Signal<string | null>;
+    /** Whether the field currently has an error. */
+    readonly hasError: _angular_core.Signal<boolean>;
+    /** Required either explicitly or through the bound control's validators. */
+    readonly isRequired: _angular_core.Signal<boolean>;
+    /** Disabled either explicitly or through the bound control. */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Whether the hint should be shown (hidden while an error is present). */
+    readonly hintVisible: _angular_core.Signal<boolean>;
+    /**
+     * Space-separated id list for a nested control's `aria-describedby`,
+     * or `null` when there is nothing to describe.
+     */
+    readonly describedBy: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkFormField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkFormField, "mk-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "errorOn": { "alias": "errorOn"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["ngControl"], ["*"], true, never>;
+}
+
+/** One field-level error to surface in {@link MkFormErrorSummary}. */
+interface MkFormError {
+    /**
+     * The `id` of the control (or `mk-form-field`'s `controlId`) the message
+     * refers to. Clicking the summary entry focuses this element.
+     */
+    fieldId: string;
+    /** The human-readable error message. */
+    message: string;
+}
+/**
+ * FormErrorSummary — an accessible summary of a form's validation errors,
+ * shown at the top of the form on a failed submit. Each entry links to its
+ * field and focuses it on click. Following the WAI/GOV.UK pattern it is an
+ * `alert` region and, when the surrounding form is submitted with errors,
+ * focus moves here automatically (opt out with `[autoFocus]="false"`) so
+ * screen-reader and keyboard users are taken straight to the problems. The
+ * public `focus()` remains for manual flows (e.g. server-side errors).
+ *
+ * ## Automatic collection
+ *
+ * Point `form` at a `FormGroup` and the summary walks it itself: one entry per
+ * invalid control, worded from the `validation` i18n table (override per key
+ * with `errorMessages`). Pass `labels` to name the fields — without an entry
+ * the control's path is used. Entries appear once the form is submitted;
+ * `showOn="always"` lists them as soon as they exist.
+ *
+ * Each entry is linked to its field by locating the control in the DOM, so
+ * `formControlName` must be a static attribute (`formControlName="email"`,
+ * the usual form) rather than a binding.
+ *
+ * ```html
+ * <!-- automatic -->
+ * <form [formGroup]="form" (ngSubmit)="submit()">
+ *   <mk-form-error-summary #summary [form]="form"
+ *     [labels]="{ email: 'Email address', age: 'Age' }" />
+ *   …
+ * </form>
+ *
+ * <!-- manual -->
+ * <mk-form-error-summary #summary [errors]="errors()" />
+ * …
+ * onSubmit() { if (invalid) { this.errors.set(collect()); this.summary.focus(); } }
+ * ```
+ */
+declare class MkFormErrorSummary {
+    private readonly document;
+    private readonly host;
+    private readonly i18n;
+    private readonly parentForm;
+    private readonly parentFormGroup;
+    /**
+     * Errors to list explicitly. When non-empty this wins over `form`, so a form
+     * can mix automatic collection with server-side errors by not setting it.
+     */
+    readonly errors: _angular_core.InputSignal<readonly MkFormError[]>;
+    /** Collect errors from this control tree instead of passing them in. */
+    readonly form: _angular_core.InputSignal<AbstractControl<any, any, any> | null>;
+    /** Field names for automatic entries, keyed by control path. */
+    readonly labels: _angular_core.InputSignal<Readonly<Record<string, string>>>;
+    /** Per-key wording for automatic entries, as on `mk-form-field`. */
+    readonly errorMessages: _angular_core.InputSignal<Readonly<Record<string, string | ((err: any) => string)>> | null>;
+    /** When automatic entries appear. Defaults to after the form is submitted. */
+    readonly showOn: _angular_core.InputSignal<"always" | "submit">;
+    /** Heading shown above the list. */
+    readonly summaryTitle: _angular_core.InputSignal<string>;
+    /**
+     * Move focus to the summary automatically when the surrounding form is
+     * submitted with errors (the WAI/GOV.UK pattern). Disable to drive focus
+     * yourself via the public `focus()`.
+     */
+    readonly autoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly titleId: string;
+    /** Bumped on every change in the watched control tree. */
+    private readonly formTick;
+    constructor();
+    /** Whether the surrounding form (if any) has been submitted. */
+    private readonly submitted;
+    /** Entries collected from `form`, when one is set and they should show. */
+    private readonly autoErrors;
+    /** The entries actually rendered — an explicit `errors` list wins. */
+    protected readonly shownErrors: _angular_core.Signal<readonly MkFormError[]>;
+    /** Whether there is anything to show. */
+    protected readonly hasErrors: _angular_core.Signal<boolean>;
+    /** Move keyboard focus to the summary (call after a failed submit). */
+    focus(): void;
+    /** Focus the field an entry points at (native anchor jump is unreliable). */
+    protected focusField(event: Event, fieldId: string): void;
+    /**
+     * Resolves a control path to the id of the element to focus. Reactive forms
+     * put `formControlName` in the DOM as a plain attribute, so the control can
+     * be located from its path; the element's own `id` (which `mk-form-field`
+     * assigns) is preferred so the link's `href` anchor also resolves.
+     */
+    private fieldIdFor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkFormErrorSummary, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkFormErrorSummary, "mk-form-error-summary", ["mkFormErrorSummary"], { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "showOn": { "alias": "showOn"; "required": false; "isSignal": true; }; "summaryTitle": { "alias": "summaryTitle"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Input — enhances a native `<input>` or `<textarea>` with mk-kit theming and
+ * a11y wiring. It is an attribute-selector component so all native semantics
+ * and keyboard behaviour come for free; this layers on tokenised styling, aria
+ * state and form integration.
+ *
+ * It provides its own `ControlValueAccessor` (over the native `value`) so
+ * `[(ngModel)]` and reactive forms write back to the DOM reliably — including
+ * when the bound model is reset programmatically. IME composition is buffered
+ * so `onChange` fires once per completed character, matching Angular's built-in
+ * `DefaultValueAccessor`.
+ *
+ * When placed inside an `mk-form-field` it automatically adopts the field's
+ * control id (so the `<label for>` associates), `aria-describedby`,
+ * `aria-invalid` and `aria-required`.
+ *
+ * ```html
+ * <input mkInput type="email" placeholder="you@example.com" />
+ * <textarea mkInput rows="4" [invalid]="true"></textarea>
+ * ```
+ */
+declare class MkInput implements ControlValueAccessor {
+    private readonly field;
+    private readonly group;
+    private readonly host;
+    private readonly initialId;
+    /** Whether this input sits inside an `mk-input-group` (the group then owns the frame). */
+    protected readonly inGroup: boolean;
+    /** Control size. Ignored when nested in an `mk-form-field` (inherits it). */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force the invalid visual + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly resolvedId: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    private onChange;
+    protected onTouched: () => void;
+    /** True while an IME composition is in flight (buffers `onChange`). */
+    private composing;
+    protected onInput(event: Event): void;
+    protected onCompositionStart(): void;
+    protected onCompositionEnd(event: Event): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkInput, "input[mkInput], textarea[mkInput]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * InputGroup — wraps a native `input[mkInput]` with leading / trailing affixes
+ * (icons, static text, compact buttons) inside one shared control frame. The
+ * group carries the border, background and focus ring; the nested input
+ * detects the group and drops its own chrome, so the whole assembly reads as
+ * a single field.
+ *
+ * Project affixes with the `mkInputPrefix` / `mkInputSuffix` attributes. Both
+ * are optional; interactive suffixes (a clear or scan button) keep their own
+ * focus behaviour.
+ *
+ * Inside an `mk-form-field` the group inherits the field's size and invalid
+ * state, and the field's label association still targets the inner input.
+ *
+ * ```html
+ * <mk-input-group>
+ *   <mk-icon mkInputPrefix name="search" />
+ *   <input mkInput type="search" placeholder="Search…" />
+ * </mk-input-group>
+ *
+ * <mk-form-field label="Price">
+ *   <mk-input-group>
+ *     <input mkInput type="number" formControlName="price" />
+ *     <span mkInputSuffix>zł</span>
+ *   </mk-input-group>
+ * </mk-form-field>
+ * ```
+ */
+declare class MkInputGroup {
+    private readonly field;
+    /** Control size. Ignored when nested in an `mk-form-field` (inherits it). */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force the invalid visual when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Visually reflect a disabled inner control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The size the group (and its nested input) renders at. */
+    readonly effectiveSize: _angular_core.Signal<MkSize>;
+    /** Whether the group renders the invalid frame. */
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkInputGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkInputGroup, "mk-input-group", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["[mkInputPrefix]", "*", "[mkInputSuffix]"], true, never>;
+}
+
+/**
+ * SubmitInput — a short text entry and its action button rendered as one
+ * connected control: the "type a code and apply it" pattern (discount codes,
+ * gift cards, invite codes, newsletter sign-up, quick search).
+ *
+ * The button is disabled while the value is empty or blank, shows a spinner
+ * while `loading` and emits {@link submitted} with the **trimmed** value on
+ * click or on Enter.
+ *
+ * ## Enter never submits the surrounding form
+ *
+ * This control is normally dropped inside a bigger form (a checkout, a
+ * settings page), where triggering that form's submit would be a bug. So the
+ * action button is a `type="button"` and, while `submitOnEnter` is on, the
+ * Enter keydown is `preventDefault()`-ed — implicit form submission never
+ * fires. Set `submitOnEnter="false"` to restore the native behaviour and let
+ * Enter reach the enclosing form.
+ *
+ * ## Button content
+ *
+ * The button is configured, not projected: `buttonLabel` sets its text.
+ * Passing `buttonIcon` (a registered {@link MkIcon} name) switches it to the
+ * square icon-only variant, where `buttonLabel` becomes its `aria-label` — so
+ * the action always has an accessible name.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so
+ * `[(ngModel)]`, reactive forms and `[(value)]` all work.
+ *
+ * ```html
+ * <mk-submit-input
+ *   [(value)]="code"
+ *   buttonLabel="Apply"
+ *   [loading]="applying()"
+ *   placeholder="SUMMER10"
+ *   clearable
+ *   (submitted)="apply($event)"
+ * />
+ *
+ * <!-- icon-only, inside a field -->
+ * <mk-form-field label="Search">
+ *   <mk-submit-input buttonIcon="search" buttonLabel="Search" [(ngModel)]="q" />
+ * </mk-form-field>
+ * ```
+ */
+declare class MkSubmitInput implements ControlValueAccessor {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly inputRef;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the whole control (input + button). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Accessible name for the inner input when the control is used outside an
+     * `mk-form-field` (inside one, the field's `<label>` wins). Defaults to the
+     * button's caption.
+     */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Native `type` of the inner input (`text`, `search`, `email`, …). */
+    readonly type: _angular_core.InputSignal<string>;
+    /** Native `autocomplete` hint for the inner input. */
+    readonly autocomplete: _angular_core.InputSignal<string>;
+    /** Two-way value. `submitted` emits it trimmed; the model keeps what was typed. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Button text — or, with `buttonIcon`, the icon button's `aria-label`. */
+    readonly buttonLabel: _angular_core.InputSignal<string>;
+    /** Registered icon name; switches the button to the icon-only variant. */
+    readonly buttonIcon: _angular_core.InputSignal<string>;
+    /** Button visual treatment. */
+    readonly buttonVariant: _angular_core.InputSignal<MkVariant>;
+    /** Button colour tone. */
+    readonly buttonTone: _angular_core.InputSignal<MkTone>;
+    /** Shows a spinner in the button and blocks submitting while an action runs. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a clear affix while the value is non-empty. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Submit on Enter, without submitting an enclosing `<form>`. Turn it off to
+     * let Enter bubble to the form as the browser normally would.
+     */
+    readonly submitOnEnter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emits the current value, trimmed, when the action is triggered. */
+    readonly submitted: _angular_core.OutputEmitterRef<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    /** Id of the inner input — the `<label for>` target inside an `mk-form-field`. */
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    /** Fallback accessible name for the input when no field label describes it. */
+    protected readonly inputLabel: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** The accessible name of the action button in either variant. */
+    protected readonly actionLabel: _angular_core.Signal<string>;
+    /** Whether the clear affix is currently rendered. */
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    /** Blank values, a disabled control and an in-flight action all block submitting. */
+    protected readonly canSubmit: _angular_core.Signal<boolean>;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Emit `submitted` with the trimmed value, when the control allows it. */
+    submit(): void;
+    /** Clear the value and return focus to the input. */
+    clear(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSubmitInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSubmitInput, "mk-submit-input", ["mkSubmitInput"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; "isSignal": true; }; "buttonIcon": { "alias": "buttonIcon"; "required": false; "isSignal": true; }; "buttonVariant": { "alias": "buttonVariant"; "required": false; "isSignal": true; }; "buttonTone": { "alias": "buttonTone"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "submitOnEnter": { "alias": "submitOnEnter"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "submitted": "submitted"; }, never, never, true, never>;
+}
+
+/** One translatable locale offered by {@link MkI18nInput}. */
+interface MkI18nLocale {
+    /** Value key in the bound record, e.g. `pl`. */
+    code: string;
+    /** Short switcher label, e.g. `PL`. */
+    label: string;
+    /** Longer name for the accessible label, e.g. `Polish`. */
+    name?: string;
+}
+/** The bound value: one string per locale code. */
+type MkI18nValue = Record<string, string>;
+/**
+ * I18nInput — one field that edits the same text in several languages.
+ *
+ * The common alternative is stacking one input per language, which grows the
+ * form linearly with locale count and buries the field the author actually
+ * cares about. This shows a single input and a compact switcher, and marks
+ * which locales already have content so nothing is silently left untranslated.
+ *
+ * Binds a `Record<code, string>`, so it drops into reactive forms as one
+ * control instead of a nested group:
+ *
+ * ```html
+ * <mk-form-field label="Name">
+ *   <mk-i18n-input formControlName="name" [locales]="locales" />
+ * </mk-form-field>
+ * ```
+ *
+ * ```ts
+ * locales = [
+ *   { code: 'en', label: 'EN', name: 'English' },
+ *   { code: 'pl', label: 'PL', name: 'Polish' },
+ * ];
+ * ```
+ */
+declare class MkI18nInput implements ControlValueAccessor {
+    /** Locales offered, in switcher order. The first is the initial tab. */
+    readonly locales: _angular_core.InputSignal<readonly MkI18nLocale[]>;
+    /** Render a textarea instead of a single-line input. */
+    readonly multiline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Textarea rows (ignored unless `multiline`). */
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Placeholder for the active locale's input. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Control size, forwarded to the input and the switcher. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /**
+     * Locale codes that must be filled. They get a marker in the switcher while
+     * empty, so a missing translation is visible without switching to it.
+     */
+    readonly requiredLocales: _angular_core.InputSignal<readonly string[]>;
+    /** Disable the whole control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly value;
+    private readonly cvaDisabled;
+    protected readonly activeCode: _angular_core.WritableSignal<string | null>;
+    /** The locale currently being edited — the first one until switched. */
+    protected readonly active: _angular_core.Signal<MkI18nLocale>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Text for the active locale. */
+    protected readonly activeText: _angular_core.Signal<string>;
+    /** Locale codes that currently hold text — drives the switcher markers. */
+    protected readonly filled: _angular_core.Signal<Set<string>>;
+    /** True when a required locale is still empty. */
+    protected missing(code: string): boolean;
+    protected onSwitch(code: string): void;
+    protected onInput(text: string): void;
+    protected onBlur(): void;
+    /** Accessible label for a switcher item, e.g. "Polish — missing". */
+    protected switcherAria(locale: MkI18nLocale): string;
+    private onChange;
+    private onTouched;
+    writeValue(value: MkI18nValue | null): void;
+    registerOnChange(fn: (value: MkI18nValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkI18nInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkI18nInput, "mk-i18n-input", never, { "locales": { "alias": "locales"; "required": false; "isSignal": true; }; "multiline": { "alias": "multiline"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "requiredLocales": { "alias": "requiredLocales"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** A single selectable option for {@link MkSelect}. */
+interface MkSelectOption {
+    /** Text shown to the user (and used for typeahead). */
+    label: string;
+    /** The value bound to the form control when chosen. */
+    value: unknown;
+    /** Disable the option (skipped by keyboard + not selectable). */
+    disabled?: boolean;
+}
+/**
+ * Select — a fully custom, accessible single-select implementing the ARIA
+ * listbox/combobox pattern. Options are supplied via the `options` input.
+ *
+ * Keyboard: Up/Down to move, Home/End to jump, Enter/Space to select, Esc to
+ * close, and typeahead by typing option text. Focus stays on the trigger
+ * (`aria-activedescendant` pattern) for robust screen-reader behaviour.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so it
+ * works with `[(ngModel)]`, reactive forms and `[(value)]`.
+ *
+ * ```html
+ * <mk-select placeholder="Pick a role"
+ *   [options]="[{label:'Admin', value:'admin'}, {label:'Editor', value:'editor'}]"
+ *   [(ngModel)]="role" />
+ * ```
+ */
+declare class MkSelect implements ControlValueAccessor, OnDestroy {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly triggerRef;
+    /** The list of options to choose from. */
+    readonly options: _angular_core.InputSignal<readonly MkSelectOption[]>;
+    /** Placeholder shown when nothing is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Two-way selected value. */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    private typeahead;
+    private typeaheadTimer?;
+    readonly listId: string;
+    readonly triggerId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly selectedIndex: _angular_core.Signal<number>;
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    protected optionId(index: number): string;
+    protected toggle(): void;
+    private openList;
+    protected close(): void;
+    protected selectOption(index: number): void;
+    protected onKeydown(event: Event): void;
+    protected onBlur(): void;
+    private move;
+    private firstEnabled;
+    private lastEnabled;
+    private typeaheadSearch;
+    private focusTrigger;
+    ngOnDestroy(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSelect, "mk-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** A single suggestion for {@link MkAutocomplete}. */
+interface MkAutocompleteOption {
+    /** Text shown to the user and used as the input display value when chosen. */
+    label: string;
+    /** The value bound to the form control when this option is selected. */
+    value: unknown;
+    /** Disable the option (skipped by keyboard + not selectable). */
+    disabled?: boolean;
+    /**
+     * Muted second line under the label — the disambiguator when labels can
+     * collide (two customers named Jan Kowalski, telling accounts apart by
+     * email, an id under a product name).
+     */
+    description?: string;
+}
+/** How the option list is narrowed against the typed text. */
+type MkAutocompleteFilterMode = 'contains' | 'startsWith' | 'none';
+/**
+ * Autocomplete — an accessible text input that suggests options as the user
+ * types, implementing the ARIA combobox (`aria-autocomplete="list"`) pattern
+ * with a popup listbox.
+ *
+ * Filtering is built in (`contains` / `startsWith`); set `filterMode="none"`
+ * and drive `options` yourself from the `search` output for async/server-side
+ * suggestions. Typing arbitrary text is allowed unless `requireSelection` is
+ * set, in which case the field clears on blur if it doesn't match an option.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so it
+ * works with `[(ngModel)]`, reactive forms and `[(value)]`. When nested in an
+ * `mk-form-field` it inherits size, label, hint/error and required wiring.
+ *
+ * ```html
+ * <mk-autocomplete placeholder="Search users"
+ *   [options]="filtered()"
+ *   filterMode="none"
+ *   (search)="query.set($event)"
+ *   [(value)]="userId" />
+ * ```
+ */
+declare class MkAutocomplete implements ControlValueAccessor {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly announcer;
+    private readonly inputRef;
+    /** Last announced result count (guards repeat announcements). */
+    private lastAnnouncedCount;
+    constructor();
+    /** The list of suggestions. Update it from `search` for async sources. */
+    readonly options: _angular_core.InputSignal<readonly MkAutocompleteOption[]>;
+    /** Placeholder shown when the input is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** How the option list is filtered against the typed text. */
+    readonly filterMode: _angular_core.InputSignal<MkAutocompleteFilterMode>;
+    /** Only open the list once this many characters have been typed. */
+    readonly minChars: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show a loading row instead of "no results" (for async fetches). */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Clear the input on blur unless the text matches a selectable option. */
+    readonly requireSelection: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Message shown when there are no matching options. */
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    /** Two-way selected value (the `value` of the chosen option, or `null`). */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    /** Emits the current input text on every keystroke — drive async loading. */
+    readonly search: _angular_core.OutputEmitterRef<string>;
+    /** Emits the option whenever one is committed by click or Enter. */
+    readonly optionSelected: _angular_core.OutputEmitterRef<MkAutocompleteOption>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly listId: string;
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Options after applying the built-in filter (or all, when `none`). */
+    protected readonly filtered: _angular_core.Signal<readonly MkAutocompleteOption[]>;
+    protected readonly hasResults: _angular_core.Signal<boolean>;
+    protected optionId(index: number): string;
+    /** The option matching the current value, if any. */
+    private optionForValue;
+    protected onInput(event: Event): void;
+    protected onFocus(): void;
+    private openIfEligible;
+    protected close(): void;
+    protected selectOption(index: number): void;
+    protected onKeydown(event: Event): void;
+    protected onBlur(): void;
+    /**
+     * When `requireSelection` is set, drop free text that doesn't map to an
+     * option; otherwise restore the committed option's label if one exists.
+     */
+    private reconcileOnBlur;
+    protected onOutsideDismiss(): void;
+    protected clear(): void;
+    private move;
+    private firstEnabled;
+    private lastEnabled;
+    private focusInput;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkAutocomplete, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkAutocomplete, "mk-autocomplete", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "minChars": { "alias": "minChars"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "requireSelection": { "alias": "requireSelection"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "search": "search"; "optionSelected": "optionSelected"; }, never, never, true, never>;
+}
+
+/** How mention suggestions are narrowed against the typed query. */
+type MkMentionFilterMode = 'contains' | 'startsWith' | 'none';
+/** A single suggestion offered by {@link MkMention}. */
+interface MkMentionOption {
+    /** Machine identifier (username, tag slug) — also matched when filtering. */
+    value: string;
+    /** Text shown in the panel; the default insertion writes `trigger + label`. */
+    label: string;
+    /** Muted, single-line disambiguator shown after the label (e-mail, count…). */
+    hint?: string;
+    /**
+     * Offer this option for one trigger character only (e.g. `'#'` for tags).
+     * Options without a `trigger` are offered for every trigger.
+     */
+    trigger?: string;
+}
+/** Payload of {@link MkMention.mentionSearch}. */
+interface MkMentionSearchEvent {
+    /** The trigger character that opened the session (`'@'`, `'#'`, …). */
+    trigger: string;
+    /** Text typed between the trigger and the caret. */
+    query: string;
+}
+/** Payload of {@link MkMention.mentionSelect}. */
+interface MkMentionSelectEvent {
+    option: MkMentionOption;
+    trigger: string;
+}
+/**
+ * Mention / hashtag autocomplete for a **native** `<textarea>` or text
+ * `<input>`. Typing a trigger character (`@`, `#`, …) at the start of a word
+ * opens a top-layer suggestion panel anchored at the caret; picking an option
+ * replaces the trigger-plus-query with the completed mention and dispatches an
+ * `input` event so `ngModel`/reactive-forms bindings stay in sync.
+ *
+ * The element keeps its native textbox semantics — no `role="combobox"` — and
+ * follows the ARIA activedescendant pattern while the panel is open
+ * (`aria-autocomplete="list"`, `aria-controls`, `aria-expanded`,
+ * `aria-activedescendant`).
+ *
+ * Filtering is built in (`contains` / `startsWith` over label + value); set
+ * `mentionFilter="none"` and drive `mentionOptions` from the `mentionSearch`
+ * output for async/server-side suggestions (`mentionLoading` keeps the panel
+ * open with a spinner while results are in flight).
+ *
+ * ```html
+ * <textarea mkMention
+ *   [mentionTriggers]="['@', '#']"
+ *   [mentionOptions]="users"
+ *   (mentionSelect)="onPick($event)"
+ * ></textarea>
+ * ```
+ */
+declare class MkMention implements OnDestroy {
+    private readonly host;
+    private readonly document;
+    private readonly vcr;
+    /** Single characters that start a mention session. */
+    readonly mentionTriggers: _angular_core.InputSignal<readonly string[]>;
+    /** The suggestion pool. Update it from `mentionSearch` for async sources. */
+    readonly mentionOptions: _angular_core.InputSignal<readonly MkMentionOption[]>;
+    /** How suggestions are filtered against the typed query. */
+    readonly mentionFilter: _angular_core.InputSignal<MkMentionFilterMode>;
+    /** Keep the panel open with a loading row while async results are pending. */
+    readonly mentionLoading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Builds the text inserted for a picked option. Defaults to
+     * `` `${trigger}${option.label} ` `` (note the trailing space).
+     */
+    readonly mentionInsert: _angular_core.InputSignal<((option: MkMentionOption, trigger: string) => string) | null>;
+    /** Emits `{trigger, query}` whenever the active query changes — drive async loading. */
+    readonly mentionSearch: _angular_core.OutputEmitterRef<MkMentionSearchEvent>;
+    /** Emits after an option has been inserted into the control. */
+    readonly mentionSelect: _angular_core.OutputEmitterRef<MkMentionSelectEvent>;
+    /** Id of the listbox panel, wired to `aria-controls` while open. */
+    readonly listId: string;
+    private readonly session;
+    private readonly activeIndex;
+    /** Caret anchor point (viewport px) the panel is positioned against. */
+    private readonly caretAnchor;
+    /**
+     * Trigger index dismissed via Escape. The session stays closed while the
+     * caret remains in a mention context at this index — i.e. until a new
+     * trigger is typed elsewhere (or this one is deleted).
+     */
+    private dismissedStart;
+    private panelRef;
+    /** Options for the active session, after trigger scoping + filtering. */
+    private readonly filtered;
+    /**
+     * The panel shows while a session is active and there is something to show:
+     * matching options, or a pending async fetch (`mentionLoading`). Zero
+     * options with nothing pending closes the panel (the session itself stays
+     * active, so async results arriving later reopen it).
+     */
+    protected readonly panelOpen: _angular_core.Signal<boolean>;
+    protected readonly activeOptionId: _angular_core.Signal<string | null>;
+    constructor();
+    /**
+     * Looks backwards from the caret for a trigger character that starts a
+     * mention context: the trigger must sit at the start of the text or be
+     * preceded by whitespace, and the text between it and the caret (the query)
+     * must contain no whitespace and stay under {@link MAX_QUERY} characters.
+     */
+    private detect;
+    /** Re-evaluates the mention context after typing or caret movement. */
+    protected update(): void;
+    private closeSession;
+    protected onKeydown(event: Event): void;
+    /** Caret-only movements never fire `input`; re-detect on their keyup. */
+    protected onKeyup(event: Event): void;
+    private move;
+    protected onBlur(event: Event): void;
+    private commit;
+    private createPanel;
+    private destroyPanel;
+    ngOnDestroy(): void;
+    /**
+     * Caret pixel position via the mirror-div technique: an offscreen `<div>`
+     * cloning the control's text layout gets the value up to the caret plus a
+     * marker span; the marker's rect, offset by the control's own rect and
+     * scroll position, is the caret's viewport coordinate. Returns the point
+     * just **below** the caret's line so the panel opens under it.
+     *
+     * Environments without layout (SSR, jsdom) safely yield `{0, 0}`.
+     */
+    private caretPoint;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkMention, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkMention, "textarea[mkMention], input[mkMention]", ["mkMention"], { "mentionTriggers": { "alias": "mentionTriggers"; "required": false; "isSignal": true; }; "mentionOptions": { "alias": "mentionOptions"; "required": false; "isSignal": true; }; "mentionFilter": { "alias": "mentionFilter"; "required": false; "isSignal": true; }; "mentionLoading": { "alias": "mentionLoading"; "required": false; "isSignal": true; }; "mentionInsert": { "alias": "mentionInsert"; "required": false; "isSignal": true; }; }, { "mentionSearch": "mentionSearch"; "mentionSelect": "mentionSelect"; }, never, never, true, never>;
+}
+
+/**
+ * Suggestion listbox for {@link MkMention}. Created dynamically by the
+ * directive and wired imperatively right after creation: the directive hands
+ * it read-only signals (options, active index, caret anchor point) plus plain
+ * callbacks, so the panel re-renders reactively without `setInput` churn.
+ *
+ * The `<ul>` is promoted to the top layer by `mkAnchoredPanel` and positioned
+ * at the caret point; this host element stays empty in place.
+ *
+ * Not intended for direct use — the public API is the `[mkMention]` directive.
+ */
+declare class MkMentionPanel {
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    options: Signal<readonly MkMentionOption[]>;
+    activeIndex: Signal<number>;
+    /** Caret point (viewport px) the panel is anchored to. */
+    anchorPoint: Signal<{
+        x: number;
+        y: number;
+    }>;
+    loading: Signal<boolean>;
+    listId: string;
+    /**
+     * The mention control itself — passed as the anchored panel's element
+     * anchor so pointerdowns inside the control don't count as "outside"
+     * dismissals (the point anchor still wins for positioning).
+     */
+    anchorEl: HTMLElement | undefined;
+    onPick: (index: number) => void;
+    onHover: (index: number) => void;
+    onDismiss: () => void;
+    private readonly panel;
+    /** The teleported listbox element (used for the blur containment guard). */
+    readonly list: Signal<ElementRef<HTMLUListElement> | undefined>;
+    constructor();
+    optionId(index: number): string;
+    protected pick(event: Event, index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkMentionPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkMentionPanel, "mk-mention-panel", never, {}, {}, never, never, true, never>;
+}
+
+/** A single selectable option for {@link MkMultiSelect}. */
+interface MkMultiSelectOption {
+    /** Text shown to the user (and used for the chip + typeahead). */
+    label: string;
+    /** The value committed to the form control when chosen. */
+    value: unknown;
+    /** Disable the option (skipped by keyboard + not selectable). */
+    disabled?: boolean;
+}
+/** How the option list is narrowed against the typed text. */
+type MkMultiSelectFilterMode = 'contains' | 'startsWith' | 'none';
+/**
+ * MultiSelect — an accessible combobox that commits **multiple** values,
+ * rendering each selection as a removable chip inside the control. Implements
+ * the ARIA combobox + multiselectable listbox pattern.
+ *
+ * Filtering is built in (`contains` / `startsWith`); set `filterMode="none"`
+ * and drive `options` from the `search` output for async / server-side sources.
+ * Selected options are remembered even after they leave the `options` list, so
+ * chips keep their labels across async pages.
+ *
+ * Implements `ControlValueAccessor` over an **array** value and exposes a
+ * two-way `value` model, so it works with `[(ngModel)]`, reactive forms and
+ * `[(value)]`. When nested in an `mk-form-field` it inherits size, label,
+ * hint/error and required wiring.
+ *
+ * Keyboard: type to filter, Up/Down to move, Home/End to jump, Enter/Space to
+ * toggle the active option, Backspace on an empty query removes the last chip,
+ * Escape closes. The dropdown renders in the top layer via
+ * {@link MkAnchoredPanel} so it is never clipped by a container.
+ *
+ * ```html
+ * <mk-multi-select placeholder="Add tags"
+ *   [options]="tagOptions()"
+ *   [(value)]="tags" />
+ * ```
+ */
+declare class MkMultiSelect implements ControlValueAccessor, Validator {
+    private readonly field;
+    private readonly host;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly announcer;
+    private readonly inputRef;
+    /** The list of options to choose from. Update from `search` for async. */
+    readonly options: _angular_core.InputSignal<readonly MkMultiSelectOption[]>;
+    /** Placeholder shown when no value is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** How the option list is filtered against the typed text. */
+    readonly filterMode: _angular_core.InputSignal<MkMultiSelectFilterMode>;
+    /** Only open the list once this many characters have been typed. */
+    readonly minChars: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show a loading row instead of "no results" (for async fetches). */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Maximum number of selections (0 = unlimited). */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Close the dropdown after each selection. Default keeps it open. */
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Message shown when there are no matching options. */
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    /** Two-way selected values. */
+    readonly value: _angular_core.ModelSignal<unknown[]>;
+    /** Emits the current query text on every keystroke — drive async loading. */
+    readonly search: _angular_core.OutputEmitterRef<string>;
+    /** Emits the option whenever one is added. */
+    readonly optionAdded: _angular_core.OutputEmitterRef<MkMultiSelectOption>;
+    /** Emits the value whenever a selection is removed. */
+    readonly optionRemoved: _angular_core.OutputEmitterRef<unknown>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly listId: string;
+    readonly inputId: string;
+    /**
+     * Every option ever seen, keyed by value — so chips keep their labels even
+     * after the option leaves the (async, filtered) `options` list.
+     */
+    private readonly seen;
+    /** Last announced result count (guards repeat announcements). */
+    private lastAnnouncedCount;
+    /**
+     * Skips the next results-count announcement — set when a selection resets
+     * the query, so "x added" is not immediately clobbered by "n results".
+     */
+    private suppressCountAnnouncement;
+    constructor();
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Whether the selection cap has been reached. */
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    /** Why unselected options are unavailable once the cap is reached. */
+    protected readonly atMaxHint: _angular_core.Signal<string>;
+    /** The selected values resolved to option objects (for the chips). */
+    protected readonly chips: _angular_core.Signal<MkMultiSelectOption[]>;
+    /** Options after the built-in filter (or all, when `none`). */
+    protected readonly filtered: _angular_core.Signal<readonly MkMultiSelectOption[]>;
+    protected readonly hasResults: _angular_core.Signal<boolean>;
+    protected optionId(index: number): string;
+    protected isSelected(value: unknown): boolean;
+    protected onInput(event: Event): void;
+    protected onFocus(): void;
+    private openIfEligible;
+    protected close(): void;
+    /** Add or remove the option at `index` in the filtered list. */
+    protected toggleOption(index: number): void;
+    private add;
+    private remove;
+    /** Remove a chip from its remove button. */
+    protected removeChip(value: unknown): void;
+    protected onKeydown(event: Event): void;
+    protected onBlur(event: Event): void;
+    protected onOutsideDismiss(): void;
+    /** Clicking anywhere in the control focuses the input. */
+    protected onControlPointerdown(event: Event): void;
+    private move;
+    private firstEnabled;
+    private lastEnabled;
+    private focusInput;
+    private setValue;
+    writeValue(value: unknown[] | null): void;
+    registerOnChange(fn: (value: unknown[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMaxItems` when more options are selected than `[max]` allows.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkMultiSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkMultiSelect, "mk-multi-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "minChars": { "alias": "minChars"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "search": "search"; "optionAdded": "optionAdded"; "optionRemoved": "optionRemoved"; }, never, never, true, never>;
+}
+
+/**
+ * TagInput — a freeform token input: type a value and press Enter (or a
+ * separator) to add it as a removable chip. Backspace on an empty field removes
+ * the last tag, and pasting a delimited string adds several at once. Unlike
+ * `mk-multi-select` the tags are not drawn from a fixed option list. Implements
+ * `ControlValueAccessor` + a two-way `value` model of `string[]`.
+ *
+ * ```html
+ * <mk-tag-input placeholder="Add tags…" [(value)]="tags" />
+ * ```
+ */
+declare class MkTagInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly announcer;
+    private readonly host;
+    private readonly injector;
+    private readonly inputRef;
+    /** Two-way list of tags. */
+    readonly value: _angular_core.ModelSignal<string[]>;
+    /** Placeholder shown in the text field. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Maximum number of tags (0 = unlimited). */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Allow the same tag more than once. */
+    readonly allowDuplicates: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Commit the pending text as a tag when the field loses focus. */
+    readonly addOnBlur: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Extra characters that commit the pending text (Enter always does). A
+     * pasted string is split on these too. Default: comma.
+     */
+    readonly separators: _angular_core.InputSignal<readonly string[]>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Emitted when a tag is added. */
+    readonly added: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when a tag is removed. */
+    readonly removed: _angular_core.OutputEmitterRef<string>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    protected focusInput(): void;
+    protected onQueryInput(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onPaste(event: ClipboardEvent): void;
+    protected onBlur(): void;
+    private splitPattern;
+    private commit;
+    /**
+     * Reset the pending text. A one-way `[value]="query()"` binding does not
+     * reliably push an empty value back onto an input the user has just edited,
+     * so clear the native element directly as well as the signal.
+     */
+    private clearQuery;
+    protected removeAt(index: number): boolean;
+    /**
+     * Remove a chip via its remove button. The button disappears with the chip,
+     * so keep focus useful: the next chip's remove button, else the previous
+     * one's, else the text input.
+     */
+    protected removeChipAt(index: number): void;
+    private setValue;
+    writeValue(value: string[] | null): void;
+    registerOnChange(fn: (value: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMaxItems` when more tags are present than `[max]` allows.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTagInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTagInput, "mk-tag-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; "separators": { "alias": "separators"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "added": "added"; "removed": "removed"; }, never, never, true, never>;
+}
+
+/** A single password rule with its current pass/fail state. */
+interface MkPasswordRule {
+    readonly key: 'length' | 'uppercase' | 'number' | 'symbol';
+    readonly label: string;
+    readonly met: boolean;
+}
+/**
+ * PasswordInput — a password field with a reveal toggle, an optional strength
+ * meter and an optional rules checklist. Implements `ControlValueAccessor` over
+ * `string` with a two-way `value` model, and wires label / description /
+ * validity a11y automatically when nested in an `mk-form-field`.
+ *
+ * ```html
+ * <mk-password-input [(value)]="pw" showStrength showRules [minLength]="10" />
+ * ```
+ */
+declare class MkPasswordInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly inputRef;
+    /** Two-way value. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Placeholder when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored inside an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling when standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the 0–4 strength meter below the field. */
+    readonly showStrength: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the rules checklist below the field. */
+    readonly showRules: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Minimum length used by the strength score and rules. */
+    readonly minLength: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * `autocomplete` for the native input. Use `'new-password'` on signup /
+     * change-password forms (where the strength meter and rules belong) so the
+     * browser offers a generated password instead of the saved one.
+     */
+    readonly autocomplete: _angular_core.InputSignal<(string & {}) | "current-password" | "new-password">;
+    protected readonly inputId: string;
+    protected readonly strengthId: string;
+    protected readonly rulesId: string;
+    /** Whether the password characters are currently visible. */
+    protected readonly revealed: _angular_core.WritableSignal<boolean>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    /** The four rules and whether the current value satisfies each. */
+    protected readonly rules: _angular_core.Signal<MkPasswordRule[]>;
+    /**
+     * Password strength as a 0–4 score, counting distinct character classes
+     * (lowercase, uppercase, digit, symbol) plus a length ≥ minLength bonus,
+     * capped at 4.
+     */
+    protected readonly strength: _angular_core.Signal<number>;
+    protected readonly strengthLabel: _angular_core.Signal<string>;
+    /** The 4 meter segments, marked filled up to the current score. */
+    protected readonly segments: _angular_core.Signal<boolean[]>;
+    /** Combined `aria-describedby` for the input, or `null`. */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected toggleReveal(): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `minlength` for a password shorter than `[minLength]` — the same
+     * requirement the rules list shows. An empty value passes; compose with
+     * `Validators.required` to reject it.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPasswordInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkPasswordInput, "mk-password-input", ["mkPasswordInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "showStrength": { "alias": "showStrength"; "required": false; "isSignal": true; }; "showRules": { "alias": "showRules"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** A single transferable item for {@link MkTransferList}. */
+interface MkTransferItem {
+    /** The value committed to the form control when the item is in the selected list. */
+    value: unknown;
+    /** Text shown to the user. */
+    label: string;
+    /** Disable the item (cannot be checked or moved). */
+    disabled?: boolean;
+}
+/** Which of the two lists a row belongs to. */
+type MkTransferSide = 'available' | 'selected';
+/**
+ * TransferList — a dual list box (a.k.a. pick list) for moving items between an
+ * **available** list and a **selected** list, e.g. assigning roles or
+ * permissions. The user checks rows in one list then clicks the middle move
+ * buttons (or presses Enter on a row) to shuttle them across.
+ *
+ * Implements `ControlValueAccessor` over an **array** value (the values in the
+ * selected list) and exposes a two-way `value` model, so it works with
+ * `[(ngModel)]`, reactive forms and `[(value)]`. When nested in an
+ * `mk-form-field` it inherits size and label wiring.
+ *
+ * Keyboard: each listbox is a single tab stop (roving tabindex). Arrow Up/Down
+ * and Home/End move between rows, Space toggles a row's check and Enter moves
+ * it to the opposite list.
+ *
+ * ```html
+ * <mk-transfer-list filterable
+ *   [items]="allRoles()"
+ *   [(value)]="assignedRoles"
+ *   availableLabel="All roles"
+ *   selectedLabel="Assigned" />
+ * ```
+ */
+declare class MkTransferList implements ControlValueAccessor {
+    private readonly host;
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly announcer;
+    private readonly injector;
+    private readonly availableOptEls;
+    private readonly selectedOptEls;
+    private readonly availableListEl;
+    private readonly selectedListEl;
+    /** The full set of items to shuttle between the two lists. */
+    readonly items: _angular_core.InputSignal<readonly MkTransferItem[]>;
+    /** Heading for the left (available) list. */
+    readonly availableLabel: _angular_core.InputSignal<string>;
+    /** Heading for the right (selected) list. */
+    readonly selectedLabel: _angular_core.InputSignal<string>;
+    /** Show a search box over each list. */
+    readonly filterable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the whole control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling + `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>;
+    /** Two-way values currently in the selected (right) list. */
+    readonly value: _angular_core.ModelSignal<unknown[]>;
+    /** Emits the new selected values whenever items are moved. */
+    readonly change: _angular_core.OutputEmitterRef<unknown[]>;
+    private readonly cvaDisabled;
+    /** Values checked in each list, awaiting a move. */
+    private readonly checkedAvailable;
+    private readonly checkedSelected;
+    /** Per-list search queries (only used when `filterable`). */
+    protected readonly availableQuery: _angular_core.WritableSignal<string>;
+    protected readonly selectedQuery: _angular_core.WritableSignal<string>;
+    /** Roving-tabindex active option index per list. */
+    private readonly activeAvailable;
+    private readonly activeSelected;
+    private onChange;
+    private onTouched;
+    readonly baseId: string;
+    readonly availableListId: string;
+    readonly selectedListId: string;
+    readonly availableLabelId: string;
+    readonly selectedLabelId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    /** Items keyed by value, for resolving the selected order. */
+    private readonly byValue;
+    /** Items not currently in the value (in `items` order). */
+    protected readonly available: _angular_core.Signal<readonly MkTransferItem[]>;
+    /** Items currently in the value, preserving the value array order. */
+    protected readonly selected: _angular_core.Signal<readonly MkTransferItem[]>;
+    protected readonly filteredAvailable: _angular_core.Signal<readonly MkTransferItem[]>;
+    protected readonly filteredSelected: _angular_core.Signal<readonly MkTransferItem[]>;
+    private applyFilter;
+    /** Whether the "move right" controls are actionable. */
+    protected readonly canMoveRight: _angular_core.Signal<boolean>;
+    /** Whether the "move left" controls are actionable. */
+    protected readonly canMoveLeft: _angular_core.Signal<boolean>;
+    protected readonly canMoveAllRight: _angular_core.Signal<boolean>;
+    protected readonly canMoveAllLeft: _angular_core.Signal<boolean>;
+    protected isChecked(side: MkTransferSide, value: unknown): boolean;
+    private checkedFor;
+    /** Toggle a row's checked state (Space / click on the row). */
+    protected toggleCheck(side: MkTransferSide, item: MkTransferItem): void;
+    protected onQueryInput(side: MkTransferSide, event: Event): void;
+    private filteredFor;
+    private activeSignalFor;
+    /** The active (tabbable) option index for a list, clamped to its length. */
+    protected activeIdx(side: MkTransferSide): number;
+    /** Keep the roving index in sync when an option is focused (e.g. by click). */
+    protected setActive(side: MkTransferSide, index: number): void;
+    /** Move the active index and focus that option. */
+    private moveActive;
+    private focusOption;
+    /**
+     * After a move, keep focus useful: focus the source list's next remaining
+     * option, or the (empty) list element itself.
+     */
+    private focusAfterMove;
+    private announceMove;
+    protected onRowKeydown(side: MkTransferSide, item: MkTransferItem, event: Event): void;
+    /** Move a single item to the opposite list (Enter on a row). */
+    private moveOne;
+    /** Move all checked available items into the selected list. */
+    protected moveRight(): void;
+    /** Move all checked selected items back to the available list. */
+    protected moveLeft(): void;
+    /** Move every movable available item into the selected list. */
+    protected moveAllRight(): void;
+    /** Move every movable selected item back to the available list. */
+    protected moveAllLeft(): void;
+    private uncheck;
+    private commit;
+    /**
+     * Marks the control touched once focus leaves it entirely, so a form that
+     * gates its errors on `touched` behaves the same here as on a native input.
+     */
+    protected onFocusOut(event: FocusEvent): void;
+    writeValue(value: unknown[] | null): void;
+    registerOnChange(fn: (value: unknown[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTransferList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTransferList, "mk-transfer-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "availableLabel": { "alias": "availableLabel"; "required": false; "isSignal": true; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "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": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "change": "change"; }, never, never, true, never>;
+}
+
+/** Template context for a {@link MkRepeaterRow} row template. */
+interface MkRepeaterRowContext<T> {
+    /** The row's item — destructure with `let-item`. */
+    $implicit: T;
+    /** The row's current index — destructure with `let-i="index"`. */
+    index: number;
+}
+/**
+ * Marks an `<ng-template>` as the row template for {@link MkRepeater}. The
+ * template receives the item as its implicit context plus its `index`:
+ *
+ * ```html
+ * <ng-template mkRepeaterRow let-item let-i="index">
+ *   <input mkInput [(ngModel)]="item.name" />
+ * </ng-template>
+ * ```
+ */
+declare class MkRepeaterRow<T = unknown> {
+    /** The projected row template, rendered once per item. */
+    readonly template: TemplateRef<MkRepeaterRowContext<T>>;
+    static ngTemplateContextGuard<T>(_dir: MkRepeaterRow<T>, _ctx: unknown): _ctx is MkRepeaterRowContext<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRepeaterRow<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkRepeaterRow<any>, "[mkRepeaterRow]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marks an `<ng-template>` as {@link MkRepeater}'s custom empty state, shown
+ * instead of the row list while there are no items.
+ */
+declare class MkRepeaterEmpty {
+    /** The projected empty-state template. */
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRepeaterEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkRepeaterEmpty, "[mkRepeaterEmpty]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Repeater — the schema-friendly editable list: renders one instance of a
+ * consumer-projected row template per item, with add / remove / (optional)
+ * drag-and-drop + keyboard reorder built in.
+ *
+ * `items` is a two-way model and the component also implements
+ * `ControlValueAccessor` over `T[]`, so it drops into template-driven and
+ * reactive forms alike. **Every mutation produces a new array** — the
+ * consumer's array is never mutated in place.
+ *
+ * Rows are tracked by **item object identity** (stable across the repeater's
+ * immutable array copies), so removing a middle row keeps the following rows'
+ * DOM — and any in-progress input state — intact. Consequently, arrays of
+ * primitives with duplicate values (e.g. `['a', 'a']`) are not supported
+ * directly: wrap each value in an object (`{ value: 'a' }`) so every row has
+ * a distinct identity.
+ *
+ * With `reorderable`, each row gets a drag handle wired through the dnd
+ * module's touch-safe handle-based configuration (a swipe on the row body
+ * still scrolls the page). Reordering also works by keyboard: focus the
+ * handle (or the row) and press Space/Enter to pick up, arrows to move,
+ * Space/Enter to drop, Escape to cancel. Each completed reorder is announced
+ * via {@link MkLiveAnnouncer}.
+ *
+ * ```html
+ * <mk-repeater [(items)]="rows" [min]="1" [max]="10" reorderable
+ *              [factory]="newRow" addLabel="Add row">
+ *   <ng-template mkRepeaterRow let-item let-i="index">
+ *     <input mkInput [(ngModel)]="item.name" />
+ *   </ng-template>
+ *   <ng-template mkRepeaterEmpty>No rows yet.</ng-template>
+ * </mk-repeater>
+ * ```
+ *
+ * @typeParam T item data type.
+ */
+declare class MkRepeater<T = unknown> implements ControlValueAccessor {
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly announcer;
+    /** The rows (two-way). Every mutation sets a **new** array. */
+    readonly items: _angular_core.ModelSignal<T[]>;
+    /** Creates the item appended by the add button. Default: `{}` cast to `T`. */
+    readonly factory: _angular_core.InputSignal<() => T>;
+    /** Minimum number of rows — remove buttons disable at (or below) it. */
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Maximum number of rows (0 = unlimited) — the add button disables at it. */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Enable per-row drag handles (pointer + keyboard reorder). */
+    readonly reorderable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the whole control (add, remove and reorder). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Add-button caption. Defaults to the i18n `repeaterAddRow` string. */
+    readonly addLabel: _angular_core.InputSignal<string>;
+    /** Emitted after the add button appended a factory-made item. */
+    readonly added: _angular_core.OutputEmitterRef<{
+        item: T;
+        index: number;
+    }>;
+    /** Emitted after a row was removed. */
+    readonly removed: _angular_core.OutputEmitterRef<{
+        item: T;
+        index: number;
+    }>;
+    /** Emitted after a row was reordered (drag or keyboard). */
+    readonly moved: _angular_core.OutputEmitterRef<{
+        from: number;
+        to: number;
+    }>;
+    /** The projected `[mkRepeaterRow]` row template (required). */
+    protected readonly rowTemplate: _angular_core.Signal<MkRepeaterRow<T>>;
+    /** The optional `[mkRepeaterEmpty]` empty-state template. */
+    protected readonly emptyTemplate: _angular_core.Signal<MkRepeaterEmpty | undefined>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    /** Effective disabled state (input- or form-driven). */
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Whether the row cap has been reached (add disables). */
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    /** Whether the row floor has been reached (remove disables). */
+    protected readonly atMin: _angular_core.Signal<boolean>;
+    /** The add button's caption (input, falling back to i18n). */
+    protected readonly effectiveAddLabel: _angular_core.Signal<string>;
+    /** Append a new `factory()` item (no-op when disabled or at `max`). */
+    protected add(): void;
+    /** Remove the row at `index` (no-op when disabled or at `min`). */
+    protected removeAt(index: number): void;
+    /** Apply a dnd drop (pointer or keyboard) to a **copy** of the array. */
+    protected onDrop(event: MkDropEvent<T>): void;
+    /**
+     * Keep keys typed into the projected row content (and pressed on the remove
+     * button) from bubbling to the row's `[mkDrag]` host, where Space/Enter
+     * would pick the row up for keyboard dragging. Reordering by keyboard stays
+     * available from the drag handle and the row element itself.
+     */
+    protected onContentKeydown(event: Event): void;
+    private setItems;
+    writeValue(value: T[] | null): void;
+    registerOnChange(fn: (value: T[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRepeater<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkRepeater<any>, "mk-repeater", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "factory": { "alias": "factory"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "addLabel": { "alias": "addLabel"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "added": "added"; "removed": "removed"; "moved": "moved"; }, ["rowTemplate", "emptyTemplate"], never, true, never>;
+}
+
+/**
+ * TreeSelect — a form field whose popover contains a hierarchical
+ * {@link MkTree}. The trigger shows the selected node's label (or a
+ * placeholder); opening it reveals a selectable tree rendered in the top layer
+ * via {@link MkAnchoredPanel}, so it is never clipped. Choosing a node sets the
+ * value to that node's `value` (or the node itself when `value` is unset),
+ * closes the panel and restores focus to the trigger. Implements
+ * `ControlValueAccessor` and a two-way `value` model.
+ *
+ * ```html
+ * <mk-tree-select [nodes]="tree" [(value)]="picked" clearable />
+ * ```
+ */
+declare class MkTreeSelect implements ControlValueAccessor {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly host;
+    private readonly injector;
+    private readonly triggerRef;
+    private readonly panelRef;
+    /** The hierarchical data to render in the panel. */
+    readonly nodes: _angular_core.InputSignal<readonly MkTreeNode[]>;
+    /** Two-way selected value (a node's `value`, or the node itself if unset). */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    /** Placeholder shown when nothing is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a clear button when a value is selected. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly triggerId: string;
+    readonly panelId: string;
+    /** Id of the rendered value/placeholder span, appended to `aria-labelledby`. */
+    readonly valueId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Label of the selected node (found by walking `nodes` recursively). */
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    protected toggle(): void;
+    protected openPanel(): void;
+    protected close(restoreFocus?: boolean): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    /**
+     * Focus left the teleported panel. The host `(focusout)` never sees this —
+     * the panel lives under `document.body` — so Tab-out of the tree is handled
+     * here: close unless focus moved back into the field or the panel.
+     */
+    protected onPanelFocusout(event: FocusEvent): void;
+    /** Handle a selection emitted by the tree (a value) or a node passed directly. */
+    protected onPick(selected: unknown): void;
+    protected clear(event: Event): void;
+    protected onFocusOut(event: FocusEvent): void;
+    /** Resolve the bound value for a node (or pass a primitive value through). */
+    private valueOf;
+    private findNode;
+    private focusTree;
+    writeValue(value: unknown | null): void;
+    registerOnChange(fn: (value: unknown | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTreeSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTreeSelect, "mk-tree-select", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Upload lifecycle state for a single file. */
+type MkUploadStatus = 'pending' | 'uploading' | 'success' | 'error';
+/** A file tracked by {@link MkFileUpload}. */
+interface MkUploadFile {
+    /** Stable id for tracking + removal. */
+    id: string;
+    /** The underlying browser `File`. */
+    file: File;
+    /** File name. */
+    name: string;
+    /** Size in bytes. */
+    size: number;
+    /** Upload lifecycle state. */
+    status: MkUploadStatus;
+    /** Upload progress, 0–100. */
+    progress: number;
+    /** Failure reason (validation or upload error). */
+    error?: string;
+    /** Object URL for an image preview, when the file is an image. */
+    previewUrl?: string;
+}
+/** Why a dropped/selected file was rejected. */
+interface MkUploadRejection {
+    file: File;
+    reason: 'type' | 'size' | 'maxFiles';
+    message: string;
+}
+/**
+ * Uploads the given file, reporting progress via `onProgress` (0–100) and
+ * resolving on success / rejecting (optionally with an `Error`) on failure.
+ */
+type MkUploadFn = (file: File, onProgress: (percent: number) => void) => Promise<void>;
+/**
+ * What {@link MkFileUpload} publishes as its form value: the raw browser
+ * `File`s (the default, and what you would send in a `FormData`), or the full
+ * tracked items including upload status and progress.
+ */
+type MkUploadValueFormat = 'file' | 'item';
+/**
+ * FileUpload — an accessible click-or-drag dropzone with multi-file support,
+ * type/size/count validation, image thumbnails and per-file progress.
+ *
+ * Provide an `uploadFn` to stream each accepted file to your backend (it
+ * reports progress and resolves/rejects); with `autoUpload` (on by default when
+ * an `uploadFn` is set) files upload as soon as they are accepted. Without one,
+ * the component just validates + tracks files and emits `filesSelected` for you
+ * to handle. The tracked list is a two-way `files` model so you can reset it.
+ *
+ * Keyboard: the dropzone is a button — Enter/Space opens the native picker.
+ * Rejections are announced through a polite live region.
+ *
+ * Implements `ControlValueAccessor` and `Validator`, so it drops into a
+ * reactive form like any other control. The form value is `File[]` by default
+ * (`[valueFormat]="'item'"` publishes the tracked `MkUploadFile[]` instead),
+ * and `accept` / `maxSize` / `maxFiles` are enforced as validation errors as
+ * well as at pick time — a list written in from the model side is checked too.
+ *
+ * ```html
+ * <mk-file-upload accept="image/*" multiple [maxSize]="5_000_000"
+ *   [uploadFn]="upload" (filesSelected)="onFiles($event)" [(files)]="files" />
+ *
+ * <mk-file-upload formControlName="attachments" accept=".pdf" [maxFiles]="3" />
+ * ```
+ */
+declare class MkFileUpload implements ControlValueAccessor, Validator {
+    private readonly host;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly inputRef;
+    /** Native `accept` filter, e.g. `image/*` or `.pdf,.doc`. */
+    readonly accept: _angular_core.InputSignal<string>;
+    /** Allow selecting more than one file. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Maximum size per file in bytes (0 = unlimited). */
+    readonly maxSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Maximum number of files kept (0 = unlimited). */
+    readonly maxFiles: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Primary dropzone prompt. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Secondary hint under the prompt (e.g. accepted types / size). */
+    readonly hint: _angular_core.InputSignal<string>;
+    /** Hide the built-in file list (render your own from `files`). */
+    readonly hideList: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Async upload handler. When set, files upload automatically. */
+    readonly uploadFn: _angular_core.InputSignal<MkUploadFn | null>;
+    /** Upload accepted files immediately. Defaults to true when `uploadFn` set. */
+    readonly autoUpload: _angular_core.InputSignal<boolean | undefined>;
+    /** Shape of the value published to a bound form control. */
+    readonly valueFormat: _angular_core.InputSignal<MkUploadValueFormat>;
+    /** The tracked files (two-way, so consumers can reset the list). */
+    readonly files: _angular_core.ModelSignal<MkUploadFile[]>;
+    /** Emits the accepted `File`s each time files are added. */
+    readonly filesSelected: _angular_core.OutputEmitterRef<File[]>;
+    /** Emits rejected files with a reason. */
+    readonly rejected: _angular_core.OutputEmitterRef<MkUploadRejection[]>;
+    /** Emits a file once its upload succeeds. */
+    readonly uploaded: _angular_core.OutputEmitterRef<MkUploadFile>;
+    /** Emits a file when it is removed from the list. */
+    readonly removed: _angular_core.OutputEmitterRef<MkUploadFile>;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    /** Latest rejection messages, surfaced in a polite live region. */
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    readonly inputId: string;
+    /** Set by reactive forms through `setDisabledState`. */
+    private readonly cvaDisabled;
+    /** Disabled either by the `disabled` input or by the bound form control. */
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    /** Guards `writeValue` from echoing back through `onChange`. */
+    private writing;
+    protected readonly shouldAutoUpload: _angular_core.Signal<boolean>;
+    protected openPicker(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onInputChange(event: Event): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    /** Validate + track a batch of files, uploading them when configured. */
+    private addFiles;
+    /** Remove a tracked file. */
+    protected remove(item: MkUploadFile): void;
+    /** Retry a failed upload. */
+    protected retry(item: MkUploadFile): void;
+    private upload;
+    /** Immutably update one tracked file by id. */
+    private patch;
+    private toItem;
+    private revoke;
+    private matchesAccept;
+    protected formatBytes(bytes: number): string;
+    /**
+     * Revoke preview object-URLs for items that leave the two-way `files` model
+     * externally (e.g. a consumer resetting the list), not just via `remove()`.
+     */
+    private readonly trackedPreviews;
+    private readonly trackPreviews;
+    ngOnDestroy(): void;
+    /** Marks the control touched once focus leaves the dropzone and its list. */
+    protected onFocusOut(event: FocusEvent): void;
+    /** The value published to a bound form control, in the requested shape. */
+    private readonly formValue;
+    /**
+     * Last value handed to `onChange`, for change detection against `formValue`.
+     * `null` suppresses the next emission — used for the initial render and for
+     * every `writeValue`, so writing from the model side never dirties the
+     * control or loops back.
+     */
+    private lastEmitted;
+    private readonly emitOnChange;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: File[] | MkUploadFile[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Accepts either shape of written value; drops anything unrecognisable. */
+    private adopt;
+    private readonly validatorChange;
+    /**
+     * Applies the same `accept` / `maxSize` / `maxFiles` rules the dropzone
+     * enforces at pick time, so a list written in from the model side — which
+     * never goes through that path — is checked too. An empty list passes;
+     * compose with `Validators.required` to reject it.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkFileUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkFileUpload, "mk-file-upload", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "hideList": { "alias": "hideList"; "required": false; "isSignal": true; }; "uploadFn": { "alias": "uploadFn"; "required": false; "isSignal": true; }; "autoUpload": { "alias": "autoUpload"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; }, { "files": "filesChange"; "filesSelected": "filesSelected"; "rejected": "rejected"; "uploaded": "uploaded"; "removed": "removed"; }, never, never, true, never>;
+}
+
+/** The validity of the editor's current content. */
+interface MkCodeValidity {
+    valid: boolean;
+    /** Parser error message, or `null` when valid / not validated. */
+    error: string | null;
+}
+/**
+ * CodeEditor — a lightweight, dependency-free code field with syntax
+ * highlighting, JSON validation and pretty-printing. A `<textarea>` provides
+ * editing and a synced highlight layer sits behind it, so it stays fully
+ * accessible (real textarea semantics, `aria-invalid`, form-field wiring)
+ * without pulling in a heavyweight editor.
+ *
+ * With `language="json"` it validates on every change (exposing an inline error
+ * + `(validate)` output) and offers `format()` to pretty-print. Ideal for a CMS
+ * `json` field or plugin/settings JSONB editing.
+ *
+ * Keyboard: Tab inserts `tabSize` spaces; press Escape then Tab to move focus
+ * out (so it is never a keyboard trap). Implements `ControlValueAccessor` over a
+ * string value with a two-way `value` model.
+ *
+ * ```html
+ * <mk-code-editor #editor language="json" [(value)]="config" [rows]="10" />
+ * <button mkButton (click)="editor.format()">Format</button>
+ * ```
+ */
+declare class MkCodeEditor implements ControlValueAccessor, OnDestroy {
+    private readonly field;
+    private readonly textareaRef;
+    private readonly highlightRef;
+    private readonly gutterRef;
+    /** Language for highlighting + validation. */
+    readonly language: _angular_core.InputSignal<MkCodeLanguage>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Render read-only (still focusable/selectable). */
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Visible rows (minimum height). */
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Show a line-number gutter. */
+    readonly lineNumbers: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Number of spaces inserted by Tab. */
+    readonly tabSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Soft-wrap long lines instead of scrolling horizontally. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Accessible label when used standalone (no form field). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Two-way editor content. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Emits the content validity whenever it changes (JSON only). */
+    readonly validate: _angular_core.OutputEmitterRef<MkCodeValidity>;
+    private readonly cvaDisabled;
+    /**
+     * Debounced mirror of `value` that the expensive derivations (highlight,
+     * JSON validation) read. Typing schedules a trailing update; programmatic
+     * writes (`writeValue`, `format()`, `[(value)]` at rest) flush synchronously
+     * so the overlay never lags when the user is not typing.
+     */
+    private readonly debouncedValue;
+    private debounceTimer;
+    /** Set true by Escape so the next Tab moves focus instead of indenting. */
+    private escapeArmed;
+    private onChange;
+    private onTouched;
+    readonly editorId: string;
+    readonly errorId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Parse error for JSON content, or `null` when valid / empty / plaintext. */
+    protected readonly jsonError: _angular_core.Signal<string | null>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    /** `aria-describedby` merging the field's ids with the JSON error id. */
+    protected readonly ariaDescribedBy: _angular_core.Signal<string | null>;
+    /**
+     * Highlighted HTML for the layer behind the textarea. Reads the debounced
+     * value: while typing the (transparent-text) textarea sits above the overlay,
+     * so a briefly stale highlight is invisible; at rest both are identical.
+     */
+    protected readonly highlightedHtml: _angular_core.Signal<string>;
+    /** Cache so `lines()` returns the same array while the count is unchanged. */
+    private cachedLines;
+    /**
+     * Line numbers to render in the gutter. Counts newlines in the LIVE value
+     * (cheap single scan, no `split()` allocation) so the gutter never lags the
+     * textarea, and returns a cached array while the count is unchanged so the
+     * `@for` never re-diffs on same-line edits.
+     */
+    protected readonly lines: _angular_core.Signal<number[]>;
+    constructor();
+    ngOnDestroy(): void;
+    /** Trailing-edge debounce for the expensive derivations while typing. */
+    private scheduleDerivations;
+    /** Cancels any pending debounce and syncs the derivations immediately. */
+    private flushDerivations;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    /** Keep the highlight layer + gutter aligned with the textarea scroll. */
+    protected onScroll(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Insert text at the caret, preserving undo history where supported. */
+    private insertText;
+    /** The parsed JSON value, or `undefined` when empty / invalid / plaintext. */
+    parsed(): unknown;
+    /** Pretty-print valid JSON with `tabSize` indentation. No-op otherwise. */
+    format(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCodeEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCodeEditor, "mk-code-editor", ["mkCodeEditor"], { "language": { "alias": "language"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "tabSize": { "alias": "tabSize"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "validate": "validate"; }, never, never, true, never>;
+}
+
+/**
+ * Rating — a star rating input (and read-only display). Implements the ARIA
+ * slider pattern: one focusable control, Arrow keys adjust, Home/End jump.
+ * Click or hover a star to set the value. `ControlValueAccessor` + two-way
+ * `value` model over a number.
+ *
+ * ```html
+ * <mk-rating [(value)]="score" [max]="5" />
+ * <mk-rating [value]="4" readonly />
+ * ```
+ */
+declare class MkRating implements ControlValueAccessor, Validator {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Number of stars. */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Two-way rating value (0–max). */
+    readonly value: _angular_core.ModelSignal<number>;
+    /** Read-only display (no interaction). */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the invalid visual + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Size scale. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Accessible label. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly hover: _angular_core.WritableSignal<number>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    /** The surrounding field's label labels this control (`aria-labelledby`). */
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    /** Hint/error ids from the surrounding field (`aria-describedby`). */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /**
+     * The `aria-label` actually rendered. When an `mk-form-field` provides a
+     * label, `aria-labelledby` wins and the default label is dropped so it
+     * cannot override the field's visible label.
+     */
+    protected readonly effectiveAriaLabel: _angular_core.Signal<string | null>;
+    /** The stars to render (1-based indices). */
+    protected readonly stars: _angular_core.Signal<number[]>;
+    /** The value shown right now (hover preview wins). */
+    protected readonly displayValue: _angular_core.Signal<number>;
+    protected readonly valueText: _angular_core.Signal<string>;
+    protected setValue(v: number): void;
+    protected onStarEnter(v: number): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onBlur(): void;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `max` for a rating above `[max]`. Zero means "unrated" and is
+     * left to `Validators.required` to reject.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkRating, "mk-rating", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "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; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * NumberInput — a numeric field with −/+ stepper buttons, clamping and keyboard
+ * stepping (Arrow keys / Page keys). Implements the ARIA `spinbutton` pattern
+ * and `ControlValueAccessor` over `number | null`, with a two-way `value` model.
+ *
+ * ```html
+ * <mk-number-input [(value)]="qty" [min]="0" [max]="99" [step]="1" />
+ * ```
+ */
+declare class MkNumberInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly inputRef;
+    /** Minimum value. */
+    readonly min: _angular_core.InputSignal<number | null>;
+    /** Maximum value. */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Step increment for buttons + Arrow keys. */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Two-way value. */
+    readonly value: _angular_core.ModelSignal<number | null>;
+    /** Placeholder when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling when standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored inside an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    protected readonly inputId: string;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Text mirror of the value for the input. */
+    protected readonly display: _angular_core.Signal<string>;
+    protected readonly canDecrement: _angular_core.Signal<boolean>;
+    protected readonly canIncrement: _angular_core.Signal<boolean>;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    protected step_(delta: number): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private clamp;
+    private commit;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `min` / `max` against the `[min]` and `[max]` inputs, using the
+     * same error shapes as `Validators.min` / `Validators.max`.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkNumberInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkNumberInput, "mk-number-input", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "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"; }, never, never, true, never>;
+}
+
+type MkNumericKeypadMode = 'pin' | 'quantity' | 'amount';
+/** A key on the pad: a digit, or one of the three action keys. */
+type PadKey = {
+    id: string;
+    label: string;
+    action: 'digit' | 'clear' | 'decimal' | 'backspace';
+};
+/**
+ * Numeric keypad — a touch-first 3×4 digit pad for PIN entry, quantity entry
+ * and money amounts (POS-style). `ControlValueAccessor` + two-way `value`
+ * model; the value is a **string** in `pin` mode (leading zeros preserved)
+ * and a **number | null** in `quantity`/`amount` mode.
+ *
+ * - `pin`: masked echo row by default; `(submit)` fires automatically when
+ *   `length` digits are entered.
+ * - `quantity`: integer entry; the bottom-left key clears.
+ * - `amount`: decimal entry (value uses `.`; the echo shows
+ *   `decimalSeparator`); capped at `fractionDigits` fraction digits.
+ *
+ * A physical keyboard works anywhere inside the pad: digits, Backspace,
+ * Delete (clear), Enter (submit) and the decimal separator. Arrow keys move
+ * between the on-screen keys (roving tabindex).
+ *
+ * ```html
+ * <mk-numeric-keypad mode="pin" [length]="4" (submit)="unlock($event)" />
+ * <mk-numeric-keypad mode="quantity" [min]="1" [(value)]="qty" />
+ * ```
+ */
+declare class MkNumericKeypad implements ControlValueAccessor, Validator {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly announcer;
+    private readonly keyEls;
+    /** Entry mode. Decides the value type and the bottom-left key. */
+    readonly mode: _angular_core.InputSignal<MkNumericKeypadMode>;
+    /** PIN length (`pin` mode only). Reaching it emits `submit`. */
+    readonly length: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Lower bound reported through the validator (`quantity`/`amount`). */
+    readonly min: _angular_core.InputSignal<number | null>;
+    /** Upper bound reported through the validator (`quantity`/`amount`). */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Mask the echo row in `pin` mode. Default `true`. */
+    readonly mask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show the echo row above the keys. Default `true`. */
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Echo-row separator for `amount` mode. The VALUE always uses `.`. */
+    readonly decimalSeparator: _angular_core.InputSignal<string>;
+    /** Max fraction digits accepted in `amount` mode. */
+    readonly fractionDigits: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Disable the pad. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible label for the pad. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Two-way value: `string` in `pin` mode, `number | null` otherwise. */
+    readonly value: _angular_core.ModelSignal<string | number | null>;
+    /** Enter key / full PIN. Emits the current value. */
+    readonly submit: _angular_core.OutputEmitterRef<string | number | null>;
+    readonly padId: string;
+    /** Raw entry buffer ('' = empty; amount keeps a '.' while typing). */
+    private readonly buffer;
+    private readonly cvaDisabled;
+    /** Roving-tabindex position inside the flattened key list. */
+    protected readonly focusIndex: _angular_core.WritableSignal<number>;
+    private onChange;
+    private onTouched;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly keys: _angular_core.Signal<PadKey[]>;
+    /** Echo text: masked dots are rendered separately in `pin` mode. */
+    protected readonly echoText: _angular_core.Signal<string>;
+    protected readonly isPinMasked: _angular_core.Signal<boolean>;
+    protected readonly pinDots: _angular_core.Signal<boolean[]>;
+    protected keyAriaLabel(key: PadKey): string | null;
+    protected onKeyClick(key: PadKey): void;
+    /** Physical-keyboard entry + arrow-key roving over the on-screen keys. */
+    protected onGridKeydown(event: KeyboardEvent): void;
+    protected onKeyFocus(index: number): void;
+    protected onBlur(): void;
+    private focusKey;
+    private pushDigit;
+    private pushDecimal;
+    private commit;
+    writeValue(value: string | number | null): void;
+    registerOnChange(fn: (value: string | number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * `pin`: reports `minlength` while the code is incomplete (empty passes —
+     * compose with `Validators.required`). `quantity`/`amount`: reports
+     * `min`/`max` against the bounds.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkNumericKeypad, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkNumericKeypad, "mk-numeric-keypad", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; "isSignal": true; }; "fractionDigits": { "alias": "fractionDigits"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "submit": "submit"; }, never, never, true, never>;
+}
+
+/**
+ * Layout data for {@link MkOnScreenKeyboard}.
+ *
+ * A layout is a set of rows per layer. String entries are literal character
+ * keys (lowercase base form); object entries are action keys. Shifted
+ * characters come from `shiftMap` when present, else `toUpperCase()` — which
+ * handles Polish diacritics for free (`ą` → `Ą`).
+ */
+/** Non-character keys. `span` stretches the key across extra grid columns. */
+interface MkKeyboardActionKey {
+    readonly action: 'shift' | 'backspace' | 'space' | 'enter' | 'layer';
+    readonly span?: number;
+}
+type MkKeyboardKey = string | MkKeyboardActionKey;
+interface MkKeyboardLayout {
+    /** Letter layer. */
+    readonly base: ReadonlyArray<ReadonlyArray<MkKeyboardKey>>;
+    /** Alternate layer (digits live in the base top row; this holds diacritics + symbols). */
+    readonly alt: ReadonlyArray<ReadonlyArray<MkKeyboardKey>>;
+    /** Overrides for shifted characters; missing keys fall back to `toUpperCase()`. */
+    readonly shiftMap?: Readonly<Record<string, string>>;
+}
+/**
+ * QWERTY with a Polish alternate layer (programmer-Polish convention: base
+ * letters are plain QWERTY, diacritics sit on the `?ąę` layer along with the
+ * common symbols).
+ */
+declare const MK_KEYBOARD_LAYOUT_QWERTY_PL: MkKeyboardLayout;
+
+/** A resolved key ready for the template. */
+interface RenderKey {
+    readonly char?: string;
+    readonly action?: MkKeyboardActionKey['action'];
+    readonly span: number;
+}
+type MkOnScreenKeyboardTarget = HTMLInputElement | HTMLTextAreaElement;
+/**
+ * On-screen keyboard — a touch QWERTY panel for kiosk/till screens where no
+ * physical keyboard exists. Anchored below its input in the browser top layer
+ * (via {@link MkAnchoredPanel}), it writes caret-aware into the target's
+ * native value and dispatches `input` events, so `ngModel`/reactive forms
+ * stay in sync with no extra wiring.
+ *
+ * Pair it with the `mkOnScreenKeyboardFor` directive, which opens the panel
+ * on focus and suppresses the OS keyboard (`inputmode="none"`):
+ *
+ * ```html
+ * <input mkInput [mkOnScreenKeyboardFor]="kbd" />
+ * <mk-on-screen-keyboard #kbd />
+ * ```
+ *
+ * Layers: base (letters + digit row), shift (auto-resets after one
+ * character) and an alternate layer (Polish diacritics + symbols in the
+ * default {@link MK_KEYBOARD_LAYOUT_QWERTY_PL}); pass `layout` for other
+ * languages. Enter inserts a newline in a `<textarea>` and emits `enter`
+ * for single-line inputs. Keys are excluded from the tab order — physical
+ * keyboards type into the input directly, the panel is a pointer surface.
+ */
+declare class MkOnScreenKeyboard {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly isBrowser;
+    /** Stable id for `aria-controls` on the trigger. */
+    readonly panelId: string;
+    /** Key layout. Defaults to QWERTY with a Polish alternate layer. */
+    readonly layout: _angular_core.InputSignal<MkKeyboardLayout>;
+    /** Preferred placement relative to the input. */
+    readonly placement: _angular_core.InputSignal<MkPlacement>;
+    /** Enter pressed on a single-line input (textareas insert a newline instead). */
+    readonly enter: _angular_core.OutputEmitterRef<void>;
+    /** Emitted whenever the keyboard closes (any reason). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly _open;
+    /** Whether the panel is open. */
+    readonly opened: _angular_core.Signal<boolean>;
+    protected readonly anchorEl: _angular_core.WritableSignal<HTMLElement | undefined>;
+    protected readonly shift: _angular_core.WritableSignal<boolean>;
+    protected readonly layer: _angular_core.WritableSignal<"base" | "alt">;
+    private target;
+    protected readonly rows: _angular_core.Signal<RenderKey[][]>;
+    private resolve;
+    /** Open anchored to `anchor`, typing into `target`. */
+    open(anchor: HTMLElement, target: MkOnScreenKeyboardTarget): void;
+    /** Close the panel. */
+    close(): void;
+    /** Keys must never steal focus from the input. */
+    protected onPanelPointerdown(event: Event): void;
+    protected onKeyClick(key: RenderKey): void;
+    protected keyLabel(key: RenderKey): string;
+    /** The visible face of the layer key: `?ąę` on base, `abc` on alt. */
+    protected layerFace(): string;
+    private insert;
+    private deleteBack;
+    private notify;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkOnScreenKeyboard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkOnScreenKeyboard, "mk-on-screen-keyboard", ["mkOnScreenKeyboard"], { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, { "enter": "enter"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Binds an `<input>`/`<textarea>` to an {@link MkOnScreenKeyboard}: opens the
+ * panel on focus/click, closes it when focus leaves, and sets
+ * `inputmode="none"` so touch devices don't raise the OS keyboard on top of
+ * it. Disabled/readonly fields never open the panel.
+ *
+ * ```html
+ * <input mkInput [mkOnScreenKeyboardFor]="kbd" />
+ * <mk-on-screen-keyboard #kbd />
+ * ```
+ */
+declare class MkOnScreenKeyboardTrigger {
+    private readonly host;
+    /** The keyboard instance to open for this field. */
+    readonly keyboard: _angular_core.InputSignal<MkOnScreenKeyboard>;
+    protected open(): void;
+    /**
+     * Panel keys `preventDefault()` their pointerdown, so the input only blurs
+     * when focus genuinely moves elsewhere — close then.
+     */
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkOnScreenKeyboardTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MkOnScreenKeyboardTrigger, "input[mkOnScreenKeyboardFor], textarea[mkOnScreenKeyboardFor]", ["mkOnScreenKeyboardTrigger"], { "keyboard": { "alias": "mkOnScreenKeyboardFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * OTP — a segmented one-time-code input: N single-character boxes with automatic
+ * focus advance, Backspace-to-previous, Arrow navigation and full-code paste.
+ * `ControlValueAccessor` + two-way `value` model over the concatenated string.
+ *
+ * ```html
+ * <mk-otp [(value)]="code" [length]="6" />
+ * ```
+ */
+declare class MkOtp implements ControlValueAccessor, Validator {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly cells;
+    /** Number of character boxes. */
+    readonly length: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Restrict input to digits (`number`) or allow any char (`text`). */
+    readonly type: _angular_core.InputSignal<"number" | "text">;
+    /** Mask entered characters (password style). */
+    readonly mask: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Two-way concatenated value. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling when standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored inside an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Accessible label for the group. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly cellId: string;
+    private readonly chars;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    protected readonly indexes: _angular_core.Signal<number[]>;
+    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>;
+    /** Required state from the surrounding field (`aria-required` on the cells). */
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    /** Hint/error ids from the surrounding field (`aria-describedby` on the cells). */
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly inputMode: _angular_core.Signal<"text" | "numeric">;
+    /**
+     * Cell ids. The first cell adopts the surrounding field's `controlId` so the
+     * field's `<label for>` resolves to a real element.
+     */
+    protected cellIdFor(i: number): string;
+    constructor();
+    protected charAt(i: number): string;
+    protected onCellInput(i: number, event: Event): void;
+    protected onCellKeydown(i: number, event: KeyboardEvent): void;
+    protected onPaste(i: number, event: ClipboardEvent): void;
+    protected onBlur(): void;
+    private fillFrom;
+    private commit;
+    private focusCell;
+    private sanitize;
+    private split;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `minlength` for a partially entered code. An empty value passes;
+     * compose with `Validators.required` to reject it.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkOtp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkOtp, "mk-otp", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "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; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Per-country dialing metadata for {@link MkPhoneInput}.
+ *
+ * `mask` is an `mkApplyMask`-style pattern for the **national** number
+ * (`0` = digit, everything else is a literal). Masks follow the most common
+ * national formatting; countries with several plan lengths use their longest
+ * common mobile format. The set covers the countries an admin product is
+ * likely to meet — extend or replace it via the `countries` input.
+ */
+interface MkPhoneCountry {
+    /** ISO 3166-1 alpha-2 code, uppercase (drives the flag + display name). */
+    code: string;
+    /** International dialing code, digits only (no `+`). */
+    dialCode: string;
+    /** Mask for the national number, `0` = digit. */
+    mask: string;
+}
+/** The built-in country set (alphabetical by ISO code). */
+declare const MK_PHONE_COUNTRIES: readonly MkPhoneCountry[];
+/** Regional-indicator flag emoji for an ISO 3166-1 alpha-2 code. */
+declare function mkCountryFlag(code: string): string;
+
+/** Structured value emitted by {@link MkPhoneInput} in `parts` mode. */
+interface MkPhoneValue {
+    /** ISO 3166-1 alpha-2 country code, e.g. `PL`. */
+    country: string;
+    /** Dialing prefix with the leading `+`, e.g. `+48`. */
+    dialCode: string;
+    /** National number, digits only. */
+    national: string;
+    /** The full E.164 number, e.g. `+48601234567`. */
+    e164: string;
+}
+/** A country row prepared for the dropdown list. */
+interface CountryOption {
+    country: MkPhoneCountry;
+    name: string;
+    flag: string;
+}
+/**
+ * PhoneInput — an international telephone field: a searchable country-prefix
+ * dropdown (flag + dial code) next to a national-number input that formats
+ * itself with the selected country's mask as the user types.
+ *
+ * The form value is either a single E.164 string (`"+48601234567"`, default)
+ * or a structured object (`valueFormat="parts"`) carrying the country, dial
+ * code and national number separately; both modes read back either shape and
+ * `null` when empty. Pasting a full international number (`+44…`) into the
+ * number field switches the country automatically.
+ *
+ * Implements `ControlValueAccessor` and exposes two-way `value` and `country`
+ * models, so `[(ngModel)]`, reactive forms, `[(value)]` and `[(country)]` all
+ * work.
+ *
+ * ```html
+ * <mk-phone-input [(ngModel)]="phone" country="PL" />
+ * <mk-phone-input valueFormat="parts" [preferredCountries]="['PL','DE','CZ']"
+ *   [(value)]="phoneParts" />
+ * ```
+ */
+declare class MkPhoneInput implements ControlValueAccessor {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly triggerRef;
+    private readonly searchRef;
+    private readonly nationalRef;
+    /** The selectable country set (defaults to the built-in list). */
+    readonly countries: _angular_core.InputSignal<readonly MkPhoneCountry[]>;
+    /** ISO codes pinned, in order, to the top of the dropdown. */
+    readonly preferredCountries: _angular_core.InputSignal<readonly string[]>;
+    /** Shape of the form value: an E.164 string or a structured object. */
+    readonly valueFormat: _angular_core.InputSignal<"e164" | "parts">;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder for the national-number field. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Two-way selected ISO country code. */
+    readonly country: _angular_core.ModelSignal<string>;
+    /** Two-way form value (`string` in `e164` mode, {@link MkPhoneValue} in `parts`). */
+    readonly value: _angular_core.ModelSignal<string | MkPhoneValue | null>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    private readonly nationalDigits;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    /** The last value this component itself wrote into the `value` model. */
+    private lastDerived;
+    private lastCountry;
+    readonly listId: string;
+    readonly inputId: string;
+    readonly searchId: string;
+    private readonly displayNames;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** The currently selected country (falls back to the first in the set). */
+    protected readonly selectedCountry: _angular_core.Signal<MkPhoneCountry>;
+    protected readonly selectedFlag: _angular_core.Signal<string>;
+    protected readonly selectedName: _angular_core.Signal<string>;
+    /** Masked national number shown in the field. */
+    protected readonly nationalMasked: _angular_core.Signal<string>;
+    /** Countries sorted preferred-first, then A→Z by localised name. */
+    private readonly sortedCountries;
+    /** Dropdown rows matching the search query. */
+    protected readonly filtered: _angular_core.Signal<CountryOption[]>;
+    constructor();
+    /** Localised display name for an ISO country code. */
+    protected countryName(code: string): string;
+    protected optionId(index: number): string;
+    protected onNationalChange(unmasked: string): void;
+    /** Pasting a full `+…` number switches country + fills the national part. */
+    protected onNationalPaste(event: ClipboardEvent): void;
+    protected onBlur(): void;
+    /** Pending focus-the-search-box timeout; cleared on re-open and destroy. */
+    private searchFocusTimer?;
+    protected toggle(): void;
+    private openList;
+    protected close(refocusTrigger?: boolean): void;
+    protected onTriggerKeydown(event: Event): void;
+    protected onSearch(event: Event): void;
+    protected onSearchKeydown(event: Event): void;
+    protected selectCountry(index: number): void;
+    /** Compute the outward value and push it to the model (+ form when `emit`). */
+    private deriveValue;
+    private sameValue;
+    /** Interpret an externally-assigned value (writeValue or `[value]`). */
+    private applyExternalValue;
+    /** Split an E.164-ish string into a country + national digits. */
+    private applyE164;
+    writeValue(value: string | MkPhoneValue | null): void;
+    registerOnChange(fn: (value: string | MkPhoneValue | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPhoneInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkPhoneInput, "mk-phone-input", ["mkPhoneInput"], { "countries": { "alias": "countries"; "required": false; "isSignal": true; }; "preferredCountries": { "alias": "preferredCountries"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "country": { "alias": "country"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "country": "countryChange"; "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Per-country postal-code formats for {@link MkPostalCodeInput}.
+ *
+ * `mask` is an `mkApplyMask`-style pattern (`0` = digit, `A` = letter,
+ * `*` = alphanumeric, everything else a literal). `pattern` validates the
+ * complete formatted value. Countries whose codes vary too much for a fixed
+ * mask (e.g. GB) omit `mask` and rely on `pattern` + uppercasing alone.
+ */
+interface MkPostalFormat {
+    /** ISO 3166-1 alpha-2 code, uppercase. */
+    code: string;
+    /** Input mask; omitted for free-form (variable-length) codes. */
+    mask?: string;
+    /** Regex the complete formatted value must match to be valid. */
+    pattern: RegExp;
+    /** Example of a valid code, used as the default placeholder. */
+    example: string;
+}
+/** The built-in postal formats (alphabetical by ISO code). */
+declare const MK_POSTAL_FORMATS: readonly MkPostalFormat[];
+/** Look up the built-in format for an ISO country code (case-insensitive). */
+declare function mkPostalFormat(code: string): MkPostalFormat | undefined;
+
+/**
+ * Reactive-forms validator for a postal code in a given country. Empty values
+ * pass (compose with `Validators.required`); countries without a built-in
+ * format pass everything.
+ *
+ * ```ts
+ * zip: ['', [Validators.required, mkPostalCodeValidator('PL')]]
+ * ```
+ */
+declare function mkPostalCodeValidator(country: string, formats?: readonly MkPostalFormat[]): ValidatorFn;
+/**
+ * PostalCodeInput — a postal/ZIP code field that masks, uppercases and
+ * validates itself for the given `country` (35+ built-in formats: `PL`
+ * `00-000`, `US` `00000[-0000]`, `CA` `A0A 0A0`, `NL` `0000 AA`, …).
+ * Free-format countries (e.g. `GB`) skip the mask and validate against the
+ * national pattern instead, normalising the inward-code space on blur.
+ *
+ * The placeholder defaults to a valid example for the country. `valid()`
+ * (via `exportAs`) reports `true`/`false` for a complete/incomplete code and
+ * `null` when empty or the country is unknown; invalid styling engages after
+ * the field is touched.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so
+ * `[(ngModel)]`, reactive forms and `[(value)]` all work.
+ *
+ * ```html
+ * <mk-postal-code-input country="PL" [(ngModel)]="zip" />
+ * <mk-postal-code-input [country]="form.value.country" [(value)]="zip" />
+ * ```
+ */
+declare class MkPostalCodeInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** ISO 3166-1 alpha-2 country whose format applies. */
+    readonly country: _angular_core.InputSignal<string>;
+    /** The format table (defaults to the built-in set) — extend to add countries. */
+    readonly formats: _angular_core.InputSignal<readonly MkPostalFormat[]>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder; defaults to a valid example for the country. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Two-way formatted value (e.g. `00-950`, `K1A 0B1`). */
+    readonly value: _angular_core.ModelSignal<string>;
+    private readonly touched;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** The active format, or `undefined` for unknown countries (free text). */
+    protected readonly format: _angular_core.Signal<MkPostalFormat | undefined>;
+    /**
+     * `true`/`false` for a complete/incomplete code, `null` when empty or the
+     * country has no known format.
+     */
+    readonly valid: _angular_core.Signal<boolean | null>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly effectivePlaceholder: _angular_core.Signal<string>;
+    /** Numeric keyboard for digit-only masks. */
+    protected readonly inputMode: _angular_core.Signal<"text" | "numeric">;
+    protected readonly maxLength: _angular_core.Signal<number>;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    private commit;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `postalCode` for a code not matching `[country]`'s format — the
+     * same error `mkPostalCodeValidator()` produces. Empty values and countries
+     * without a built-in format pass.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkPostalCodeInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkPostalCodeInput, "mk-postal-code-input", ["mkPostalCodeInput"], { "country": { "alias": "country"; "required": false; "isSignal": true; }; "formats": { "alias": "formats"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Locale-derived formatting facts used while editing. */
+interface LocaleInfo {
+    /** Grouping separator, e.g. `,` / ` ` / `.`. */
+    group: string;
+    /** Decimal separator, e.g. `.` / `,`. */
+    decimal: string;
+    /** Currency symbol text (empty in plain-decimal mode). */
+    symbol: string;
+    /** Whether the symbol renders before the number. */
+    symbolPrefix: boolean;
+    /** The currency's default fraction digits (2 for USD, 0 for JPY, …). */
+    fractionDigits: number;
+}
+/**
+ * CurrencyInput — a money/amount field that formats itself with
+ * `Intl.NumberFormat`: thousands grouping live as the user types, the
+ * currency symbol as a fixed prefix/suffix (per locale), fraction digits
+ * padded to the currency's convention on blur (`1234,5` → `1 234,50 zł`).
+ * The form value is always a plain `number` (or `null` when empty) — the
+ * locale formatting never leaks into the data.
+ *
+ * `currency` takes an ISO 4217 code; omit it for a plain grouped decimal.
+ * `locale` defaults to the runtime locale. `decimals` overrides the
+ * currency's fraction digits; `min`/`max` clamp on blur.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so
+ * `[(ngModel)]`, reactive forms and `[(value)]` all work.
+ *
+ * ```html
+ * <mk-currency-input currency="PLN" [(ngModel)]="price" />
+ * <mk-currency-input currency="USD" [min]="0" [(value)]="budget" />
+ * ```
+ */
+declare class MkCurrencyInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** ISO 4217 currency code (`PLN`, `USD`, …). Empty = plain decimal. */
+    readonly currency: _angular_core.InputSignal<string>;
+    /** BCP 47 locale for separators/symbol; defaults to the runtime locale. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Max fraction digits; defaults to the currency's convention (else 2). */
+    readonly decimals: _angular_core.InputSignal<number | null>;
+    /** Clamp the value to at least this on blur. */
+    readonly min: _angular_core.InputSignal<number | null>;
+    /** Clamp the value to at most this on blur. */
+    readonly max: _angular_core.InputSignal<number | null>;
+    /** Allow a leading minus sign. */
+    readonly allowNegative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Two-way numeric value (`null` when empty). */
+    readonly value: _angular_core.ModelSignal<number | null>;
+    /** The text currently shown in the field. */
+    protected readonly display: _angular_core.WritableSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    /** The last value this component itself pushed into the `value` model. */
+    private lastEmitted;
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Separators, symbol and fraction convention for the current setup. */
+    protected readonly localeInfo: _angular_core.Signal<LocaleInfo>;
+    /** Effective max fraction digits. */
+    private readonly maxDecimals;
+    constructor();
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    /**
+     * Reduce whatever is in the field to a canonical `-?digits(.digits)?`
+     * string. Accepts the locale decimal separator plus `.`/`,` when they are
+     * not the grouping separator; drops everything else.
+     */
+    private parseCanonical;
+    /** Canonical string → number (`null` for empty / lone `-`). */
+    private toNumber;
+    /** Grouped editing text preserving a partially-typed fraction (`1 234,5`). */
+    private formatEditing;
+    /** Settled (blur / programmatic) text with padded fraction digits. */
+    private formatSettled;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `min` / `max` against the `[min]` and `[max]` inputs, using the
+     * same error shapes as `Validators.min` / `Validators.max`.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCurrencyInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCurrencyInput, "mk-currency-input", ["mkCurrencyInput"], { "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "allowNegative": { "alias": "allowNegative"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Card networks {@link MkCardNumberInput} recognises. */
+type MkCardBrand = 'visa' | 'mastercard' | 'amex' | 'discover' | 'diners' | 'jcb';
+/** Human-readable names for the recognised brands. */
+declare const MK_CARD_BRAND_NAMES: Record<MkCardBrand, string>;
+/** Detect the card network from the leading digits (IIN ranges). */
+declare function mkDetectCardBrand(digits: string): MkCardBrand | null;
+/** Luhn (mod 10) checksum over a digit string. */
+declare function mkLuhnCheck(digits: string): boolean;
+/**
+ * CardNumberInput — a payment-card number field that groups digits with the
+ * detected network's layout (16-digit `0000 0000 0000 0000`, Amex
+ * `0000 000000 00000`, Diners `0000 000000 0000`), shows the brand as a
+ * badge, and validates the complete number with the Luhn checksum.
+ *
+ * The form value is the raw digit string (no spaces). `brand()` exposes the
+ * detected network (also via `(brandChange)`), and `valid()` reports
+ * `true`/`false` for a complete number passing/failing Luhn and `null` while
+ * empty or incomplete; invalid styling engages after the field was touched.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so
+ * `[(ngModel)]`, reactive forms and `[(value)]` all work.
+ *
+ * ```html
+ * <mk-card-number-input [(ngModel)]="cardNumber" />
+ * ```
+ */
+declare class MkCardNumberInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Show the detected brand as a badge inside the field. */
+    readonly showBrand: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Two-way card number, digits only (no spaces). */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Emits whenever the detected brand changes. */
+    readonly brandChange: _angular_core.OutputEmitterRef<MkCardBrand | null>;
+    private readonly touched;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    private lastBrand;
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** The detected card network, `null` while unrecognised. */
+    readonly brand: _angular_core.Signal<MkCardBrand | null>;
+    /** Human-readable brand name (empty while unrecognised). */
+    protected readonly brandName: _angular_core.Signal<string>;
+    /** The grouping mask for the current brand. */
+    protected readonly mask: _angular_core.Signal<string>;
+    /** Digits the current brand's complete number has. */
+    private readonly expectedLength;
+    /** Formatted (grouped) number shown in the field. */
+    protected readonly masked: _angular_core.Signal<string>;
+    /**
+     * `true` for a complete number passing Luhn, `false` for a complete number
+     * failing it, `null` while empty or incomplete.
+     */
+    readonly valid: _angular_core.Signal<boolean | null>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected onDigitsChange(unmasked: string): void;
+    protected onBlur(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Reports `cardNumber` for a number failing the Luhn checksum (which
+     * includes a half-typed one). An empty value passes; compose with
+     * `Validators.required` to reject it.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCardNumberInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCardNumberInput, "mk-card-number-input", ["mkCardNumberInput"], { "showBrand": { "alias": "showBrand"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "brandChange": "brandChange"; }, never, never, true, never>;
+}
+
+/** IBAN length per ISO 13616 country code (SEPA + common others). */
+declare const MK_IBAN_LENGTHS: Readonly<Record<string, number>>;
+/**
+ * ISO 13616 mod-97 check over a compact (no spaces, uppercase) IBAN.
+ * Assumes the shape `CC00…` has already been length-checked by the caller.
+ */
+declare function mkIbanChecksum(compact: string): boolean;
+/** Full IBAN validity: known country, exact length, mod-97 check. */
+declare function mkIbanIsValid(compact: string): boolean;
+/**
+ * Reactive-forms validator for an IBAN (any supported country). Empty values
+ * pass (compose with `Validators.required`); the error carries the country
+ * and its expected length when known.
+ *
+ * ```ts
+ * account: ['', [Validators.required, mkIbanValidator()]]
+ * ```
+ */
+declare function mkIbanValidator(): ValidatorFn;
+/**
+ * IbanInput — an international bank account number field: uppercases and
+ * groups the number in blocks of four as the user types (`PL61 1090 1014 …`),
+ * caps input at the country's exact length (65 countries built in) and
+ * validates with the ISO 13616 mod-97 checksum.
+ *
+ * The form value is the compact electronic format (uppercase, no spaces).
+ * `valid()` (via `exportAs`) reports `true`/`false` for a complete number
+ * passing/failing validation and `null` while empty or incomplete; invalid
+ * styling engages after the field was touched.
+ * `mkIbanValidator()` covers reactive forms.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so
+ * `[(ngModel)]`, reactive forms and `[(value)]` all work.
+ *
+ * ```html
+ * <mk-iban-input [(ngModel)]="account" />
+ * ```
+ */
+declare class MkIbanInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Two-way IBAN in compact electronic format (uppercase, no spaces). */
+    readonly value: _angular_core.ModelSignal<string>;
+    private readonly touched;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** The value grouped in blocks of four for display. */
+    protected readonly grouped: _angular_core.Signal<string>;
+    /** The expected length for the typed country, when known. */
+    private readonly expectedLength;
+    /**
+     * `true` for a complete IBAN passing the mod-97 check, `false` for a
+     * complete-but-wrong one (or an unknown country once 2+ chars are typed and
+     * the field was left), `null` while empty or still incomplete.
+     */
+    readonly valid: _angular_core.Signal<boolean | null>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected onInput(event: Event): void;
+    private expectedLengthFor;
+    protected onBlur(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Reports `iban` for a number failing the mod-97 checksum — the same error
+     * `mkIbanValidator()` produces, so the two are interchangeable. An empty
+     * value passes; compose with `Validators.required` to reject it.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkIbanInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkIbanInput, "mk-iban-input", ["mkIbanInput"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Per-country business tax-identifier format for {@link MkTaxIdInput}.
+ *
+ * `mask` is an `mkApplyMask` pattern (`0` = digit; every built-in format is
+ * digits only). `compact` validates the unmasked value — the form value —
+ * and `validate` adds the national checksum where one exists and is
+ * unambiguous. Formats without a `validate` are pattern-checked only.
+ */
+interface MkTaxIdFormat {
+    /** ISO 3166-1 alpha-2 code, uppercase. */
+    country: string;
+    /** Local name of the identifier, e.g. `NIP`. */
+    label: string;
+    /** Input mask; `0` = digit. */
+    mask: string;
+    /** Regex the complete unmasked (compact) value must match. */
+    compact: RegExp;
+    /** Example of a valid identifier, used as the default placeholder. */
+    example: string;
+    /** National checksum over the compact value; omitted when there is none. */
+    validate?: (compact: string) => boolean;
+}
+/**
+ * Polish NIP checksum: the weighted sum of the first nine digits modulo 11 is
+ * the tenth (check) digit. A remainder of 10 can never be a digit, so such a
+ * number is invalid whatever its last digit.
+ */
+declare function mkNipChecksum(compact: string): boolean;
+/**
+ * The built-in tax-identifier formats (alphabetical by ISO code). Only Poland
+ * carries a checksum; the rest are length/shape checks, which is what the
+ * national registries publish without ambiguity.
+ */
+declare const MK_TAX_ID_FORMATS: readonly MkTaxIdFormat[];
+/** Look up the built-in format for an ISO country code (case-insensitive). */
+declare function mkTaxIdFormat(country: string): MkTaxIdFormat | undefined;
+/**
+ * Full validity for a country: shape plus the national checksum when the
+ * format defines one. Masked and compact input are both accepted; unknown
+ * countries have no rule to fail, so they pass.
+ */
+declare function mkTaxIdIsValid(value: string, country: string): boolean;
+/**
+ * Reactive-forms validator for a business tax identifier in a given country.
+ * Empty values pass (compose with `Validators.required`); countries without a
+ * built-in format pass everything.
+ *
+ * ```ts
+ * nip: ['', [Validators.required, mkTaxIdValidator('PL')]]
+ * ```
+ */
+declare function mkTaxIdValidator(country: string): ValidatorFn;
+/**
+ * TaxIdInput — a business tax-identifier field that masks and validates itself
+ * for the given `country` (`PL` NIP `000-000-00-00`, `DE` USt-IdNr., `CZ` DIČ,
+ * `IT` Partita IVA, `SK` IČ DPH). Poland's NIP is checksum-verified; the other
+ * built-ins are shape-verified.
+ *
+ * Like `MkIbanInput`, the form value is the **compact** identifier (digits
+ * only, e.g. `1234563218`) while the field *displays* it masked
+ * (`123-456-32-18`) — so what is stored is what an API or invoice expects, and
+ * `writeValue()` accepts either form. The placeholder defaults to a valid
+ * example for the country. `valid()` (via `exportAs`) reports `true`/`false`
+ * for a complete identifier passing/failing validation and `null` while empty,
+ * still incomplete or the country is unknown; invalid styling engages after
+ * the field was touched. `mkTaxIdValidator()` covers reactive forms.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so
+ * `[(ngModel)]`, reactive forms and `[(value)]` all work.
+ *
+ * ```html
+ * <mk-tax-id-input [(ngModel)]="nip" />
+ * <mk-tax-id-input [country]="form.value.country" [(value)]="taxId" />
+ * ```
+ */
+declare class MkTaxIdInput implements ControlValueAccessor, Validator {
+    private readonly field;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    /** ISO 3166-1 alpha-2 country whose format applies. */
+    readonly country: _angular_core.InputSignal<string>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder; defaults to a valid example for the country. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Two-way identifier in compact form (digits only, e.g. `1234563218`). */
+    readonly value: _angular_core.ModelSignal<string>;
+    private readonly touched;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly inputId: string;
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** The active format, or `undefined` for unknown countries (free digits). */
+    protected readonly format: _angular_core.Signal<MkTaxIdFormat | undefined>;
+    /** The compact value rendered through the country's mask. */
+    protected readonly masked: _angular_core.Signal<string>;
+    protected readonly effectivePlaceholder: _angular_core.Signal<string>;
+    protected readonly maxLength: _angular_core.Signal<number>;
+    /**
+     * `true` for a complete identifier passing its format (and checksum),
+     * `false` for a complete-but-wrong one, `null` while empty, still shorter
+     * than the mask allows, or the country has no known format.
+     */
+    readonly valid: _angular_core.Signal<boolean | null>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    /** Accepts both the masked (`123-456-32-18`) and compact (`1234563218`) form. */
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `taxId` for an identifier not matching `[country]`'s format or
+     * failing its checksum — the same error `mkTaxIdValidator()` produces, so
+     * the two are interchangeable. Empty values and unknown countries pass;
+     * compose with `Validators.required` to reject an empty one.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTaxIdInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTaxIdInput, "mk-tax-id-input", ["mkTaxIdInput"], { "country": { "alias": "country"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * SignaturePad — a canvas the user draws a signature on (pointer, touch or
+ * pen). Strokes are captured as smoothed polylines, rendered crisp on hi-DPI
+ * screens and re-drawn losslessly when the pad resizes. The form value is a
+ * PNG data-URL of the drawing (`null` while empty), so it drops straight into
+ * an `<img>`, a form post or an upload.
+ *
+ * A Clear control resets the pad (also available as `clear()`); `isEmpty()`
+ * reports whether anything is drawn. Programmatic values (`writeValue`,
+ * `[value]`) are painted onto the canvas as an image.
+ *
+ * Drawing is inherently pointer-based; pair the pad with an alternative flow
+ * (e.g. a typed-name checkbox) where WCAG requires a keyboard equivalent.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model, so
+ * `[(ngModel)]`, reactive forms and `[(value)]` all work.
+ *
+ * ```html
+ * <mk-signature-pad [(ngModel)]="signature" />
+ * <img [src]="signature" alt="Captured signature" />
+ * ```
+ */
+declare class MkSignaturePad implements ControlValueAccessor, OnDestroy {
+    private readonly host;
+    private readonly field;
+    private readonly isBrowser;
+    /** Localised strings (override globally via `provideMkI18n`). */
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly canvasRef;
+    /** Stroke width in CSS pixels. */
+    readonly strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Pad height in CSS pixels (width follows the container). */
+    readonly height: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Force invalid styling + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Two-way PNG data-URL of the signature (`null` while empty). */
+    readonly value: _angular_core.ModelSignal<string | null>;
+    /** Emits when the pad is cleared (via the button or `clear()`). */
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    private readonly strokes;
+    private current;
+    /**
+     * Per-gesture cache: canvas rect, devicePixelRatio and stroke color are
+     * read once at pointerdown so pointermove does no layout/style reads.
+     * Refreshed on a mid-stroke resize, dropped at pointerup/cancel.
+     */
+    private gesture;
+    /**
+     * Highest smoothing segment of `current` already painted incrementally.
+     * Segment `i` (1-based) is `quadraticCurveTo(p[i], mid(p[i], p[i+1]))` —
+     * exactly the curve `redraw()` produces, so the final full redraw matches.
+     */
+    private lastSeg;
+    /** Pending animation-frame handle for the incremental draw. */
+    private rafId;
+    private readonly empty;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    private resizeObserver?;
+    /** Set while `value` holds an external image we can't re-derive strokes from. */
+    private externalImage;
+    readonly padId: string;
+    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>;
+    /** Whether nothing is drawn yet. */
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnDestroy(): void;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(): void;
+    /** Clear the drawing (and the form value). */
+    clear(): void;
+    protected onClearClick(): void;
+    private toLocal;
+    /** Snapshot the per-gesture environment (rect, dpr, stroke color). */
+    private cacheGesture;
+    private scheduleFlush;
+    private cancelFlush;
+    /**
+     * Paint only the not-yet-drawn part of the in-flight stroke. Produces the
+     * same midpoint-smoothed curve as `redraw()` minus the trailing straight
+     * cap to the last point, which the final redraw on pointerup adds.
+     */
+    private drawPending;
+    /** Match the bitmap to the CSS size × devicePixelRatio, then re-render. */
+    private resizeCanvas;
+    private context;
+    private redraw;
+    private emitValue;
+    /** Paint an externally-provided data-URL/image URL onto the pad. */
+    private paintExternal;
+    /**
+     * Marks the control touched once focus leaves it entirely, so a form that
+     * gates its errors on `touched` behaves the same here as on a native input.
+     */
+    protected onFocusOut(event: FocusEvent): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSignaturePad, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSignaturePad, "mk-signature-pad", ["mkSignaturePad"], { "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+/**
+ * A single segment inside an `mk-button-toggle-group`. Projected content is the
+ * label (text, an icon, or both). Its selected state and keyboard behaviour are
+ * driven by the parent group.
+ *
+ * ```html
+ * <mk-button-toggle value="bold" aria-label="Bold"><b>B</b></mk-button-toggle>
+ * ```
+ */
+declare class MkButtonToggle {
+    private readonly group;
+    private readonly btnRef;
+    /** The value contributed to the group's selection when this item is on. */
+    readonly value: _angular_core.InputSignal<unknown>;
+    /** Disable just this item. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether this item is currently selected (owned by the parent group). */
+    readonly selected: _angular_core.Signal<boolean>;
+    /** Disabled if the item or the whole group is disabled. */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /** `radio` in single-select groups; a plain toggle button in multiple mode. */
+    protected readonly role: _angular_core.Signal<"radio" | null>;
+    /** `aria-checked` for the radio role; `null` otherwise. */
+    protected readonly ariaChecked: _angular_core.Signal<boolean | null>;
+    /** `aria-pressed` for multiple-select toggle buttons; `null` otherwise. */
+    protected readonly ariaPressed: _angular_core.Signal<boolean | null>;
+    /** Roving tabindex position within the group. */
+    protected readonly tabIndex: _angular_core.Signal<number>;
+    protected onClick(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Move focus to this item's button. Called by the parent group. */
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkButtonToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkButtonToggle, "mk-button-toggle", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * ButtonToggleGroup — a segmented control grouping one or more
+ * `mk-button-toggle` items into a single, keyboard-operable selection.
+ *
+ * In single-select mode (default) the group is an ARIA `radiogroup`: exactly
+ * one item is selected, Arrow keys move and select, and the selected item is
+ * the tab stop. Set `multiple` to allow any number of items — the group
+ * becomes a toolbar of independent `aria-pressed` buttons.
+ *
+ * Implements `ControlValueAccessor` and exposes a two-way `value` model. In
+ * single mode `value` is the chosen item's `value`; in multiple mode it is an
+ * array of the selected values.
+ *
+ * ```html
+ * <mk-button-toggle-group [(value)]="view" aria-label="View">
+ *   <mk-button-toggle value="grid">Grid</mk-button-toggle>
+ *   <mk-button-toggle value="list">List</mk-button-toggle>
+ * </mk-button-toggle-group>
+ * ```
+ */
+declare class MkButtonToggleGroup implements ControlValueAccessor {
+    private readonly host;
+    /** Optional surrounding form field — supplies label/hint/error wiring. */
+    private readonly field;
+    /** Live list of projected toggle items, in DOM order. */
+    readonly toggles: _angular_core.Signal<readonly MkButtonToggle[]>;
+    /** Allow selecting any number of items (toolbar of `aria-pressed` buttons). */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size, applied to every item. Ignored inside an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** The size actually applied (the form field's when nested). */
+    readonly effectiveSize: _angular_core.Signal<MkSize>;
+    /** Label / description ids inherited from a surrounding form field. */
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    /** Semantic color tone used for the selected fill. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Disable the whole group. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the invalid visual + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Accessible name for the group (recommended). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /**
+     * Two-way selected value. Single mode: the chosen item's `value` (or `null`).
+     * Multiple mode: an array of selected values.
+     */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    private readonly cvaDisabled;
+    private readonly roving;
+    private onChange;
+    private onTouched;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    /** The single item that currently owns the tab stop (roving tabindex). */
+    private readonly rovingTarget;
+    /** Whether a given item is part of the current selection. */
+    isSelected(toggle: MkButtonToggle): boolean;
+    /** `0` for the item that owns the tab stop, `-1` for the rest. */
+    tabIndexFor(toggle: MkButtonToggle): number;
+    /** Toggle (multiple) or set (single) the selection for an item. */
+    select(toggle: MkButtonToggle): void;
+    onKeydown(event: KeyboardEvent, toggle: MkButtonToggle): void;
+    private nextEnabled;
+    private commit;
+    /**
+     * Marks the control touched once focus leaves it entirely, so a form that
+     * gates its errors on `touched` behaves the same here as on a native input.
+     */
+    protected onFocusOut(event: FocusEvent): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkButtonToggleGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkButtonToggleGroup, "mk-button-toggle-group", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["toggles"], ["*"], true, never>;
+}
+
+/**
+ * Radio — a single option within an `mk-radio-group`. Rendered as
+ * `role="radio"` with a roving tabindex managed by the parent group, so the
+ * whole group is a single Tab stop and Arrow keys move between options.
+ *
+ * Must be used as a child of `mk-radio-group`.
+ *
+ * ```html
+ * <mk-radio [value]="'pro'">Pro plan</mk-radio>
+ * ```
+ */
+declare class MkRadio implements OnInit, OnDestroy {
+    protected readonly group: MkRadioGroup;
+    private readonly host;
+    /** The value contributed to the group when this radio is selected. */
+    readonly value: _angular_core.InputSignal<unknown>;
+    /** Disable just this radio. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly size: Signal<MkSize>;
+    readonly checked: Signal<boolean>;
+    readonly isDisabled: Signal<boolean>;
+    /** Roving tabindex: the checked radio (or the first enabled one) is tabbable. */
+    protected readonly tabindex: Signal<number>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Focus this radio's host element (used by the group's keyboard nav). */
+    focus(): void;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkRadio, "mk-radio", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * RadioGroup — an ARIA `radiogroup` that coordinates projected `mk-radio`
+ * children. It manages a single selected value with roving tabindex and
+ * Arrow-key navigation (Up/Left = previous, Down/Right = next, wrapping and
+ * skipping disabled radios).
+ *
+ * Implements `ControlValueAccessor` with a two-way `value` model.
+ *
+ * ```html
+ * <mk-radio-group [(ngModel)]="plan" aria-label="Plan">
+ *   <mk-radio [value]="'free'">Free</mk-radio>
+ *   <mk-radio [value]="'pro'">Pro</mk-radio>
+ * </mk-radio-group>
+ * ```
+ */
+declare class MkRadioGroup implements ControlValueAccessor, Validator {
+    private readonly host;
+    private readonly field;
+    /** Two-way selected value. */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    /** Disable the whole group. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the invalid visual + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Mark required (adds `aria-required`). */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Size applied to all child radios. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Semantic color tone applied to all child radios. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Shared `name` grouping (defaults to a generated unique name). */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Layout direction; also sets arrow-key mapping expectations. */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    private readonly radios;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly isDisabled: Signal<boolean>;
+    protected readonly isRequired: Signal<boolean>;
+    protected readonly isInvalid: Signal<boolean>;
+    protected readonly labelledBy: Signal<string | null>;
+    protected readonly describedBy: Signal<string | null>;
+    /** Whether a radio currently matches the selected value. */
+    readonly hasChecked: Signal<boolean>;
+    /** Register a child radio (called from `mk-radio` on init). */
+    register(radio: MkRadio): void;
+    /** Unregister a child radio (called on destroy). */
+    unregister(radio: MkRadio): void;
+    /** True when `radio` matches the group's current value. */
+    isChecked(radio: MkRadio): boolean;
+    /** The radio that should be tabbable when nothing is selected. */
+    readonly firstEnabled: Signal<MkRadio | null>;
+    /** Select a radio's value (guarded by disabled state). */
+    select(radio: MkRadio): void;
+    protected onKeydown(event: Event): void;
+    /**
+     * Marks the control touched once focus leaves it entirely, so a form that
+     * gates its errors on `touched` behaves the same here as on a native input.
+     */
+    protected onFocusOut(event: FocusEvent): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `required` when `[required]` is set and no radio is selected.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkRadioGroup, "mk-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Switch — a toggle with `role="switch"` and an animated knob. Operable with
+ * Space/Enter, projects its label, and supports size + tone.
+ *
+ * Implements `ControlValueAccessor` with a two-way `checked` model, so it works
+ * with `[(ngModel)]`, reactive forms and `[(checked)]`.
+ *
+ * ```html
+ * <mk-switch [(ngModel)]="notify">Email notifications</mk-switch>
+ * <mk-switch [(checked)]="dark" tone="success" size="lg">Dark mode</mk-switch>
+ * ```
+ */
+declare class MkSwitch implements ControlValueAccessor {
+    private readonly field;
+    /** Two-way checked (on/off) state. */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    /** Disable the control. */
+    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. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Semantic color tone for the "on" track. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Accessible label when no text content is projected. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    protected onTouched: () => void;
+    readonly labelId: string;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected toggle(): void;
+    protected onKeydown(event: Event): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSwitch, "mk-switch", never, { "checked": { "alias": "checked"; "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; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Slider — a single-value range slider with `role="slider"`, a filled track and
+ * a draggable thumb (pointer events). Fully keyboard operable: Arrow keys step,
+ * Page Up/Down take larger steps, Home/End jump to the bounds.
+ *
+ * Implements `ControlValueAccessor` with a two-way `value` model, so it works
+ * with `[(ngModel)]`, reactive forms and `[(value)]`.
+ *
+ * ```html
+ * <mk-slider [min]="0" [max]="100" [step]="5" [(ngModel)]="volume" />
+ * ```
+ */
+declare class MkSlider implements ControlValueAccessor, Validator, OnDestroy {
+    private readonly field;
+    private readonly trackRef;
+    private readonly thumbRef;
+    /** Minimum value. */
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Maximum value. */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Step increment (must be > 0). */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Disable the control. */
+    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 (track/thumb thickness). */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Semantic color tone for the filled track + thumb. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Accessible label for the thumb. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Two-way current value. */
+    readonly value: _angular_core.ModelSignal<number>;
+    private dragging;
+    /** Element the drag listeners are attached to (only while dragging). */
+    private dragTarget;
+    /** Track geometry cached at pointerdown — no layout reads per move. */
+    private dragRect;
+    /** Text direction cached at pointerdown (keyboard keeps live reads). */
+    private dragRtl;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _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>;
+    /** Fill percentage (0–100) for the track + thumb position. */
+    protected readonly percent: _angular_core.Signal<number>;
+    private get bigStep();
+    protected onKeydown(event: Event): void;
+    protected onPointerDown(event: Event): void;
+    private readonly onDragMove;
+    private readonly onDragEnd;
+    /** Blur while dragging releases the drag (template binding). */
+    protected onPointerUp(): void;
+    private endDrag;
+    ngOnDestroy(): void;
+    /** Whether the rendered track is right-to-left. */
+    private isRtl;
+    /** Pointer-drag path only — uses the geometry cached at pointerdown. */
+    private updateFromClientX;
+    private setValue;
+    private clampSnap;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `min` / `max` for a value outside the track. The slider clamps
+     * what the user can produce, so this only fires for a value written in
+     * from the model side.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkSlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkSlider, "mk-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "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; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * ColorPicker — a compact color control: a live swatch that opens the native OS
+ * picker, an editable hex field and an optional row of preset swatches.
+ * `ControlValueAccessor` + two-way `value` model over a hex string.
+ *
+ * ```html
+ * <mk-color-picker [(value)]="brand" [swatches]="palette" />
+ * ```
+ */
+declare class MkColorPicker implements ControlValueAccessor {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly nativeRef;
+    /** Two-way hex color value. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Preset swatches (hex strings). */
+    readonly swatches: _angular_core.InputSignal<readonly string[]>;
+    /** Show the editable hex text field. */
+    readonly hexInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling when standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Control size. Ignored inside an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Accessible label for the swatch trigger. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly inputId: string;
+    /** Uncommitted text in the hex field (may be partial while typing). */
+    protected readonly hexText: _angular_core.WritableSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    constructor();
+    protected readonly effectiveSize: _angular_core.Signal<MkSize>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly nativeValue: _angular_core.Signal<string>;
+    /** Open the OS color picker (via the hidden native input). */
+    protected openNative(): void;
+    protected onNativeInput(event: Event): void;
+    protected onHexInput(event: Event): void;
+    protected commitHex(): void;
+    protected pickSwatch(hex: string): void;
+    private setValue;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkColorPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkColorPicker, "mk-color-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "swatches": { "alias": "swatches"; "required": false; "isSignal": true; }; "hexInput": { "alias": "hexInput"; "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; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** A `[low, high]` value pair. */
+type MkRange = [number, number];
+/**
+ * RangeSlider — a two-thumb slider selecting a `[low, high]` range. Each thumb is
+ * a `role="slider"` (Arrow / Page / Home / End keys); the thumbs can't cross.
+ * Implements `ControlValueAccessor` over a `[number, number]` tuple with a
+ * two-way `value` model.
+ *
+ * ```html
+ * <mk-range-slider [min]="0" [max]="1000" [step]="10" [(value)]="priceRange" />
+ * ```
+ */
+declare class MkRangeSlider implements ControlValueAccessor, Validator, OnDestroy {
+    private readonly host;
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly trackRef;
+    private readonly thumbRefs;
+    /** Minimum value. */
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Maximum value. */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Step increment (must be > 0). */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Disable the control. */
+    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. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /** Semantic tone for the filled range + thumbs. */
+    readonly tone: _angular_core.InputSignal<MkTone>;
+    /** Accessible label for the low thumb. */
+    readonly minLabel: _angular_core.InputSignal<string>;
+    /** Accessible label for the high thumb. */
+    readonly maxLabel: _angular_core.InputSignal<string>;
+    /** Two-way `[low, high]` value. */
+    readonly value: _angular_core.ModelSignal<MkRange>;
+    private activeThumb;
+    /** Element the drag listeners are attached to (only while dragging). */
+    private dragTarget;
+    /** Track geometry cached at pointerdown — no layout reads per move. */
+    private dragRect;
+    /** Text direction cached at pointerdown (keyboard keeps live reads). */
+    private dragRtl;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    protected readonly low: _angular_core.Signal<number>;
+    protected readonly high: _angular_core.Signal<number>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    private pct;
+    protected readonly lowPercent: _angular_core.Signal<number>;
+    protected readonly highPercent: _angular_core.Signal<number>;
+    private get bigStep();
+    protected onKeydown(thumb: 0 | 1, event: Event): void;
+    protected onPointerDown(event: Event): void;
+    private readonly onDragMove;
+    private readonly onDragEnd;
+    private endDrag;
+    ngOnDestroy(): void;
+    /** Whether the rendered track is right-to-left. */
+    private isRtl;
+    /** Pointer-drag path only — uses the geometry cached at pointerdown. */
+    private rawFromClientX;
+    private setThumb;
+    private clampSnap;
+    /**
+     * Marks the control touched once focus leaves it entirely, so a form that
+     * gates its errors on `touched` behaves the same here as on a native input.
+     */
+    protected onFocusOut(event: FocusEvent): void;
+    writeValue(value: MkRange | null): void;
+    registerOnChange(fn: (value: MkRange) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `min` / `max` for either endpoint falling outside the track. The
+     * slider clamps what the user can produce, so this only fires for a range
+     * written in from the model side.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkRangeSlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkRangeSlider, "mk-range-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "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; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "minLabel": { "alias": "minLabel"; "required": false; "isSignal": true; }; "maxLabel": { "alias": "maxLabel"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+export { MK_CARD_BRAND_NAMES, MK_IBAN_LENGTHS, MK_KEYBOARD_LAYOUT_QWERTY_PL, MK_PHONE_COUNTRIES, MK_POSTAL_FORMATS, MK_TAX_ID_FORMATS, MkAutocomplete, MkButtonToggle, MkButtonToggleGroup, MkCardNumberInput, MkCodeEditor, MkColorPicker, MkCurrencyInput, MkFileUpload, MkFormErrorSummary, MkFormField, MkI18nInput, MkIbanInput, MkInput, MkInputGroup, MkMention, MkMentionPanel, MkMultiSelect, MkNumberInput, MkNumericKeypad, MkOnScreenKeyboard, MkOnScreenKeyboardTrigger, MkOtp, MkPasswordInput, MkPhoneInput, MkPostalCodeInput, MkRadio, MkRadioGroup, MkRangeSlider, MkRating, MkRepeater, MkRepeaterEmpty, MkRepeaterRow, MkSelect, MkSignaturePad, MkSlider, MkSubmitInput, MkSwitch, MkTagInput, MkTaxIdInput, MkTransferList, MkTreeSelect, mkCountryFlag, mkDetectCardBrand, mkIbanChecksum, mkIbanIsValid, mkIbanValidator, mkLuhnCheck, mkNipChecksum, mkPostalCodeValidator, mkPostalFormat, mkTaxIdFormat, mkTaxIdIsValid, mkTaxIdValidator };
+export type { MkAutocompleteFilterMode, MkAutocompleteOption, MkCardBrand, MkCodeValidity, MkFormError, MkI18nLocale, MkI18nValue, MkKeyboardActionKey, MkKeyboardKey, MkKeyboardLayout, MkMentionFilterMode, MkMentionOption, MkMentionSearchEvent, MkMentionSelectEvent, MkMultiSelectFilterMode, MkMultiSelectOption, MkNumericKeypadMode, MkOnScreenKeyboardTarget, MkPasswordRule, MkPhoneCountry, MkPhoneValue, MkPostalFormat, MkRange, MkRepeaterRowContext, MkSelectOption, MkTaxIdFormat, MkTransferItem, MkUploadFile, MkUploadFn, MkUploadRejection, MkUploadStatus, MkUploadValueFormat };