import * as _angular_core from '@angular/core';
import { InjectionToken, Signal, Provider } from '@angular/core';
import * as forty_cdk_time_picker from 'forty-cdk/time-picker';
import { FormValueControl } from '@angular/forms/signals';
import { TimeCapableDateAdapter, WritingDirection, CollectionHandle, VetoableNativeEvent, VetoableEvent } from 'forty-cdk/core';
import { FloatingSide, FloatingAlign, ListboxOverlayContext, AnchoredFormValueControlBase, AnchoredPositioningSeedDefaults } from 'forty-cdk/core-overlay';

/** The time granularity at which the picker operates. */
type TimePickerGranularity = 'hour' | 'minute' | 'second';
/**
 * A single generated time slot in the listbox.
 *
 * @typeParam D The adapter's date-time type.
 */
interface ForTimeSlot<D> {
    /** Stable identifier for use as the `track` expression in `@for`. Value is `'slot-' + totalSeconds`. */
    readonly id: string;
    /**
     * The date-time value this slot represents, anchored to a fixed DST-stable
     * sentinel date. The consumer grafts this wall-clock time onto the real
     * selected date at commit time.
     */
    readonly value: D;
    /** Display label formatted via the active adapter and the resolved format options. */
    readonly label: string;
    /** Whether this slot is currently selected, compared at the configured granularity. */
    readonly selected: boolean;
    /** Whether this slot is disabled because its time-of-day falls outside `[minTime, maxTime]`. */
    readonly disabled: boolean;
}
/**
 * Configuration bag for {@link buildTimeSlots}.
 *
 * @typeParam D The adapter's date-time type.
 */
interface BuildTimeSlotsConfig<D> {
    readonly adapter: TimeCapableDateAdapter<D>;
    /** The currently committed value, or `null` when nothing is selected. */
    readonly selected: D | null;
    /** Lower bound (inclusive). Only the time-of-day component is considered. `null` = start-of-day. */
    readonly minTime: D | null;
    /** Upper bound (inclusive). Only the time-of-day component is considered. `null` = end-of-day. */
    readonly maxTime: D | null;
    /** Slot interval in whole minutes. Clamped to ≥ 1. */
    readonly step: number;
    readonly granularity: TimePickerGranularity;
    /** `Intl.DateTimeFormat` options for the slot label. */
    readonly formatOptions: Intl.DateTimeFormatOptions;
    /** BCP 47 locale for the slot label; the runtime default when omitted. */
    readonly locale?: string;
}
/**
 * Generates the full-day slot list for a {@link ForTimePicker}.
 *
 * Slots span the full 24-hour day (00:00:00 up to but not past 24:00). Each slot's
 * `disabled` flag is `true` when its time-of-day falls outside `[minTime, maxTime]`
 * — slots are never omitted, following the WAI-ARIA option convention for disabled
 * items.
 *
 * Every slot value is anchored to a fixed DST-stable sentinel date so wall-clock
 * times never collide on a spring-forward day; the consumer grafts the picked
 * time onto the real selected date at commit.
 *
 * Pure function: no signals, no DOM, no side effects.
 */
declare function buildTimeSlots<D>(config: BuildTimeSlotsConfig<D>): readonly ForTimeSlot<D>[];

/**
 * Why a time picker requested close.
 */
type ForTimePickerCloseReason = 'escape' | 'pointerDownOutside' | 'focusOutside' | 'select' | 'tab' | 'programmatic';
/**
 * Where focus lands when the listbox opens.
 * `'selected'` snaps to the selected slot (or first enabled if none selected).
 */
type ForTimePickerInitialFocus = 'first' | 'last' | 'selected';
/**
 * Handle every `[forTimePickerOption]` registers with the root.
 */
