@mk-kit/ui 0.34.0

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

@@ -0,0 +1,1171 @@
+import * as _mk_kit_ui_core from '@mk-kit/ui/core';
+import { MkDateNames, MkSize } from '@mk-kit/ui/core';
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+
+/**
+ * Dependency-free date helpers shared by the mk-kit DATE & TIME components.
+ * All functions are pure and operate on native `Date`. Name-producing helpers
+ * default to English but accept an optional {@link MkDateNames} table (from
+ * `MK_I18N`) for localisation. Dates are treated in the local time zone.
+ */
+
+/** Day-of-week index 0 (Sunday) … 6 (Saturday). */
+type MkWeekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/** True when both dates fall on the same calendar day (local time). */
+declare function isSameDay(a: Date, b: Date): boolean;
+/** True when both dates fall in the same calendar month of the same year. */
+declare function isSameMonth(a: Date, b: Date): boolean;
+/** Midnight (00:00:00.000) on the first day of `date`'s month. */
+declare function startOfMonth(date: Date): Date;
+/** Midnight on the last day of `date`'s month. */
+declare function endOfMonth(date: Date): Date;
+/** A new date `count` months after `date` (negative to subtract). Clamps the
+ * day of month so e.g. Jan 31 + 1 month = Feb 28/29, not Mar 3. */
+declare function addMonths(date: Date, count: number): Date;
+/** A new date `count` days after `date` (negative to subtract). */
+declare function addDays(date: Date, count: number): Date;
+/** Midnight (00:00:00.000) on `date`'s calendar day. */
+declare function startOfDay(date: Date): Date;
+/**
+ * The first day of the week containing `date`, at midnight. `firstDayOfWeek`
+ * is the week's starting weekday (0 = Sunday … 6 = Saturday).
+ */
+declare function startOfWeek(date: Date, firstDayOfWeek?: number): Date;
+/** The last day of the week containing `date`, at midnight. */
+declare function endOfWeek(date: Date, firstDayOfWeek?: number): Date;
+/**
+ * ISO-8601 week number (1–53) of `date`. Weeks start on Monday and week 1 is
+ * the week containing the first Thursday of the year.
+ */
+declare function getISOWeek(date: Date): number;
+/** True when `a` is strictly before `b` (full timestamp comparison). */
+declare function isBefore(a: Date, b: Date): boolean;
+/** True when `a` is strictly after `b` (full timestamp comparison). */
+declare function isAfter(a: Date, b: Date): boolean;
+/** Clamp `date` into the inclusive `[min, max]` range (either bound optional). */
+declare function clampDate(date: Date, min?: Date | null, max?: Date | null): Date;
+/** Format `date` as an ISO calendar date `YYYY-MM-DD` (local time). */
+declare function formatISODate(date: Date): string;
+/** Parse a `YYYY-MM-DD` string into a local-time `Date`, or `null` if invalid. */
+declare function parseISODate(value: string | null | undefined): Date | null;
+/**
+ * Format `date` using a small pattern set. Supported tokens:
+ * `yyyy` (4-digit year), `MMMM` (full month), `MMM` (short month),
+ * `MM` (2-digit month), `dd` (2-digit day), `d` (day), `ddd` (short weekday).
+ * Longer tokens are matched first so `MMMM` wins over `MM`.
+ * Month/weekday names come from `names` when given, else English.
+ */
+declare function formatDate(date: Date, pattern: string, names?: MkDateNames): string;
+/**
+ * Build a fixed 6×7 matrix of `Date` cells for `viewDate`'s month, including
+ * the leading days from the previous month and trailing days from the next so
+ * every row is full. `firstDayOfWeek` is 0 (Sunday) … 6 (Saturday).
+ */
+declare function buildMonthMatrix(viewDate: Date, firstDayOfWeek?: number): Date[][];
+/** Full month names, index 0 = January (from `names`, else English). */
+declare function getMonthNames(names?: MkDateNames): readonly string[];
+/**
+ * Weekday header labels ordered to start at `firstDayOfWeek`.
+ * `format` selects `'short'` (e.g. `Mon`) or `'narrow'` (e.g. `M`).
+ * Labels come from `names` when given, else English.
+ */
+declare function getWeekdayNames(firstDayOfWeek?: number, format?: 'short' | 'narrow', names?: MkDateNames): string[];
+/** Full weekday name for `date` (for screen-reader labels). */
+declare function getWeekdayFullName(date: Date, names?: MkDateNames): string;
+
+/** Weekday header descriptor (short label + full name for `abbr[title]`). */
+interface MkWeekdayHeader$1 {
+    short: string;
+    full: string;
+}
+/**
+ * Calendar — an accessible month-grid date picker following the WAI-ARIA
+ * grid / date-picker pattern. It is the reusable core behind
+ * `mk-date-picker` and `mk-date-range-picker`.
+ *
+ * Keyboard (when a day has focus): Arrow keys move by day/week (crossing month
+ * boundaries updates the view), Home/End jump to the start/end of the week,
+ * PageUp/PageDown change month, Shift+PageUp/PageDown change year, and
+ * Enter/Space selects the focused day. A roving tabindex keeps a single tab
+ * stop. Month changes are announced via {@link MkLiveAnnouncer}.
+ *
+ * Exposes a two-way `value` model and implements `ControlValueAccessor`, so it
+ * also works directly with `ngModel` / `formControl` (single-date mode).
+ * Additive range inputs (`rangeMode`,
+ * `rangeStart`, `rangeEnd`) let it highlight an in-progress selection without
+ * affecting single-date use; range hosts listen to `dateSelected`.
+ *
+ * ```html
+ * <mk-calendar [(value)]="date" [min]="minDate" [firstDayOfWeek]="1" />
+ * ```
+ */
+declare class MkCalendar implements ControlValueAccessor, Validator {
+    private readonly host;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly injector;
+    private readonly announcer;
+    /** Two-way selected date (single-date mode). */
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    /** Earliest selectable date (inclusive, day granularity). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Latest selectable date (inclusive, day granularity). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** First column of the week: 0 = Sunday … 6 = Saturday. */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Disable the whole calendar. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force the invalid visual + `aria-invalid` when used standalone. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Predicate marking individual days as disabled. */
+    readonly disabledDate: _angular_core.InputSignal<((d: Date) => boolean) | null>;
+    /** Control size. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    /**
+     * Stretch to fill the container instead of sizing to content.
+     *
+     * Off by default, because the common host is a date-picker popover that must
+     * stay a compact widget. Turn it on when the calendar is laid out as part of
+     * a page — a sidebar or a column — where sizing to content leaves the space
+     * beside it empty. Cells share the width evenly and `--_cell-size` becomes
+     * their minimum rather than their fixed size.
+     */
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable range highlighting. Hosts drive selection via `dateSelected`. */
+    readonly rangeMode: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Range start endpoint to highlight (range mode). */
+    readonly rangeStart: _angular_core.InputSignal<Date | null>;
+    /** Range end endpoint to highlight (range mode). */
+    readonly rangeEnd: _angular_core.InputSignal<Date | null>;
+    /** Emitted whenever a (non-disabled) day is activated. */
+    readonly dateSelected: _angular_core.OutputEmitterRef<Date>;
+    /**
+     * Emitted (in range mode) as the pointer hovers days — the hovered day, or
+     * `null` on leave. Lets hosts preview a selection (e.g. a whole-week
+     * highlight in `mk-week-picker`).
+     */
+    readonly dateHovered: _angular_core.OutputEmitterRef<Date | null>;
+    /** id of the visible month/year label — wire as the grid's label. */
+    readonly labelId: string;
+    /** Disabled state driven by forms (`setDisabledState`). */
+    protected readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
+    /** The day that currently owns the roving tabindex; also drives the view. */
+    protected readonly focusedDate: _angular_core.WritableSignal<Date>;
+    /** Hovered day used to preview a range before the end is picked. */
+    protected readonly hoveredDate: _angular_core.WritableSignal<Date | null>;
+    /** Disabled by the `disabled` input or by the bound form control. */
+    protected readonly isControlDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    /** First day of the visible month. */
+    protected readonly viewMonth: _angular_core.Signal<Date>;
+    /** Human label for the visible month, e.g. `July 2026`. */
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    /** 6×7 grid of dates for the visible month. */
+    protected readonly weeks: _angular_core.Signal<Date[][]>;
+    /** Weekday column headers ordered from `firstDayOfWeek`. */
+    protected readonly weekdays: _angular_core.Signal<MkWeekdayHeader$1[]>;
+    private announcedMonth;
+    constructor();
+    private onChange;
+    private onTouched;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Marks the control touched when focus leaves the calendar entirely. */
+    protected onFocusout(event: FocusEvent): void;
+    private initialFocus;
+    protected isOutside(d: Date): boolean;
+    protected isDisabled(d: Date): boolean;
+    protected isToday(d: Date): boolean;
+    protected isSelected(d: Date): boolean;
+    protected isFocused(d: Date): boolean;
+    /** Effective range end while previewing (falls back to the hovered day). */
+    private previewEnd;
+    protected isRangeStart(d: Date): boolean;
+    protected isRangeEnd(d: Date): boolean;
+    protected isInRange(d: Date): boolean;
+    /**
+     * `aria-selected` state of a day's gridcell. Single-date mode mirrors
+     * `isSelected`; range mode exposes the committed endpoints and the days
+     * between them (hover previews stay visual-only so the accessibility tree
+     * doesn't churn while the pointer moves).
+     */
+    protected isAriaSelected(d: Date): boolean;
+    protected dayLabel(d: Date): string;
+    protected select(d: Date): void;
+    protected onHover(d: Date): void;
+    protected clearHover(): void;
+    protected prevMonth(): void;
+    protected nextMonth(): void;
+    protected prevYear(): void;
+    protected nextYear(): void;
+    protected onGridKeydown(event: Event): void;
+    private weekdayOffset;
+    private moveFocus;
+    private focusActiveCell;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMinDate` / `mkMaxDate` for a date outside `[min]`/`[max]`, and
+     * `mkDateFilter` for one rejected by `[disabledDate]`.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkCalendar, "mk-calendar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabledDate": { "alias": "disabledDate"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "rangeMode": { "alias": "rangeMode"; "required": false; "isSignal": true; }; "rangeStart": { "alias": "rangeStart"; "required": false; "isSignal": true; }; "rangeEnd": { "alias": "rangeEnd"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "dateSelected": "dateSelected"; "dateHovered": "dateHovered"; }, never, never, true, never>;
+}
+
+/**
+ * DatePicker — a text field paired with a calendar popover. Type a date (parsed
+ * on blur/Enter) or pick one from the `mk-calendar`. Implements
+ * `ControlValueAccessor` and a two-way `value` model, so it works with
+ * `[(ngModel)]`, reactive forms and `[(value)]`.
+ *
+ * The calendar opens below the field, closes on Escape / outside click / after
+ * a selection, and wires `aria-expanded` / `aria-haspopup` / `aria-invalid`.
+ * When nested in an `mk-form-field` it adopts the field's id and aria wiring.
+ *
+ * ```html
+ * <mk-date-picker [(value)]="date" [min]="minDate" clearable />
+ * ```
+ */
+declare class MkDatePicker implements ControlValueAccessor, Validator {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly field;
+    private readonly host;
+    private readonly injector;
+    private readonly inputRef;
+    /** The calendar panel — lives in the top layer once opened. */
+    private readonly panelRef;
+    /** Two-way selected date. */
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    /** Earliest selectable date (inclusive). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Latest selectable date (inclusive). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Predicate marking individual days as disabled (threaded to the calendar). */
+    readonly disabledDate: _angular_core.InputSignal<((d: Date) => boolean) | null>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Pattern used to render the selected date in the field. */
+    readonly displayFormat: _angular_core.InputSignal<string>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a clear button when a date is selected. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling + `aria-invalid`. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** First column of the calendar week (0 = Sunday). */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    /** Editable text mirror of the field. */
+    protected readonly inputText: _angular_core.WritableSignal<string>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly inputId: string;
+    readonly panelId: 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 describedBy: _angular_core.Signal<string | null>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    constructor();
+    protected toggle(): void;
+    protected openPanel(): void;
+    protected close(): void;
+    protected onCalendarPick(date: Date | null): void;
+    protected onInput(event: Event): void;
+    protected onInputKeydown(event: Event): void;
+    protected clear(): void;
+    private commitInput;
+    private parse;
+    private setValue;
+    protected onFocusOut(event: Event): void;
+    /**
+     * Escape pressed inside the (teleported) calendar panel — close and return
+     * focus to the input. `preventDefault` + `stopPropagation` keep any outer
+     * Escape handling (e.g. a containing dialog) from also firing.
+     */
+    protected onPanelEscape(event: Event): void;
+    /**
+     * Focus left the teleported panel. The host `(focusout)` never sees this —
+     * the panel lives under `document.body` — so Tab-out of the calendar is
+     * handled here: close unless focus moved back into the field or the panel.
+     */
+    protected onPanelFocusout(event: FocusEvent): void;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMinDate` / `mkMaxDate` against the `[min]` and `[max]` inputs.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDatePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDatePicker, "mk-date-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabledDate": { "alias": "disabledDate"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "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; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** A selectable time option. */
+interface MkTimeOption {
+    /** Canonical `HH:mm` (24h) value. */
+    value: string;
+    /** Display label (respects `hour12`). */
+    label: string;
+}
+/**
+ * TimePicker — a 24-hour-canonical time field with an editable input plus a
+ * scrollable list of times generated from `step`. The time itself is always
+ * 24h canonical regardless of the `hour12` display. Implements
+ * `ControlValueAccessor` and a two-way `value` model.
+ *
+ * The form value is either a `HH:mm` string (`"14:30"`, default) or a `Date`
+ * carrying the time in its **local** hours/minutes (`valueFormat="date"`, for
+ * hosts whose model is a datetime — e.g. migrating off Material's
+ * `mat-timepicker`); both modes read back either shape and `null` when empty.
+ * Only the *emitted* value depends on `valueFormat` — internally the time is
+ * always normalised to `HH:mm`, which is also what `min` / `max` compare.
+ *
+ * In `date` mode seconds and milliseconds are zeroed, and the **date part** is
+ * taken from the current model value when that is already a `Date` (so editing
+ * the time repeatedly never drifts the day); otherwise today's local date is
+ * used. Assign a `Date` first if the day matters.
+ *
+ * Type a time (`14:30`, `2:30 pm`) or pick from the ARIA listbox
+ * (Up/Down/Home/End/Enter/Esc; the active option scrolls into view). When
+ * nested in an `mk-form-field` it adopts the field's id and aria wiring.
+ *
+ * ```html
+ * <mk-time-picker [(value)]="time" [step]="15" hour12 clearable />
+ * <mk-time-picker valueFormat="date" [(value)]="pickupAt" [step]="15" />
+ * ```
+ */
+declare class MkTimePicker implements ControlValueAccessor, Validator {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly field;
+    private readonly host;
+    private readonly injector;
+    private readonly inputRef;
+    /** The listbox panel — lives in the top layer once opened. */
+    private readonly listRef;
+    /**
+     * Two-way selected time: a canonical `HH:mm` (24h) string, a `Date` when
+     * `valueFormat="date"`, or `null`. Either shape may be assigned in either
+     * mode; it is normalised to the configured format.
+     */
+    readonly value: _angular_core.ModelSignal<string | Date | null>;
+    /** Shape of the form value: a `HH:mm` string or a `Date`. */
+    readonly valueFormat: _angular_core.InputSignal<"string" | "date">;
+    /** Earliest selectable time `HH:mm` (inclusive). */
+    readonly min: _angular_core.InputSignal<string | null>;
+    /** Latest selectable time `HH:mm` (inclusive). */
+    readonly max: _angular_core.InputSignal<string | null>;
+    /** Interval between generated options, in minutes. */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Display 12-hour time with AM/PM (the model stays 24h). */
+    readonly hour12: _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>;
+    /** Show a clear button when a time is selected. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling + `aria-invalid`. */
+    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>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly inputText: _angular_core.WritableSignal<string>;
+    /** The canonical `HH:mm` time behind whatever shape `value` carries. */
+    private readonly time;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    /** The last value this component itself wrote into the `value` model. */
+    private lastDerived;
+    /** The day `date`-mode values land on — see {@link toDate}. */
+    private datePart;
+    readonly inputId: string;
+    readonly listId: 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 describedBy: _angular_core.Signal<string | null>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    /** Generated, min/max-filtered list of selectable times. */
+    protected readonly options: _angular_core.Signal<MkTimeOption[]>;
+    protected readonly selectedIndex: _angular_core.Signal<number>;
+    constructor();
+    protected optionId(index: number): string;
+    private display;
+    private parse;
+    protected toggle(): void;
+    protected openList(): void;
+    protected close(): void;
+    protected selectOption(index: number): void;
+    protected clear(): void;
+    protected onInput(event: Event): void;
+    protected onInputKeydown(event: Event): void;
+    private moveActive;
+    private commitInput;
+    private withinBounds;
+    private setValue;
+    /** 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]`): it
+     * seeds the canonical time and, when it is a `Date`, the day that `date`-mode
+     * values land on.
+     */
+    private applyExternal;
+    /** Normalise any accepted shape to canonical `HH:mm`, or `null`. */
+    private toHhmm;
+    /**
+     * Put `hh:mm` on a `Date`. The date part comes from the current value when
+     * that is already a `Date` (so repeated edits never drift the day),
+     * otherwise from today — always via the local accessors, never the UTC ones.
+     */
+    private toDate;
+    private scrollActiveIntoView;
+    protected onFocusOut(event: Event): void;
+    writeValue(value: string | Date | null): void;
+    registerOnChange(fn: (value: string | Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMinTime` / `mkMaxTime` against the `[min]` and `[max]` inputs.
+     * The control value is normalised to `HH:mm` first (so a `Date` model
+     * validates too); both sides are then zero-padded `HH:mm`, so a
+     * lexicographic compare is a chronological one.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkTimePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkTimePicker, "mk-time-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "hour12": { "alias": "hour12"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "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>;
+}
+
+/** A selected date range. Either endpoint may be `null` while incomplete. */
+interface MkDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+/**
+ * DateRangePicker — select a start + end date from a single calendar popover.
+ * The first click sets the start, the second sets the end (endpoints are
+ * swapped if picked in reverse), and the hovered range is previewed live.
+ * Implements `ControlValueAccessor` and a two-way `value` model of
+ * {@link MkDateRange}.
+ *
+ * ```html
+ * <mk-date-range-picker [(value)]="range" [min]="minDate" clearable />
+ * ```
+ */
+declare class MkDateRangePicker implements ControlValueAccessor, Validator {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly field;
+    private readonly host;
+    private readonly injector;
+    private readonly triggerRef;
+    /** The calendar panel — lives in the top layer once opened. */
+    private readonly panelRef;
+    /** Two-way selected range. */
+    readonly value: _angular_core.ModelSignal<MkDateRange>;
+    /** Earliest selectable date (inclusive). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Latest selectable date (inclusive). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Predicate marking individual days as disabled. */
+    readonly disabledDate: _angular_core.InputSignal<((d: Date) => boolean) | null>;
+    /** Placeholder shown when no range is selected. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Pattern used to render each endpoint. */
+    readonly displayFormat: _angular_core.InputSignal<string>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a clear button when a range is selected. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling + `aria-invalid`. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** First column of the calendar week (0 = Sunday). */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Control size. Ignored when nested in an `mk-form-field`. */
+    readonly size: _angular_core.InputSignal<MkSize>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    /** In-progress start endpoint (drives calendar highlighting). */
+    protected readonly selStart: _angular_core.WritableSignal<Date | null>;
+    /** In-progress end endpoint. */
+    protected readonly selEnd: _angular_core.WritableSignal<Date | null>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly triggerId: string;
+    readonly panelId: 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 showClear: _angular_core.Signal<boolean>;
+    /** Display label, e.g. `Jul 1, 2026 – Jul 9, 2026`. */
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    protected toggle(): void;
+    protected openPanel(): void;
+    protected close(): void;
+    protected onPick(date: Date): void;
+    protected clear(): void;
+    private commit;
+    private setValue;
+    protected onFocusOut(event: Event): void;
+    /**
+     * Escape pressed inside the (teleported) calendar panel — close and return
+     * focus to the trigger. `preventDefault` + `stopPropagation` keep any outer
+     * Escape handling (e.g. a containing dialog) from also firing.
+     */
+    protected onPanelEscape(event: Event): void;
+    /**
+     * Focus left the teleported panel. The host `(focusout)` never sees this —
+     * the panel lives under `document.body` — so Tab-out of the calendar is
+     * handled here: close unless focus moved back into the field or the panel.
+     */
+    protected onPanelFocusout(event: FocusEvent): void;
+    writeValue(value: MkDateRange | null): void;
+    registerOnChange(fn: (value: MkDateRange) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `mkDateRangeIncomplete` for a half-picked range, `mkMinDate` /
+     * `mkMaxDate` for ends outside `[min]`/`[max]`, and `mkDateFilter` for an
+     * end rejected by `[disabledDate]`. A fully empty range passes; compose
+     * with `Validators.required` to reject it.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkDateRangePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkDateRangePicker, "mk-date-range-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabledDate": { "alias": "disabledDate"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "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; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Selection granularity for {@link MkMonthPicker}. */
+type MkMonthPickerMode = 'month' | 'year';
+interface Cell {
+    label: string;
+    /** Year (both modes) and month index (month mode only). */
+    year: number;
+    month: number;
+    disabled: boolean;
+    selected: boolean;
+}
+/**
+ * MonthPicker — a compact field + popover for picking a **month** (`MMM yyyy`)
+ * or a **year**. The panel shows a 12-month grid (with year nav) or a 12-year
+ * grid (with decade nav). Value is a `Date` at the first day of the selection.
+ * Implements `ControlValueAccessor` + a two-way `value` model; the panel renders
+ * in the top layer so it is never clipped.
+ *
+ * ```html
+ * <mk-month-picker [(value)]="month" />
+ * <mk-month-picker mode="year" [(value)]="year" />
+ * ```
+ */
+declare class MkMonthPicker implements ControlValueAccessor, Validator {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly field;
+    private readonly host;
+    private readonly injector;
+    private readonly triggerRef;
+    private readonly panelRef;
+    private readonly cellRefs;
+    /** Two-way selected date (first of the month / year). */
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    /** Pick a month or a whole year. */
+    readonly mode: _angular_core.InputSignal<MkMonthPickerMode>;
+    /** Earliest selectable date. */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Latest selectable date. */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Display pattern (defaults to `MMM yyyy` / `yyyy`). */
+    readonly displayFormat: _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>;
+    /** The year currently shown in the panel (base for the month/decade grid). */
+    protected readonly viewYear: _angular_core.WritableSignal<number>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly triggerId: string;
+    readonly panelId: 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 resolvedPlaceholder: _angular_core.Signal<string>;
+    private readonly pattern;
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    /** The decade start when in year mode. */
+    private readonly decadeStart;
+    /** Header label (year, or decade range). */
+    protected readonly headerLabel: _angular_core.Signal<string>;
+    /** Abbreviated month labels for the grid, from the active locale. */
+    private readonly months;
+    /** The 12 grid cells (months or years). */
+    protected readonly cells: _angular_core.Signal<Cell[]>;
+    constructor();
+    protected toggle(): void;
+    protected openPanel(): void;
+    protected close(restoreFocus?: boolean): void;
+    protected shiftView(delta: number): void;
+    protected selectCell(cell: Cell): void;
+    protected clear(event: Event): void;
+    protected onGridKeydown(event: KeyboardEvent): void;
+    private focusActive;
+    protected onFocusOut(event: FocusEvent): void;
+    private outOfRange;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMinDate` / `mkMaxDate` against the `[min]` and `[max]` inputs,
+     * compared at month granularity.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkMonthPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkMonthPicker, "mk-month-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "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>;
+}
+
+/** A selected calendar week (its first and last day, at midnight). */
+interface MkWeek {
+    start: Date;
+    end: Date;
+}
+/**
+ * WeekPicker — pick a whole calendar week from a popover calendar. Hovering a
+ * day previews its entire week; clicking selects it. The value is an
+ * {@link MkWeek} (`{ start, end }`, aligned to `firstDayOfWeek`). Implements
+ * `ControlValueAccessor` and a two-way `value` model; the panel renders in the
+ * top layer so it is never clipped.
+ *
+ * ```html
+ * <mk-week-picker [(value)]="week" [firstDayOfWeek]="1" clearable />
+ * ```
+ */
+declare class MkWeekPicker implements ControlValueAccessor, Validator {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly field;
+    private readonly host;
+    private readonly injector;
+    private readonly triggerRef;
+    private readonly panelRef;
+    /** Two-way selected week. */
+    readonly value: _angular_core.ModelSignal<MkWeek | null>;
+    /** Earliest selectable date (inclusive). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Latest selectable date (inclusive). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** First column of the calendar week (0 = Sunday). Also anchors the week. */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Placeholder shown when empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Pattern used to render each endpoint of the week range. */
+    readonly displayFormat: _angular_core.InputSignal<string>;
+    /** Prefix the label with the ISO week number, e.g. `W28 · …`. */
+    readonly showWeekNumber: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Disable the control. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Show a clear button when a week is selected. */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Force invalid styling + `aria-invalid`. */
+    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>;
+    /** The week currently previewed under the pointer (drives highlighting). */
+    private readonly hoverWeek;
+    private readonly cvaDisabled;
+    private onChange;
+    private onTouched;
+    readonly triggerId: string;
+    readonly panelId: 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 showClear: _angular_core.Signal<boolean>;
+    /** The week to highlight: the hovered one while previewing, else the value. */
+    protected readonly highlightWeek: _angular_core.Signal<MkWeek | null>;
+    /** Display label, e.g. `W28 · Jul 6 – Jul 12, 2026`. */
+    protected readonly displayLabel: _angular_core.Signal<string>;
+    protected toggle(): void;
+    protected openPanel(): void;
+    protected close(): void;
+    /** A day inside the calendar was activated — select its whole week. */
+    protected onPick(date: Date): void;
+    /** Preview the hovered day's week. */
+    protected onHover(date: Date | null): void;
+    protected clear(): void;
+    private weekOf;
+    /** Reference date the calendar should open on (the selected week's start). */
+    protected readonly calendarValue: _angular_core.Signal<Date | null>;
+    protected onFocusOut(event: Event): void;
+    writeValue(value: MkWeek | null): void;
+    registerOnChange(fn: (value: MkWeek | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Expose the raw highlight endpoints to the template. */
+    protected highlightStart: _angular_core.Signal<Date | null>;
+    protected highlightEnd: _angular_core.Signal<Date | null>;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMinDate` / `mkMaxDate` when the selected week starts before
+     * `[min]` or ends after `[max]`.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkWeekPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkWeekPicker, "mk-week-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "showWeekNumber": { "alias": "showWeekNumber"; "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>;
+}
+
+/** A timed event positioned inside a day column of the time grid. */
+interface MkTimedPlacement {
+    event: MkCalendarEvent;
+    /** Offset from the top of the grid, percent of the visible hour range. */
+    top: number;
+    /** Height, percent of the visible hour range (never below ~15 min). */
+    height: number;
+    /** Column inside the overlap cluster (0-based). */
+    lane: number;
+    /** Total columns in the overlap cluster — width is `100 / lanes`%. */
+    lanes: number;
+}
+
+/** The calendar's presentation: month grid, or a timed week/day grid. */
+type MkCalendarView = 'month' | 'week' | 'day';
+/** A single event plotted onto the {@link MkEventCalendar}. */
+interface MkCalendarEvent {
+    /**
+     * The day the event falls on. Month view places by this alone; in week/day
+     * view an event with no `start` renders in the all-day strip.
+     */
+    date: Date;
+    /** Start instant — positions the event on the week/day time grid. */
+    start?: Date;
+    /** End instant; defaults to 30 minutes after `start`. */
+    end?: Date;
+    /** Short label shown inside the event pill. */
+    title: string;
+    /** Optional pill background colour; falls back to `--mk-primary`. */
+    color?: string;
+    /** Optional caller-supplied identifier, echoed back on `eventClick`. */
+    id?: unknown;
+}
+/**
+ * Payload of `eventMove` / `eventResize`: the untouched source event plus the
+ * would-be new time range. The calendar itself never mutates `events` — the
+ * consumer owns the data and applies (or rejects) the change.
+ */
+interface MkCalendarEventEdit {
+    /** The event that was dragged — the exact object from the `events` input. */
+    event: MkCalendarEvent;
+    /** New start instant (snapped to `snapMinutes`). */
+    start: Date;
+    /** New end instant (snapped; never closer than `snapMinutes` to `start`). */
+    end: Date;
+}
+/** Weekday column header (short label + full name for the `abbr[title]`). */
+interface MkWeekdayHeader {
+    short: string;
+    full: string;
+}
+/** Template-facing state of the in-flight edit, driving the pill + outline. */
+interface EditPreviewState {
+    event: MkCalendarEvent;
+    /** Target column index — the drop outline renders in this column. */
+    day: number;
+    /** Compositor-friendly lift transform for the dragged pill. */
+    transform: string;
+    /** Height override (%) while the duration differs, else `null`. */
+    heightPct: number | null;
+    /** Would-be range shown on the pill, e.g. `09:30 – 10:45`. */
+    label: string;
+    /** Drop-outline top, percent of the visible hour range. */
+    top: number;
+    /** Drop-outline height, percent of the visible hour range. */
+    outlineHeight: number;
+}
+/** A rendered day cell: its date, classification, and the events on it. */
+interface MkDayCell {
+    date: Date;
+    outside: boolean;
+    today: boolean;
+    /** Up to `maxPerDay` events shown as pills. */
+    visible: readonly MkCalendarEvent[];
+    /** Count beyond `maxPerDay` (0 when nothing is hidden). */
+    overflow: number;
+    /**
+     * Precomputed screen-reader label (see {@link MkEventCalendar#dayLabel}) —
+     * formatting it once here keeps `formatDate` out of the per-CD template path
+     * for all 42 cells.
+     */
+    label: string;
+}
+/**
+ * Event calendar — a month-grid scheduler view. Renders a 6×7 grid of day
+ * cells built from {@link buildMonthMatrix}; each cell lists the events whose
+ * `date` falls on that day as coloured pills, capped at `maxPerDay` with a
+ * "+N more" line for the remainder.
+ *
+ * Shares the month-grid rendering, header navigation, and weekday header of
+ * `mk-calendar` but is display-only (no date selection). Exposes the viewed
+ * month as a two-way `viewDate` model plus `dayClick` / `eventClick` outputs.
+ *
+ * With `editable`, the week/day time grids additionally support drag-to-move
+ * and drag-to-resize (pointer *and* keyboard — WCAG 2.5.7): times snap to
+ * `snapMinutes` and the would-be range is emitted via `eventMove` /
+ * `eventResize` — the calendar never mutates `events` itself.
+ *
+ * ```html
+ * <mk-event-calendar [events]="events" [(viewDate)]="month"
+ *   (eventClick)="open($event)" />
+ * ```
+ */
+declare class MkEventCalendar implements OnDestroy {
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly doc;
+    private readonly hostEl;
+    private readonly announcer;
+    /** Events to plot onto the grid. */
+    readonly events: _angular_core.InputSignal<readonly MkCalendarEvent[]>;
+    /** Two-way month being viewed (any day within it). Defaults to today. */
+    readonly viewDate: _angular_core.ModelSignal<Date>;
+    /** First column of the week: 0 = Sunday … 6 = Saturday. */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Max event pills per day before collapsing the rest into "+N more". */
+    readonly maxPerDay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Presentation: the classic month grid, or a timed `week`/`day` grid. */
+    readonly view: _angular_core.ModelSignal<MkCalendarView>;
+    /** First hour shown on the week/day time grid. */
+    readonly dayStartHour: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Hour the time grid ends at (exclusive). */
+    readonly dayEndHour: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Week/day views: allow rescheduling events by dragging a pill (move) or its
+     * bottom edge (resize end time), by pointer or keyboard. Off by default —
+     * without it the grid renders exactly as before (no handles, no ARIA
+     * additions, no drag behavior).
+     */
+    readonly editable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Snap grid (minutes) for drag/keyboard edits; also the minimum duration. */
+    readonly snapMinutes: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Emitted when a day cell is activated (click / Enter). */
+    readonly dayClick: _angular_core.OutputEmitterRef<Date>;
+    /**
+     * Emitted when an event pill is clicked (does not also fire `dayClick`).
+     * Mouse-only convenience: the pills are presentational (`aria-hidden`), so
+     * keyboard / screen-reader users reach events via the day button — its label
+     * announces the day's events and activating it fires `dayClick`.
+     */
+    readonly eventClick: _angular_core.OutputEmitterRef<MkCalendarEvent>;
+    /** Emitted when the viewed range changes via the prev/next buttons. */
+    readonly monthChange: _angular_core.OutputEmitterRef<Date>;
+    /** Week/day view: an empty hour slot was clicked — the slot's start instant. */
+    readonly slotClick: _angular_core.OutputEmitterRef<Date>;
+    /**
+     * Editable week/day grid: an event pill was dragged (or keyboard-moved) to a
+     * new start time and/or day. Carries the would-be `start`/`end` — the
+     * calendar does **not** mutate `events`; the consumer owns the data and
+     * applies the change, typically:
+     *
+     * ```ts
+     * onMove = ({ event, start, end }: MkCalendarEventEdit) =>
+     *   (this.events = this.events.map((e) =>
+     *     e === event ? { ...e, date: start, start, end } : e,
+     *   ));
+     * ```
+     */
+    readonly eventMove: _angular_core.OutputEmitterRef<MkCalendarEventEdit>;
+    /**
+     * Editable week/day grid: the pill's bottom edge was dragged (or
+     * Shift+Arrow-resized) — only `end` differs, never below `snapMinutes` of
+     * duration. Same consumer-owns-the-data contract as `eventMove`.
+     */
+    readonly eventResize: _angular_core.OutputEmitterRef<MkCalendarEventEdit>;
+    /** id of the visible month/year label — wired as the grid's label. */
+    readonly labelId: string;
+    /** First day of the visible month. */
+    protected readonly viewMonth: _angular_core.Signal<Date>;
+    /** Header label — month, day, or week range, matching the active view. */
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    /** Days of the active time grid: one for `day`, seven for `week`. */
+    protected readonly gridDays: _angular_core.Signal<Date[]>;
+    /** Hour rows of the time grid. */
+    protected readonly hours: _angular_core.Signal<number[]>;
+    /**
+     * Timed events bucketed by their start's calendar day — a single pass over
+     * the events, shared by every column of the week/day grid instead of
+     * re-filtering (and re-sorting) the whole array once per day.
+     */
+    private readonly timedByDay;
+    /** Untimed events (all-day strip) bucketed by `date`'s calendar day. */
+    private readonly allDayByDay;
+    /**
+     * Per-day positioned events + all-day strip for the time grid. The column
+     * head (`Mon 21`) is precomputed here so the template never calls
+     * `formatDate` during change detection.
+     */
+    protected readonly timedColumns: _angular_core.Signal<{
+        day: Date;
+        today: boolean;
+        head: string;
+        placements: MkTimedPlacement[];
+        allDay: MkCalendarEvent[];
+    }[]>;
+    protected hourLabel(hour: number): string;
+    protected placementTitle(p: MkTimedPlacement): string;
+    protected onSlotClick(day: Date, hour: number): void;
+    /** Template-facing state of the in-flight edit (`null` when idle). */
+    protected readonly editPreview: _angular_core.WritableSignal<EditPreviewState | null>;
+    /** The active pointer gesture, if any (only one at a time). */
+    private pointerSession;
+    /** The active keyboard "move mode" session, if any. */
+    private kbSession;
+    /** Pending rAF id for the coalesced pointer-move pass. */
+    private editRaf;
+    private pendingX;
+    private pendingY;
+    /** Set after a real drag so the trailing synthetic click never fires `eventClick`. */
+    private swallowNextClick;
+    private readonly pointerMoveHandler;
+    private readonly pointerUpHandler;
+    private readonly pointerCancelHandler;
+    /** Escape aborts an in-flight pointer drag (document-level while dragging). */
+    private readonly escHandler;
+    /**
+     * `touch-action: pan-y` keeps native scrolling alive while the long-press is
+     * pending, so once armed the drag must eat `touchmove` itself
+     * (`passive: false` — same pattern as `MkDrag`).
+     */
+    private readonly touchMoveEater;
+    /** Android fires `contextmenu` on long-press — keep it off the gesture. */
+    private readonly contextMenuHandler;
+    protected onBlockPointerDown(event: Event, p: MkTimedPlacement, colIndex: number): void;
+    /** The long-press delay elapsed with the finger still down — arm the drag. */
+    private armTouch;
+    private onEditPointerMove;
+    /**
+     * The drag crossed the threshold — snapshot geometry once (column rects and
+     * the px↔minute scale); every subsequent move works off this cache, so a
+     * drag never forces layout.
+     */
+    private beginEdit;
+    /** Per-frame move pass: snap, clamp, and publish the preview signal. */
+    private applyPendingEdit;
+    /** Column index under `x`, from the rects snapshotted at lift. */
+    private columnAt;
+    private onEditPointerUp;
+    /** Escape / pointercancel: the pill snaps back, nothing is emitted. */
+    private abortPointerEdit;
+    /** Undo everything `onBlockPointerDown`/`beginEdit` set up. */
+    private teardownPointer;
+    protected onBlockKeydown(event: Event, p: MkTimedPlacement, colIndex: number): void;
+    /** Losing focus mid-move cancels the keyboard edit (no stuck state). */
+    protected onBlockBlur(): void;
+    private armKeyboard;
+    private commitKeyboard;
+    private cancelKeyboard;
+    /**
+     * Emit the edited range (if anything actually changed): `eventResize` when
+     * only the end moved, `eventMove` otherwise. The `events` input is never
+     * touched — applying the change is the consumer's job.
+     */
+    private commitEdit;
+    /** Publish the session's current target as template-facing preview state. */
+    private updatePreview;
+    private announceCancelled;
+    /** Position update after each keyboard step. */
+    private announceStep;
+    /** Is this placement the pill currently being edited? */
+    protected isEditing(p: MkTimedPlacement): boolean;
+    /** Lift transform for the dragged pill (`null` when idle). */
+    protected blockTransform(p: MkTimedPlacement): string | null;
+    /** Height (%) — the resize preview overrides the layout's height. */
+    protected blockHeight(p: MkTimedPlacement): number;
+    /** Would-be time range shown on the pill while it is being edited. */
+    protected dragLabelFor(p: MkTimedPlacement): string | null;
+    /** Drop-outline geometry when the edit currently targets column `i`. */
+    protected dropOutlineFor(i: number): EditPreviewState | null;
+    /**
+     * Accessible name for an editable pill — the title plus its time range
+     * (composed with, not replacing, the visible title text and tooltip).
+     */
+    protected blockAriaLabel(p: MkTimedPlacement): string;
+    /** `aria-roledescription` for editable pills. */
+    protected readonly movableRoledescription: string;
+    ngOnDestroy(): void;
+    /** Raw 6×7 grid of dates for the visible month. */
+    private readonly weeks;
+    /** Weekday column headers ordered from `firstDayOfWeek`. */
+    protected readonly weekdays: _angular_core.Signal<MkWeekdayHeader[]>;
+    /** Events grouped by local calendar day, keyed by `startOfDay` timestamp. */
+    private readonly eventsByDay;
+    /** 6×7 grid of day cells with their (capped) events resolved. */
+    protected readonly weekCells: _angular_core.Signal<MkDayCell[][]>;
+    /**
+     * Screen-reader label for a day cell. The button's `aria-label` replaces its
+     * visual content, so the label also announces the day's events — count plus
+     * up to three titles — e.g. `July 9, 2026, 2 events: Standup, Demo`.
+     * Precomputed into {@link MkDayCell#label} by `weekCells`.
+     */
+    protected dayLabel(cell: Omit<MkDayCell, 'label'>): string;
+    protected prevMonth(): void;
+    protected nextMonth(): void;
+    private shiftMonth;
+    protected onDayClick(d: Date): void;
+    protected onEventClick(event: Event, calendarEvent: MkCalendarEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkEventCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkEventCalendar, "mk-event-calendar", never, { "events": { "alias": "events"; "required": false; "isSignal": true; }; "viewDate": { "alias": "viewDate"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "maxPerDay": { "alias": "maxPerDay"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "dayStartHour": { "alias": "dayStartHour"; "required": false; "isSignal": true; }; "dayEndHour": { "alias": "dayEndHour"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "snapMinutes": { "alias": "snapMinutes"; "required": false; "isSignal": true; }; }, { "viewDate": "viewDateChange"; "view": "viewChange"; "dayClick": "dayClick"; "eventClick": "eventClick"; "monthChange": "monthChange"; "slotClick": "slotClick"; "eventMove": "eventMove"; "eventResize": "eventResize"; }, never, never, true, never>;
+}
+
+/** Which segment a part represents. */
+type MkDateSegment = 'day' | 'month' | 'year';
+/** Segment display order. */
+type MkMiniDateOrder = 'dmy' | 'mdy' | 'ymd';
+/** A rendered segment descriptor (view-model for one spinbutton). */
+interface MkDatePart {
+    key: MkDateSegment;
+    /** Text shown in the segment, or the placeholder when empty. */
+    display: string;
+    /** Whether the segment currently holds a value. */
+    filled: boolean;
+    valueNow: number | null;
+    valueMin: number;
+    valueMax: number;
+    valueText: string;
+    label: string;
+}
+/**
+ * MiniDate — a compact, popover-free inline date editor with segmented
+ * day / month / year spin fields (like a native `<input type="date">` but
+ * themed and signal-driven). Each segment is an ARIA `spinbutton`: Arrow
+ * Up/Down step the value (day wraps within the month), Home/End jump to the
+ * segment's minimum/maximum, Arrow Left/Right move between segments, and
+ * typing digits fills the focused segment and auto-advances (OTP-style). Implements `ControlValueAccessor` and a two-way
+ * `value` model over a real `Date | null`.
+ *
+ * A non-null `Date` is emitted only when all three segments are set and valid;
+ * the day is clamped to the month's length (e.g. Feb 31 → 28/29) and the
+ * result is clamped to `[min, max]`.
+ *
+ * ```html
+ * <mk-mini-date [(value)]="date" order="dmy" [min]="minDate" />
+ * ```
+ */
+declare class MkMiniDate implements ControlValueAccessor, Validator {
+    private readonly field;
+    protected readonly i18n: _mk_kit_ui_core.MkI18nStrings;
+    private readonly segEls;
+    /** Minimum selectable date (inclusive). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Maximum selectable date (inclusive). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Two-way value — a real `Date`, or `null` while incomplete. */
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    /** 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>;
+    /** Segment order. */
+    readonly order: _angular_core.InputSignal<MkMiniDateOrder>;
+    /** Lowest selectable year (for the year spinbutton range). */
+    readonly yearMin: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Highest selectable year (for the year spinbutton range). */
+    readonly yearMax: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly segId: string;
+    private readonly daySeg;
+    private readonly monthSeg;
+    private readonly yearSeg;
+    /** Per-segment digit buffer used for OTP-style typing/auto-advance. */
+    private buffer;
+    private bufferKey;
+    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>;
+    /** Days available in the current month/year (defaults to a leap year). */
+    private readonly monthLength;
+    /** Ordered, rendered segment descriptors. */
+    protected readonly parts: _angular_core.Signal<MkDatePart[]>;
+    protected onSegKeydown(key: MkDateSegment, index: number, e: KeyboardEvent): void;
+    protected onSegFocus(key: MkDateSegment): void;
+    protected onBlur(): void;
+    /** A segment's minimum value (Home key). */
+    private segMin;
+    /** A segment's maximum value (End key). */
+    private segMax;
+    /** Step a segment by `delta`; the day wraps within the current month. */
+    protected step(key: MkDateSegment, delta: number): void;
+    /** OTP-style digit entry with auto-advance to the next segment when full. */
+    private typeDigit;
+    /** Set a segment, then rebuild + emit the composite date. */
+    protected setSegment(key: MkDateSegment, value: number | null): void;
+    /**
+     * Rebuild the `Date` from the three segments and emit it. Emits `null` unless
+     * all three are set; clamps the day to the month length and the whole date to
+     * `[min, max]`, writing any clamp back into the segments.
+     */
+    private recompute;
+    private emit;
+    /** Populate the three segments from a `Date`. */
+    private split;
+    private resetBuffer;
+    private focusSeg;
+    private pad;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private readonly validatorChange;
+    /**
+     * Reports `mkMinDate` / `mkMaxDate` against the `[min]` and `[max]` inputs.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MkMiniDate, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MkMiniDate, "mk-mini-date", ["mkMiniDate"], { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "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; }; "order": { "alias": "order"; "required": false; "isSignal": true; }; "yearMin": { "alias": "yearMin"; "required": false; "isSignal": true; }; "yearMax": { "alias": "yearMax"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+export { MkCalendar, MkDatePicker, MkDateRangePicker, MkEventCalendar, MkMiniDate, MkMonthPicker, MkTimePicker, MkWeekPicker, addDays, addMonths, buildMonthMatrix, clampDate, endOfMonth, endOfWeek, formatDate, formatISODate, getISOWeek, getMonthNames, getWeekdayFullName, getWeekdayNames, isAfter, isBefore, isSameDay, isSameMonth, parseISODate, startOfDay, startOfMonth, startOfWeek };
+export type { MkCalendarEvent, MkCalendarEventEdit, MkCalendarView, MkDateRange, MkMiniDateOrder, MkMonthPickerMode, MkWeek, MkWeekday };