@malva-ui/core 0.1.13 → 0.1.14

package/types/malva-ui-core-tile.d.ts

@@ -0,0 +1,373 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnChanges, OnInit, AfterViewInit, WritableSignal, SimpleChanges } from '@angular/core';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvStructural, MlvTone } from '@malva-ui/cdk/utils';
+import * as i1 from '@malva-ui/cdk/density';
+
+/** Marks a template as the action area rendered in a tile header. */
+declare class MlvTileActions extends MlvStructural {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTileActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvTileActions, "[mlvTileActions]", never, {}, {}, never, never, true, never>;
+}
+
+declare class MlvTileHeader extends MlvStructural {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTileHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvTileHeader, "[mlvTileHeader]", never, {}, {}, never, never, true, never>;
+}
+
+/** Marks a template as the trailing action area rendered in a tile header. */
+declare class MlvTileTrailingActions extends MlvStructural {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTileTrailingActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvTileTrailingActions, "[mlvTileTrailingActions]", never, {}, {}, never, never, true, never>;
+}
+
+interface MlvTileNode<TProps, TAcceptsChildren extends boolean> {
+    readonly id: string;
+    readonly acceptsChildren: TAcceptsChildren;
+    readonly props: TProps;
+}
+interface MlvTileNodeWithChildren<TProps> extends MlvTileNode<TProps, true> {
+    readonly children: readonly MlvTileTreeNode<TProps>[];
+}
+interface MlvTileNodeLeaf<TProps> extends MlvTileNode<TProps, false> {
+    readonly children?: never;
+}
+type MlvTileTreeNode<TProps> = MlvTileNodeWithChildren<TProps> | MlvTileNodeLeaf<TProps>;
+type MlvTilesAccepts<TProps> = (draggedTile: MlvTileTreeNode<TProps>, targetTile: MlvTileNodeWithChildren<TProps>, innerTiles: readonly MlvTileTreeNode<TProps>[]) => boolean;
+type MlvTilesLayout = 'list' | 'grid';
+interface MlvTileMovedEvent {
+    readonly tileId: string;
+    readonly sourceContainerId: string;
+    readonly targetContainerId: string;
+    readonly previousIndex: number;
+    readonly currentIndex: number;
+}
+interface MlvTileMoveRequest {
+    readonly tileId: string;
+    readonly sourceContainerId: string;
+    readonly targetContainerId: string;
+    readonly previousIndex: number;
+    readonly currentIndex: number;
+}
+/** Request consumed by the immutable insert helper and the compound insert APIs. */
+interface MlvTileInsertRequest<TProps> {
+    /** Container that receives the node. */
+    readonly targetContainerId: string;
+    /** Node to insert. Neither it nor any node in its subtree may reuse an existing ID. */
+    readonly tile: MlvTileTreeNode<TProps>;
+    /** Position among the target's direct children. Omitted appends. */
+    readonly index?: number;
+}
+/**
+ * Narrows a tree node to its container form.
+ *
+ * @param node - Any node of a Tile tree.
+ * @returns `true` when the node accepts children, narrowing it to `MlvTileNodeWithChildren`.
+ */
+declare function isMlvTileContainer<TProps>(node: MlvTileTreeNode<TProps>): node is MlvTileNodeWithChildren<TProps>;
+
+type MlvTileTone = MlvTone | 'default';
+declare class MlvTile<TProps = unknown> {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: Signal<_malva_ui_i18n.MlvTileI18n>;
+    /** @private Resolves parameterized accessible names. */
+    private readonly _i18nResolver;
+    private readonly _rtlService;
+    /** Human-readable tile name used by the drag handle and move announcements. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Colors the tile outline with an optional semantic tone. */
+    readonly tone: _angular_core.InputSignal<MlvTileTone>;
+    /** Typed immutable tree item represented by this tile when nested in `mlv-tiles`. */
+    readonly tile: _angular_core.InputSignal<MlvTileTreeNode<TProps> | undefined>;
+    /** Adds the standard close action to the tile header. */
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Adds the built-in drag handle to the tile header. */
+    readonly draggable: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Disables the built-in drag handle without dimming the tile content. */
+    readonly dragDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Freezes this tile: withdraws the drag handle and the standard close action,
+     * makes `remove()` a no-op, and locks any nested `mlv-tiles`. Inherited from
+     * an enclosing locked container; an explicit `false` does not unlock a locked
+     * ancestor. `setProps` and `updateProps` keep working — `locked` is
+     * structural, not data-read-only.
+     */
+    readonly locked: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * De-emphasises the projected body while leaving the header controls at full
+     * contrast. Presentational only: it does not cascade to nested tiles and adds
+     * no ARIA state, because the tile region stays fully interactive.
+     */
+    readonly inactive: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Emits when the user activates the tile's close action. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** @protected Header slot template projected via `[mlvTileHeader]`. */
+    protected readonly headerRef: Signal<MlvTileHeader | undefined>;
+    /** @protected Consumer-owned actions projected via `[mlvTileActions]`. */
+    protected readonly actionsRef: Signal<MlvTileActions | undefined>;
+    /** @protected Consumer-owned trailing actions projected via `[mlvTileTrailingActions]`. */
+    protected readonly trailingActionsRef: Signal<MlvTileTrailingActions | undefined>;
+    /** @private Closest enclosing lock, published by a container or outer tile. */
+    private readonly _inheritedLocked;
+    /**
+     * @internal Resolved lock for this tile, inherited state included. Published
+     * through `MLV_TILE_LOCKED` so nested containers and tiles inherit it.
+     */
+    readonly lockedState: Signal<boolean>;
+    /** @protected Whether this tile renders the standard close action. */
+    protected readonly _hasCloseAction: Signal<boolean>;
+    /** @protected Whether this tile renders its built-in drag handle. */
+    protected readonly _hasDragHandle: Signal<boolean>;
+    /** @protected Only registered compound handles expose keyboard operations. */
+    protected readonly _hasInteractiveDragHandle: Signal<boolean>;
+    /** @private Consumer name or localized generic fallback for assistive text. */
+    private readonly _accessibleLabel;
+    /** @protected Localized accessible drag handle label. */
+    protected readonly _dragHandleLabel: Signal<string>;
+    /** @protected Root-owned keyboard instructions associated with tree handles. */
+    protected readonly _keyboardInstructionsId: Signal<string | null>;
+    /** @private Closest compound container, absent for standalone tiles. */
+    private readonly _container;
+    /** @private Component-scoped cleanup for the marked Sortable wrapper. */
+    private readonly _destroyRef;
+    /** @private Rendered tile host used to resolve the direct list child. */
+    private readonly _elementRef;
+    /** @private Renderer used to mark and clean a consumer-owned wrapper root. */
+    private readonly _renderer;
+    /** @private Stable item ID so immutable prop replacement does not re-register it. */
+    private readonly _tileId;
+    /** @private Direct list child exposed to Sortable without public markup. */
+    private _itemRoot;
+    constructor();
+    /**
+     * Removes this item through the root-owned immutable tree. A locked tile is
+     * structurally frozen, so the call is a no-op that warns in development.
+     */
+    remove(): void;
+    /**
+     * Inserts a node into this tile's container node through the root-owned
+     * immutable tree. Valid only on a tree-bound tile whose node accepts
+     * children.
+     *
+     * @param tile - Node to insert. Neither it nor any node in its subtree may
+     *   reuse an ID that already exists in the tree.
+     * @param index - Position among this node's direct children. Omitted appends;
+     *   a non-integer, negative, or out-of-range index is rejected rather than
+     *   clamped.
+     * @returns `true` when the root tree was replaced, `false` on any rejection.
+     *   Always `false` while the tile is locked.
+     */
+    insertChild(tile: MlvTileTreeNode<TProps>, index?: number): boolean;
+    /** Replaces this item's props through the root-owned immutable tree. */
+    setProps(props: TProps): void;
+    /** Updates this item's props through the root-owned immutable tree. */
+    updateProps(update: (props: TProps) => TProps): void;
+    /** @protected Delegates the documented Alt+Arrow commands to the root tree. */
+    protected _onDragHandleKeydown(event: KeyboardEvent): void;
+    /** @private Marks the direct list child Sortable owns during interaction. */
+    private _configureItemRoot;
+    /** @private Removes the internal class from a prior direct-child wrapper. */
+    private _releaseItemRoot;
+    /** @private Returns a live registered ID or warns only for requested tree work. */
+    private _registeredTileId;
+    /** @private Single development-only channel for rejected tree operations. */
+    private _warnDev;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTile<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvTile<any>, "mlv-tile", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "tile": { "alias": "tile"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; "isSignal": true; }; "locked": { "alias": "locked"; "required": false; "isSignal": true; }; "inactive": { "alias": "inactive"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, ["headerRef", "actionsRef", "trailingActionsRef"], ["*"], true, [{ directive: typeof i1.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}
+
+/** Marks a template as the empty-target prompt rendered by `mlv-tiles`. */
+declare class MlvTilesEmpty extends MlvStructural {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTilesEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MlvTilesEmpty, "[mlvTilesEmpty]", never, {}, {}, never, never, true, never>;
+}
+
+declare function moveMlvTileNode<TProps>(root: MlvTileNodeWithChildren<TProps>, request: MlvTileMoveRequest): MlvTileNodeWithChildren<TProps>;
+declare function insertMlvTileNode<TProps>(root: MlvTileNodeWithChildren<TProps>, request: MlvTileInsertRequest<TProps>): MlvTileNodeWithChildren<TProps>;
+declare function removeMlvTileNode<TProps>(root: MlvTileNodeWithChildren<TProps>, tileId: string): MlvTileNodeWithChildren<TProps>;
+declare function updateMlvTileNodeProps<TProps>(root: MlvTileNodeWithChildren<TProps>, tileId: string, update: (props: TProps) => TProps): MlvTileNodeWithChildren<TProps>;
+
+interface MlvTileDragSession<TProps> {
+    readonly root: MlvTileNodeWithChildren<TProps>;
+    readonly draggedTile: MlvTileTreeNode<TProps>;
+    readonly allowedTargetIds: ReadonlySet<string>;
+    readonly nodeById: ReadonlyMap<string, MlvTileTreeNode<TProps>>;
+    readonly parentById: ReadonlyMap<string, string>;
+}
+declare function createMlvTileDragSession<TProps>(root: MlvTileNodeWithChildren<TProps>, draggedTileId: string, accepts: MlvTilesAccepts<TProps>, lockedTargetIds?: ReadonlySet<string>): MlvTileDragSession<TProps> | null;
+declare function canEnterMlvTileTarget<TProps>(session: MlvTileDragSession<TProps> | null, targetTileId: string): boolean;
+
+interface MlvTileContainerRegistration<TProps> {
+    readonly id: string;
+    readonly depth: number;
+    readonly accepts: MlvTilesAccepts<TProps> | undefined;
+    readonly locked: () => boolean;
+    readonly canEnter: (allowed: boolean) => void;
+}
+interface MlvTileItemRegistration<TProps> {
+    readonly id: string;
+    readonly tile: () => MlvTileTreeNode<TProps>;
+}
+interface MlvTileTreeCoordinatorOptions<TProps> {
+    readonly isRoot: boolean;
+    readonly readRoot: () => MlvTileNodeWithChildren<TProps> | undefined;
+    readonly setRoot: (root: MlvTileNodeWithChildren<TProps>) => void;
+    readonly moved: (event: MlvTileMovedEvent) => void;
+}
+/** @internal Keyboard directions used by the compound Tile components. */
+type MlvTileKeyboardMoveDirection = 'up' | 'down' | 'left' | 'right';
+declare class MlvTileTreeCoordinator<TProps> {
+    private readonly _options;
+    private readonly _containers;
+    private readonly _items;
+    private _activeSession;
+    private _registrationOrder;
+    constructor(_options: MlvTileTreeCoordinatorOptions<TProps>);
+    bindTree(root: MlvTileNodeWithChildren<TProps>): void;
+    start(): MlvTileNodeWithChildren<TProps>;
+    registerContainer(registration: MlvTileContainerRegistration<TProps>): () => void;
+    registerItem(registration: MlvTileItemRegistration<TProps>): () => void;
+    targets(): readonly MlvTileContainerRegistration<TProps>[];
+    item(id: string): MlvTileItemRegistration<TProps> | undefined;
+    activeSession(): MlvTileDragSession<TProps> | null;
+    startDrag(tileId: string): MlvTileDragSession<TProps> | null;
+    endDrag(): void;
+    moveByKeyboard(tileId: string, direction: MlvTileKeyboardMoveDirection): MlvTileMoveRequest | null;
+    move(request: MlvTileMoveRequest): boolean;
+    insert(request: MlvTileInsertRequest<TProps>): boolean;
+    remove(tileId: string): boolean;
+    /**
+     * @internal Whether a node is structurally frozen: it is itself a locked
+     * container, or it sits directly inside one. Reads the same locked set the
+     * drag session uses, so an unlocked container cannot reach into a locked
+     * subtree by ID.
+     */
+    isLocked(tileId: string): boolean;
+    updateProps(tileId: string, update: (props: TProps) => TProps): boolean;
+    /** @private Resolves the structural lock for one node against the cached set. */
+    private _isLockedNode;
+    private _createPolicyIndex;
+    private _retain;
+    private _release;
+}
+
+type MlvTilesDropState = 'idle' | 'valid' | 'invalid';
+declare class MlvTiles<TProps> implements OnChanges, OnInit, AfterViewInit {
+    /** Root-owned immutable tree. Nested containers inherit this binding. */
+    readonly tree: _angular_core.ModelSignal<MlvTileNodeWithChildren<TProps> | undefined>;
+    /** Controls the projected tile layout. */
+    readonly layout: _angular_core.InputSignal<MlvTilesLayout>;
+    /** Optionally overrides the inherited acceptance policy for this subtree. */
+    readonly accepts: _angular_core.InputSignal<MlvTilesAccepts<TProps> | undefined>;
+    /**
+     * Freezes this container and its entire subtree: no tile can be dropped in,
+     * no descendant tile can be picked up, and built-in structural affordances
+     * are withdrawn. Cascades to nested `mlv-tiles` and `mlv-tile`. Evaluated
+     * before `accepts`, so an acceptance policy cannot re-open a locked target.
+     */
+    readonly locked: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Overrides the localized empty-target prompt with a plain string. A
+     * projected `[mlvTilesEmpty]` template takes precedence over this input.
+     */
+    readonly emptyLabel: _angular_core.InputSignal<string | undefined>;
+    /** Emits after the root tree has been replaced by a successful move. */
+    readonly moved: _angular_core.OutputEmitterRef<MlvTileMovedEvent>;
+    /** Current cached acceptance state for this rendered target. */
+    readonly dropState: WritableSignal<MlvTilesDropState>;
+    /** @protected Consumer-owned empty state projected via `[mlvTilesEmpty]`. */
+    protected readonly emptyRef: Signal<MlvTilesEmpty | undefined>;
+    private readonly _parentTiles;
+    /** @private Closest enclosing lock, published by a tile or outer container. */
+    private readonly _inheritedLocked;
+    /**
+     * @internal Resolved lock for this level, inherited state included. Published
+     * through `MLV_TILE_LOCKED` so every descendant container and tile sees it.
+     */
+    readonly lockedState: Signal<boolean>;
+    private readonly _itemContext;
+    private readonly _destroyRef;
+    private readonly _elementRef;
+    private readonly _ngZone;
+    private readonly _platformId;
+    /** @protected Localized keyboard instructions rendered by the root list. */
+    protected readonly _i18n: Signal<_malva_ui_i18n.MlvTileI18n>;
+    private readonly _i18nResolver;
+    private readonly _rootTiles;
+    private readonly _groupName;
+    /** @protected Root-only assistive text is projected once per compound tree. */
+    protected readonly _isRoot: boolean;
+    /** @protected Polite keyboard movement feedback shared by nested lists. */
+    protected readonly _keyboardAnnouncement: WritableSignal<string>;
+    private _announcementSequence;
+    private _sortable;
+    private _activeDrag;
+    /** @private Current container node represented by this rendered list. */
+    private readonly _target;
+    /** @internal Shared root coordinator used by all nested containers. */
+    readonly coordinator: MlvTileTreeCoordinator<TProps>;
+    /** @internal Compound nesting depth used for target registration order. */
+    readonly depth: number;
+    /** Stable target ID derived from the root or the enclosing item context. */
+    readonly targetId: Signal<string | undefined>;
+    /** Whether this target currently has no direct child tiles. */
+    readonly isEmpty: Signal<boolean>;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /** @internal Resolves the direct consumer wrapper Sortable may animate. */
+    resolveItemRoot(tileHost: HTMLElement): HTMLElement;
+    /**
+     * Inserts a node into this container through the root-owned immutable tree.
+     *
+     * @param tile - Node to insert. Neither it nor any node in its subtree may
+     *   reuse an ID that already exists in the tree.
+     * @param index - Position among this container's direct children. Omitted
+     *   appends; a non-integer, negative, or out-of-range index is rejected
+     *   rather than clamped.
+     * @returns `true` when the root tree was replaced, `false` on any rejection.
+     *   Always `false` while this container is locked.
+     */
+    insert(tile: MlvTileTreeNode<TProps>, index?: number): boolean;
+    /**
+     * Removes a registered item from this compound tree through the root-owned
+     * immutable tree.
+     *
+     * @param tileId - Stable ID of the node to remove.
+     * @returns `true` when the root tree was replaced, `false` on any rejection.
+     *   Always `false` when the node — or the container holding it — is locked,
+     *   so an unlocked container cannot reach into a locked subtree by ID.
+     */
+    remove(tileId: string): boolean;
+    /** @internal Updates a registered item's props through the root immutable tree. */
+    updateProps(tileId: string, update: (props: TProps) => TProps): void;
+    /** @internal Associates every tree handle with one discoverable instruction. */
+    keyboardInstructionsId(): string;
+    /** @internal Executes and announces a stable-ID keyboard tree operation. */
+    moveByKeyboard(tileId: string, direction: MlvTileKeyboardMoveDirection, label: string): void;
+    private _sortableOptions;
+    private _sanitizeClone;
+    private _startSortableDrag;
+    private _endSortableDrag;
+    private _cancelActiveDrag;
+    private _restoreSortableItem;
+    private _cleanupSortableItem;
+    private _canRestoreSortableItem;
+    private _isActiveDragFresh;
+    private _announceKeyboardMove;
+    private _restoreKeyboardFocus;
+    private _restoreAttribute;
+    private _canReceive;
+    private _canMove;
+    private _eventTargetTiles;
+    private _draggableIndex;
+    /** @private Single development-only channel for rejected tree operations. */
+    private _warnDev;
+    private _prefersReducedMotion;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTiles<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvTiles<any>, "mlv-tiles", never, { "tree": { "alias": "tree"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "accepts": { "alias": "accepts"; "required": false; "isSignal": true; }; "locked": { "alias": "locked"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; }, { "tree": "treeChange"; "moved": "moved"; }, ["emptyRef"], ["*"], true, never>;
+}
+
+export { MlvTile, MlvTileActions, MlvTileHeader, MlvTileTrailingActions, MlvTiles, MlvTilesEmpty, canEnterMlvTileTarget, createMlvTileDragSession, insertMlvTileNode, isMlvTileContainer, moveMlvTileNode, removeMlvTileNode, updateMlvTileNodeProps };
+export type { MlvTileDragSession, MlvTileInsertRequest, MlvTileMoveRequest, MlvTileMovedEvent, MlvTileNode, MlvTileNodeLeaf, MlvTileNodeWithChildren, MlvTileTone, MlvTileTreeNode, MlvTilesAccepts, MlvTilesDropState, MlvTilesLayout };

package/types/malva-ui-core-time-picker.d.ts

@@ -0,0 +1,141 @@
+import * as _malva_ui_cdk_density from '@malva-ui/cdk/density';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvSignalFormControlBase, MlvFormControl, MlvFormState } from '@malva-ui/core/form-utils';
+
+/**
+ * Clock mode — 24-hour or 12-hour (AM/PM).
+ */
+type MlvTimeMode = '24h' | '12h';
+/**
+ * Visual/validation state of the time picker. Mirrors {@link MlvFormState}.
+ */
+type MlvTimePickerState = MlvFormState;
+/**
+ * Time picker component (`mlv-time-picker`) that allows users to select a time
+ * value using a compact trigger that opens a floating popup with scrollable
+ * drum-roll columns. Supports 24h and 12h (AM/PM) modes, optional seconds
+ * display, and integrates with signal, reactive, and template-driven forms.
+ *
+ * Emits values as `HH:mm` (24h format) or `HH:mm:ss` when `showSeconds` is true.
+ * In 12h mode the emitted value is still in 24h format internally.
+ */
+declare class MlvTimePicker extends MlvSignalFormControlBase<string> implements MlvFormControl {
+    /** The `HH:mm`/`HH:mm:ss` value used by all Angular forms APIs. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /**
+     * Clock mode — `'24h'` for 24-hour display (default) or `'12h'` for AM/PM.
+     */
+    readonly mode: _angular_core.InputSignal<MlvTimeMode>;
+    /**
+     * When `true`, shows a seconds column in addition to hours and minutes.
+     */
+    readonly showSeconds: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: Signal<_malva_ui_i18n.MlvTimePickerI18n>;
+    /** @protected Resolved aria-label: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedAriaLabel: Signal<string>;
+    /** @private Whether the time selection popup is open. */
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** @private Internal signal for the selected hour (0–23 in 24h mode; 1–12 in 12h mode). */
+    protected readonly _hour: _angular_core.WritableSignal<number>;
+    /** @private Internal signal for the selected minute (0–59). */
+    protected readonly _minute: _angular_core.WritableSignal<number>;
+    /** @private Internal signal for the selected second (0–59). */
+    protected readonly _second: _angular_core.WritableSignal<number>;
+    /** @private AM/PM period — `'AM'` or `'PM'`. Only relevant in 12h mode. */
+    protected readonly _period: _angular_core.WritableSignal<"AM" | "PM">;
+    /** Unique ID for the message element, used for aria-describedby linking. */
+    /** Unique ID for the popup panel, used for aria-controls linking. */
+    readonly panelId: Signal<string>;
+    /** Override focused to also be true when the popup is open. */
+    readonly focused: Signal<boolean>;
+    /** @protected Formatted display value shown in the trigger. */
+    protected readonly _displayValue: Signal<string>;
+    /** @protected Hour items for the column — depends on mode. */
+    protected readonly _hourItems: Signal<number[]>;
+    /** @protected Minute items for the column (0–59). */
+    protected readonly _minuteItems: Signal<number[]>;
+    /** @protected Second items for the column (0–59). */
+    protected readonly _secondItems: Signal<number[]>;
+    /** @protected The hour value shown in the column (1–12 in 12h mode, 0–23 in 24h). */
+    protected readonly _displayHour: Signal<number>;
+    /** @private Reference to the trigger element for focus restoration after popup close. */
+    private readonly _triggerRef;
+    /**
+     * @private The rendered drum-roll columns (hours, minutes, optional seconds),
+     * in DOM order. They are `mlv-time-picker-column` children declared in this
+     * component's own template (inside `mlvPopupContent`), so a signal view query
+     * resolves them — even though the popup content renders in a detached overlay.
+     * Used for focus-on-open and inter-column Arrow navigation instead of reaching
+     * into the overlay DOM by class name.
+     */
+    private readonly _columns;
+    /** @private Normalizes horizontal column navigation for RTL layouts. */
+    private readonly _rtlService;
+    /** @private Density directive instance for reading the resolved density level. */
+    private readonly _densityDirective;
+    /** @protected Effective density to pass to the detached popup panel. */
+    protected readonly _effectiveDensity: Signal<_malva_ui_cdk_density.MlvDensity>;
+    constructor();
+    /**
+     * @protected Toggle the popup open/closed state.
+     */
+    protected _toggleDropdown(): void;
+    /**
+     * @private Build the time string from internal signals.
+     * Always returns 24h format: `HH:mm` or `HH:mm:ss`.
+     */
+    private _buildValue;
+    /**
+     * @private Parse a time string (`HH:mm` or `HH:mm:ss`) into internal signals.
+     */
+    private _parseValue;
+    /** Whether the control holds a clearable value — The drum always shows a time, so there is always a value. */
+    readonly hasValue: Signal<boolean>;
+    /** @private Synchronizes drum columns from an external model value. */
+    private _applyValue;
+    /**
+     * @protected Called when the popup opens. Focuses the first column listbox
+     * so keyboard navigation is immediately available.
+     */
+    protected _onPopupOpened(): void;
+    /**
+     * @protected Called when the popup closes. Restores focus to the trigger element.
+     */
+    protected _onPopupClosed(): void;
+    /** @protected Marks the control touched when the trigger loses focus. */
+    protected _onTriggerBlur(): void;
+    /**
+     * @protected Handle hour column value change.
+     */
+    protected _onHourChange(value: number): void;
+    /**
+     * @protected Handle minute column value change.
+     */
+    protected _onMinuteChange(value: number): void;
+    /**
+     * @protected Handle second column value change.
+     */
+    protected _onSecondChange(value: number): void;
+    /**
+     * @protected Toggle the AM/PM period in 12h mode.
+     */
+    protected _onPeriodChange(period: 'AM' | 'PM'): void;
+    /**
+     * @protected Handle ArrowLeft/ArrowRight on the columns container to move
+     * focus between column listboxes.
+     */
+    protected _onPanelKeydown(event: KeyboardEvent): void;
+    /**
+     * @private Write the current value to the forms model.
+     */
+    private _emitValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvTimePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvTimePicker, "mlv-time-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof _malva_ui_cdk_density.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}
+
+export { MlvTimePicker };
+export type { MlvTimeMode, MlvTimePickerState };