interface ForTimePickerOptionHandle extends CollectionHandle {
    /**
     * Narrowed from {@link CollectionHandle}'s `Node`: the root moves DOM focus
     * onto the option.
     */
    readonly host: HTMLElement;
    readonly value: Signal<unknown>;
    readonly disabled: Signal<boolean>;
}
/**
 * The shared overlay-listbox coordination surface a `[forTimePicker]` exposes on
 * its context (`ctx.overlay`): trigger / anchor / content registries + ids,
 * DOM-focus navigation, the open / close machine, the initial-focus /
 * close-reason state, and the dismiss / auto-focus emit forwarders. Backed by
 * the shared `ListboxOverlayController`, so child directives read it here
 * instead of the root re-forwarding each member.
 */
type ForTimePickerOverlayContext = ListboxOverlayContext<ForTimePickerOptionHandle, ForTimePickerInitialFocus, ForTimePickerCloseReason>;
/**
 * Coordination contract owned by `[forTimePicker]`. The shared overlay-listbox
 * surface (trigger / anchor / content registration, navigation, the open /
 * close machine, dismiss forwarders) is reached through
 * {@link ForTimePickerContext.overlay}.
 *
 * @typeParam D The adapter's date-time type.
 */
interface ForTimePickerContext<D = unknown> {
    /**
     * The selected time, as a read-only signal. Mutate it through `activate` /
     * `commitOnTab` or the root's `[(value)]` binding — a direct write would
     * bypass the disabled / readonly guards and `markTouched`.
     */
    readonly value: Signal<D | null>;
    /**
     * Whether the listbox is open, as a read-only signal. Mutate it through
     * `overlay.toggle` / `overlay.openOverlay` / `overlay.closeOverlay` or the root's
     * `[(open)]` binding.
     */
    readonly open: Signal<boolean>;
    readonly effectiveDisabled: Signal<boolean>;
    readonly readonly: Signal<boolean>;
    readonly required: Signal<boolean>;
    readonly invalid: Signal<boolean>;
    readonly pending: Signal<boolean>;
    readonly modal: Signal<boolean>;
    readonly dismissible: Signal<boolean>;
    readonly returnFocus: Signal<boolean>;
    readonly side: Signal<FloatingSide | undefined>;
    readonly align: Signal<FloatingAlign | undefined>;
    readonly sideOffset: Signal<number>;
    readonly alignOffset: Signal<number>;
    readonly avoidCollisions: Signal<boolean>;
    readonly collisionPadding: Signal<number>;
    readonly sticky: Signal<'partial' | 'always' | false>;
    readonly hideWhenDetached: Signal<boolean>;
    readonly clipUntilPositioned: Signal<boolean>;
    readonly loop: Signal<boolean>;
    readonly orientation: Signal<'horizontal' | 'vertical'>;
    readonly dir: Signal<WritingDirection>;
    readonly placeholder: Signal<string>;
    readonly granularity: Signal<TimePickerGranularity>;
    readonly formattedValue: Signal<string | null>;
    readonly ariaLabel: Signal<string | null>;
    /**
     * The shared overlay-listbox coordination surface (trigger / anchor / content
     * registration + ids, navigation, open / close machine, initial-focus /
     * close-reason state, dismiss + auto-focus emit forwarders). Child directives
     * read the overlay machinery here instead of the root re-forwarding each
     * member; the value-specific behavior below stays on the context directly.
     */
    readonly overlay: ForTimePickerOverlayContext;
    readonly slots: Signal<readonly ForTimeSlot<D>[]>;
    isSelected(value: D): boolean;
    activate(value: D): void;
    focusSelectedOption(): boolean;
    commitOnTab(value: D): void;
    markTouched(): void;
}
/**
 * The time picker's pointer channel: the calls `[forTimePickerOption]` makes so
 * the slot under the cursor takes the highlight, and so the keyboard takes it
 * back when a slot is focused.
 *
 * **Not** part of {@link ForTimePickerContext} and never exported
 * from `public-api.ts` — a consumer styles the pointed-at slot off
 * `data-highlighted`, never by reporting a hover into the root.
 */
interface TimePickerPieceContext {
    /**
     * Host element of the slot the pointer is over, `null` when the pointer is
     * over none. Self-heals on read: a host that has left the registered set or
     * become disabled is discounted, so the focused slot reclaims the highlight.
     */
    readonly pointerHighlightedOption: Signal<HTMLElement | null>;
    /**
     * Reported by `[forTimePickerOption]` on `pointermove` so the highlight
     * follows the pointer. Never moves DOM focus and never selects; a move
     * arriving inside the pointer-suppression window a programmatic scroll opened
     * is ignored, or a scroll sliding a different slot under a stationary cursor
     * would hand the highlight to whatever the user merely scrolled past.
     *
     * @param host The hovered slot's host element.
     */
    highlightFromPointer(host: HTMLElement): void;
    /**
     * Called by a slot when it takes DOM focus: drops any pointer highlight, so
     * the keyboard channel owns the highlight again from the move that focused the
     * slot.
     */
    notifyOptionFocus(): void;
    /**
     * Called by `[forTimePickerContent]` when the pointer leaves the listbox
     * surface: drops any pointer highlight, so the focused slot reclaims it
     * instead of a row staying decorated with the cursor elsewhere on the page.
     * Crossing between two adjacent slots is not a leave, so the highlight never
     * blinks off.
     */
    releasePointerHighlight(): void;
}
/**
 * The time picker's internal coordination surface: everything
 * {@link ForTimePickerContext} publishes plus the {@link TimePickerPieceContext}
 * calls.
 *
 * Never exported from `public-api.ts`. It is the type the pieces read
 * {@link FOR_TIME_PICKER_CONTEXT} at, so a consumer who injects that token gets
 * the read surface while `[forTimePickerOption]` gets the pointer channel.
 * `ForTimePicker` declares those members TS-`private`, which keeps them out of
 * the emitted `.d.ts` while `useExisting` still satisfies this contract at
 * runtime.
 */
interface TimePickerContext<D = unknown> extends ForTimePickerContext<D>, TimePickerPieceContext {
}
/**
 * DI token for the time picker's coordination surface, provided by
 * `[forTimePicker]`.
 *
 * Publicly typed as the read surface {@link ForTimePickerContext}, which is the
 * whole of what the token promises a consumer. The pieces read the same token at
 * an internal type that adds the pointer-highlight channel, so a wrapper
 * re-providing it must alias it to the root:
 * `{ provide: FOR_TIME_PICKER_CONTEXT, useExisting: MyTimePicker }`, where
 * `MyTimePicker` extends `ForTimePicker`. A value that merely satisfies the
 * declared type resolves too, and is rejected in dev mode by the first piece to
 * reach the channel.
 */
declare const FOR_TIME_PICKER_CONTEXT: InjectionToken<ForTimePickerContext<unknown>>;

/**
 * Root of the headless time picker, implementing the
 * [WAI-ARIA Listbox pattern](https://www.w3.org/WAI/ARIA/apg/patterns/listbox/)
 * for a slot-based time selection. Generates a full-day list of time slots at
 * a configurable `step` (in minutes), displayed in a floating listbox.
 *
 * Implements `FormValueControl<D | null>` from `@angular/forms/signals` for
 * `[formField]` auto-wiring. Requires a time-capable adapter
 * (`provideNativeDateAdapter()` or `provideInternationalizedDateTimeAdapter()`).
 *
 * @typeParam D The adapter's immutable date-time type.
 */
declare class ForTimePicker<D> extends AnchoredFormValueControlBase implements FormValueControl<D | null>, ForTimePickerContext<D> {
    #private;
    protected readonly positioningDefaults: forty_cdk_time_picker.ForTimePickerDefaults;
    /**
     * The active, time-capable date adapter. Throws when the provided adapter is
     * day-only.
     */
    readonly adapter: TimeCapableDateAdapter<D>;
    /**
     * Two-way bindable selected time, or `null`. Required by
     * `FormValueControl<D | null>`. The `model()` change emitter
     * (`(valueChange)`) fires only on internal selection changes, never on
     * consumer writes via `[(value)]`.
     */
    readonly value: _angular_core.ModelSignal<D | null>;
    /**
     * Two-way bindable. Whether the listbox is currently shown. The `model()`
     * change emitter (`(openChange)`) fires only on internal transitions, never
     * on consumer writes via `[(open)]`.
     */
    readonly open: _angular_core.ModelSignal<boolean>;
    /**
     * Earliest selectable time-of-day (inclusive). Slots earlier in the day are
     * disabled. Named `minTime` (not `min`) because `FormUiControl.min` is
     * reserved for a numeric validator.
     */
    readonly minTime: _angular_core.InputSignal<D | null>;
    /**
     * Latest selectable time-of-day (inclusive). Slots later in the day are
     * disabled. Named `maxTime` for the same reason as {@link minTime}.
     */
    readonly maxTime: _angular_core.InputSignal<D | null>;
    /**
     * Slot interval in whole minutes. Default `30`, clamped to ≥ 1. Use `60` for
     * hourly slots, `15` for quarter-hour slots.
     */
    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
    /**
     * Finest time unit compared when determining if a slot is selected.
     * Default `'minute'`. Use `'second'` when the value carries seconds.
     */
    readonly granularity: _angular_core.InputSignal<TimePickerGranularity>;
    /**
     * 12- or 24-hour cycle for slot label formatting. When `null` (default) it
     * is derived from the runtime locale.
     */
    readonly hourCycle: _angular_core.InputSignal<12 | 24 | null>;
    /**
     * BCP 47 locale driving slot label formatting. Defaults to the runtime locale.
     */
    readonly locale: _angular_core.InputSignal<string | null>;
    /**
     * Close the listbox after a slot is selected. Default `true`.
     */
    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * When `true`, the listbox mounts as a trapped / inert / scroll-locked modal
     * surface instead of the default anchored popover. Read once when the content
     * mounts.
     */
    readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** When `true` (default), Escape, pointer-down outside, and focus outside close the listbox. */
    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** When `true` (default), focus returns to the trigger on close. */
    readonly returnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Placeholder shown by `[forTimePickerValue]` when no time is selected. */
    readonly placeholder: _angular_core.InputSignal<string>;
    /**
     * `Intl.DateTimeFormat` options driving slot label formatting. When none of
     * `hour` / `minute` / `second` are specified, sensible defaults are filled in
     * automatically based on `granularity` and `hourCycle`.
     */
    readonly formatOptions: _angular_core.InputSignal<Intl.DateTimeFormatOptions>;
    /** Manual `aria-label` on `[forTimePickerContent]` when the trigger isn't a meaningful name. */
    readonly ariaLabel: _angular_core.InputSignal<string | null>;
    /** When `true` (default), keyboard navigation wraps at the ends of the option list. */
    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Orientation of the listbox for keyboard navigation. Default `'vertical'`. */
    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
    /**
     * Writing direction. When unset (default `null`), the inherited ambient
     * direction is resolved from the nearest ancestor carrying a `dir` attribute
     * (or `<html dir>`), defaulting to `'ltr'`. An explicit `[dir]` always wins.
     */
    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
    readonly dir: _angular_core.Signal<WritingDirection>;
    /**
     * Fires when the user presses Escape while this listbox is the topmost
     * dismissible layer. Call `preventDefault()` on the veto to suppress the
     * automatic close.
     */
    readonly escapeKeyDown: _angular_core.OutputEmitterRef<VetoableNativeEvent<KeyboardEvent>>;
    /** Fires when a pointer goes down outside the listbox. Vetoable. */
    readonly pointerDownOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent>>;
    /** Fires when focus moves outside the listbox. Vetoable. */
    readonly focusOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<FocusEvent>>;
    /** Composite event: shares veto state with `pointerDownOutside` / `focusOutside`. */
    readonly interactOutside: _angular_core.OutputEmitterRef<VetoableNativeEvent<PointerEvent | FocusEvent>>;
    /**
     * Fires just before the listbox sends focus to the selected slot (or first
     * enabled) on open. Call `preventDefault()` on the veto to skip the focus
     * move.
     */
    readonly autoFocusOnOpen: _angular_core.OutputEmitterRef<VetoableEvent>;
    /**
     * Fires just before focus returns to the trigger on close. Call
     * `preventDefault()` on the veto to suppress the return-focus.
     */
    readonly autoFocusOnClose: _angular_core.OutputEmitterRef<VetoableEvent>;
    /**
     * The shared overlay-listbox coordination surface (trigger / anchor / content
     * registration + ids, DOM-focus navigation, the open / close machine, the
     * initial-focus / close-reason state, and the dismiss + auto-focus emit
     * forwarders). Exposed on the context so child directives read the overlay
     * machinery here rather than through the root. The optional
     * `[forTimePickerAnchor]` (reached via `overlay.anchor`) is preferred when
     * registered, otherwise floating-ui falls back to the trigger.
     */
    readonly overlay: ForTimePickerOverlayContext;
    private readonly pointerHighlightedOption;
    /**
     * The generated list of time slots for the full day. Each slot's `value` is
     * anchored to a fixed DST-stable sentinel date; `activate` grafts the picked
     * wall-clock onto the current `value()` date, so selecting a slot preserves
     * the calendar date when used inside a date-time picker.
     *
     * Pure derivation — never written from inside an `effect()`.
     */
    readonly slots: _angular_core.Signal<readonly ForTimeSlot<D>[]>;
    /** Formatted display of the current value, or `null` when empty. */
    readonly formattedValue: _angular_core.Signal<string | null>;
    protected fieldLabelledElement(): HTMLElement | null;
    protected fieldLabelledElementId(): string;
    /**
     * Move focus to the trigger, implementing `FormValueControl.focus` from
     * `@angular/forms/signals`. Without this override Signal Forms would focus the
     * host `[forTimePicker]` wrapper — which carries no focusable role — so
     * focus-on-error would silently go nowhere. No-op when disabled or before the
     * trigger has registered.
     */
    focus(options?: FocusOptions): void;
    constructor();
    isSelected(v: D): boolean;
    activate(v: D): void;
    focusSelectedOption(): boolean;
    private highlightFromPointer;
    private notifyOptionFocus;
    private releasePointerHighlight;
    commitOnTab(value: D): void;
    markTouched(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTimePicker<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePicker<any>, "[forTimePicker]", ["forTimePicker"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "minTime": { "alias": "minTime"; "required": false; "isSignal": true; }; "maxTime": { "alias": "maxTime"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "formatOptions": { "alias": "formatOptions"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "open": "openChange"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "autoFocusOnOpen": "autoFocusOnOpen"; "autoFocusOnClose": "autoFocusOnClose"; }, never, never, true, never>;
}

/**
 * Optional positioning anchor. When present, `[forTimePickerContent]` is
 * positioned against this element instead of `[forTimePickerTrigger]` — useful
 * when the trigger lives inside a decorated field box (padding, prefix icon,
 * clear / chevron buttons) and the listbox should align to the visible field
 * rather than the inner button.
 *
 * Only positioning changes: the trigger still owns `aria-controls`,
 * `aria-expanded`, the click toggle, focus return on close, and its exemption
 * from outside-pointer dismissal. If no anchor is registered the listbox falls
 * back to anchoring against the trigger, so existing usages are unaffected.
 *
 * At most one `[forTimePickerAnchor]` may be registered per `[forTimePicker]`;
 * a second one throws.
 *
 * ```html
 * <div forTimePicker [(value)]="time">
 *   <div forTimePickerAnchor class="field-box">
 *     <icon />
 *     <button forTimePickerTrigger><span forTimePickerValue>…</span></button>
 *     <button class="clear">×</button>
 *   </div>
 *   @if (open()) {
 *     <div forTimePickerContent>…</div>
 *   }
 * </div>
 * ```
 */
declare class ForTimePickerAnchor {
    #private;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTimePickerAnchor, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePickerAnchor, "[forTimePickerAnchor]", ["forTimePickerAnchor"], {}, {}, never, never, true, never>;
}

/**
 * Combobox button that opens the time picker listbox. Apply on a `<button>` so
 * Space / Enter dispatch native click events that toggle via `(click)`.
 *
 * Wires APG select-only combobox attributes: `role="combobox"`,
 * `aria-haspopup="listbox"`, `aria-expanded`, and `aria-controls` pointing to
 * the listbox. The button is exempt from the listbox's dismissible layer so
 * clicks on it toggle without dismissal racing.
 *
 * Disabling: the native `disabled` attribute is the single reflection channel
 * — no `aria-disabled` is emitted, because on a real single-purpose `<button>`
 * trigger the native attribute already conveys the state to assistive
 * technology, and it is what suppresses activation here. The
 * `role="combobox"` override does not change that: the HTML `disabled`
 * attribute maps to the unavailable state regardless of the ARIA role. It is
 * reflected non-destructively — the directive only removes the attribute when
 * it set it itself — and `data-disabled=""` stays as the styling hook. The
 * remaining form-control state (`aria-readonly` / `aria-required` /
 * `aria-invalid` / `aria-busy`) is unaffected, and the read-only state carries
 * its own `data-readonly=""` styling hook — `readonly` is not a valid attribute
 * of `<button>`, so a `data-*` channel is the only one available there.
 *
 * Keyboard:
 * - **Click / Enter / Space** — toggle (open focuses the selected slot, or first).
 * - **ArrowDown** — open + focus selected slot (or first).
 * - **ArrowUp** — open + focus selected slot (or last when none selected).
 */
declare class ForTimePickerTrigger<D = unknown> {
    #private;
    protected readonly buttonType: _angular_core.Signal<string | null>;
    /**
     * Optional explicit reference to the `[forTimePicker]` root, named after the
     * selector `routerLink`-style. The bare valueless attribute keeps resolving
     * the enclosing root via DI; pass the root explicitly
     * (`[forTimePickerTrigger]="root"`, with `#root="forTimePicker"`) when the
     * trigger is declared in an `ng-template` stamped inside the root.
     */
    readonly forTimePickerTrigger: _angular_core.InputSignal<"" | ForTimePickerContext<D>>;
    protected readonly ctx: _angular_core.Signal<ForTimePickerContext<D>>;
    constructor();
    protected onClick(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    protected onFocusOut(event: FocusEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTimePickerTrigger<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePickerTrigger<any>, "[forTimePickerTrigger]", ["forTimePickerTrigger"], { "forTimePickerTrigger": { "alias": "forTimePickerTrigger"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Renders the currently selected time slot's label — or the configured
 * placeholder when nothing is selected — into its host element via
 * `textContent`. Apply on a `<span>` (or any inline element) inside
 * `[forTimePickerTrigger]`:
 *
 * ```html
 * <button forTimePickerTrigger>
 *   <span forTimePickerValue placeholder="Select a time…"></span>
 * </button>
 * ```
 */
declare class ForTimePickerValue {
    #private;
    /** Text shown when nothing is selected. Falls back to `[forTimePicker][placeholder]`. */
    readonly placeholder: _angular_core.InputSignal<string>;
    protected readonly isPlaceholder: _angular_core.Signal<boolean>;
    protected readonly displayText: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTimePickerValue, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePickerValue, "[forTimePickerValue]", ["forTimePickerValue"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * The listbox surface of the time picker. Carries `role="listbox"`, is
 * portaled to `document.body`, and is positioned by `@floating-ui/dom`
 * against the trigger.
 *
 * Mount/unmount of the visible content is the consumer's responsibility —
 * wrap with `@if (open())` so `animate.enter` / `animate.leave` fire on the
 * natural mount cycle. While mounted it dismisses on Escape, pointer-down
 * outside or focus outside; the trigger element is exempt from outside-pointer
 * checks so trigger clicks toggle without dismissal racing.
 *
 * Initial focus is sent to the selected slot (`'selected'`), the first
 * enabled slot (`'first'`), or the last enabled slot (`'last'`) according to
 * the trigger's hint. On destroy, focus returns to the trigger when
 * `returnFocus` is true.
 *
 * In modal mode, modality is conveyed behaviorally — by the `inert` siblings
 * the shell applies — and reflected as `data-modal` for styling. `aria-modal`
 * is not emitted: `role="listbox"` does not support it, so the
 * attribute would be an `aria-allowed-attr` violation that announces nothing.
 */
declare class ForTimePickerContent {
    #private;
    protected readonly ctx: TimePickerContext<unknown>;
    protected readonly resolvedAriaLabel: _angular_core.Signal<string | null>;
    protected readonly labelledBy: _angular_core.Signal<string | null>;
    constructor();
    protected onPointerLeave(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTimePickerContent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePickerContent, "[forTimePickerContent]", ["forTimePickerContent"], {}, {}, never, never, true, never>;
}

/**
 * One option inside a `[forTimePickerContent]`. Apply on a `<div>` (or any
 * non-button element) — the option handles Enter/Space activation itself in its
 * keydown handler because a `<div>` has no native keyboard click.
 *
 * @typeParam D The adapter's date-time type (inferred from `[value]`).
 *
 * Hovering an enabled slot hands it `data-highlighted`, so pointer and keyboard
 * feed one highlight and exactly one slot is ever decorated. Hover never moves
 * DOM focus and never selects — the pointer's own click activates — and moving
 * the pointer off `[forTimePickerContent]` hands the highlight back to the
 * focused slot.
 *
 * Keyboard while focused:
 * - **Enter / Space** — activate (select the slot).
 * - **ArrowDown / ArrowUp / Home / End** — move focus inside the listbox.
 * - **Tab / Shift+Tab** — commit the focused slot and let the browser advance
 *   focus to the next / previous focusable.
 * - **Escape** — routed through the content's keydown to close the listbox.
 */
declare class ForTimePickerOption<D = unknown> {
    #private;
    /**
     * The date-time value this option represents. Provided by the parent
     * `[forTimePicker]`'s `slots()` computed.
     */
    readonly value: _angular_core.InputSignal<D>;
    /** When `true`, this option cannot be selected. */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly id: _angular_core.Signal<string>;
    readonly selected: _angular_core.Signal<boolean>;
    readonly effectiveDisabled: _angular_core.Signal<boolean>;
    /**
     * True when this slot is the active candidate — the one the pointer is over,
     * else the DOM-focused one. Reflected as `data-highlighted`.
     */
    readonly highlighted: _angular_core.Signal<boolean>;
    constructor();
    protected onClick(): void;
    protected onFocus(): void;
    protected onBlur(): void;
    protected onPointerMove(): void;
    protected onKeyDown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForTimePickerOption<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForTimePickerOption<any>, "[forTimePickerOption]", ["forTimePickerOption"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Defaults inherited by descendant time pickers in the surrounding injector
 * scope. Configure with `provideForTimePickerDefaults` either at the
 * application root or in any component's `providers` array; partial overrides
 * merge with the parent scope.
 */
interface ForTimePickerDefaults extends AnchoredPositioningSeedDefaults {
    /**
     * Side the listbox is anchored to for time pickers that don't override
     * `side` locally. Library fallback `'bottom'`.
     */
    side: FloatingSide;
    /**
     * Alignment along the chosen `side` for time pickers that don't override
     * `align` locally. Library fallback `'start'`.
     */
    align: FloatingAlign;
    /**
     * Distance (px) between the time picker trigger and the floating content
     * along the resolved `side` axis.
     */
    sideOffset: number;
    /**
     * Padding (px) added to the viewport edges for collision-aware positioning.
     * Higher values keep the floating content further from the edge when
     * `flip` / `shift` runs.
     */
    collisionPadding: number;
}
/** Token holding the resolved time picker defaults for the current scope. */
declare const FOR_TIME_PICKER_DEFAULTS: _angular_core.InjectionToken<ForTimePickerDefaults>;
/**
 * Configures forty-cdk time picker defaults for this injector scope. Partial
 * overrides inherit unspecified keys from the parent scope (or library defaults
 * at the root).
 */
declare function provideForTimePickerDefaults(defaults?: Partial<ForTimePickerDefaults>): Provider[];

/**
 * Exact public names of every `ForTimePicker` input, its models included.
 * Spread it into the `inputs` array of a `hostDirectives` entry so a wrapper
 * component re-exposes the primitive's full surface — the Signal Forms members
 * `[formField]` binds among them — without hand-maintaining the list. Always
 * spread into an inline object literal so the entry is statically analyzable.
 * An anti-drift spec fails when this list no longer matches the directive's
 * actual API.
 *
 * @example
 * ```ts
 * @Component({
 *   selector: 'div[myTimePicker]',
 *   template: '',
 *   hostDirectives: [
 *     {
 *       directive: ForTimePicker,
 *       inputs: [...FOR_TIME_PICKER_HOST_DIRECTIVE_INPUTS],
 *       outputs: [...FOR_TIME_PICKER_HOST_DIRECTIVE_OUTPUTS],
 *     },
 *   ],
 * })
 * export class MyTimePicker {}
 * ```
 */
declare const FOR_TIME_PICKER_HOST_DIRECTIVE_INPUTS: readonly ["value", "open", "align", "alignOffset", "ariaLabel", "avoidCollisions", "clipUntilPositioned", "closeOnSelect", "collisionPadding", "dir", "dirty", "disabled", "dismissible", "errors", "formatOptions", "granularity", "hideWhenDetached", "hourCycle", "invalid", "locale", "loop", "maxTime", "minTime", "modal", "name", "orientation", "pending", "placeholder", "readonly", "required", "returnFocus", "side", "sideOffset", "step", "sticky", "touched"];
/**
 * Exact public names of every `ForTimePicker` output, the Signal Forms `touch`
 * output included. Spread it into the `outputs` array of the same
 * `hostDirectives` entry as {@link FOR_TIME_PICKER_HOST_DIRECTIVE_INPUTS}.
 */
declare const FOR_TIME_PICKER_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "openChange", "escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "autoFocusOnOpen", "autoFocusOnClose", "touchedChange", "touch"];

export { FOR_TIME_PICKER_CONTEXT, FOR_TIME_PICKER_DEFAULTS, FOR_TIME_PICKER_HOST_DIRECTIVE_INPUTS, FOR_TIME_PICKER_HOST_DIRECTIVE_OUTPUTS, ForTimePicker, ForTimePickerAnchor, ForTimePickerContent, ForTimePickerOption, ForTimePickerTrigger, ForTimePickerValue, buildTimeSlots, provideForTimePickerDefaults };
export type { BuildTimeSlotsConfig, ForTimePickerCloseReason, ForTimePickerContext, ForTimePickerDefaults, ForTimePickerInitialFocus, ForTimePickerOptionHandle, ForTimePickerOverlayContext, ForTimeSlot, TimePickerGranularity };