@cdevhub/ngx-tw 0.2.0

package/types/cdevhub-ngx-tw-textarea.d.ts

@@ -0,0 +1,62 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { TwSize } from '@cdevhub/ngx-tw/core';
+import { InputDirective } from '@cdevhub/ngx-tw/input';
+import * as i1 from '@angular/cdk/text-field';
+
+/**
+ * How the user-resize handle behaves on the textarea. `'vertical'` (the
+ * default) lets users drag the bottom edge to grow the textarea; `'none'`
+ * locks the size; `'both'` allows free resizing on both axes (rarely useful
+ * inside a form-field — the textarea can overflow the wrapper). Horizontal
+ * is intentionally omitted — it breaks form-field layout in practice.
+ */
+type TwTextareaResize = 'none' | 'vertical' | 'both';
+/**
+ * Adapts a native `<textarea>` into an ngx-tw form-field-compatible multi-line
+ * control. Extends {@link InputDirective} — inherits its form-field
+ * integration, error-state machinery, autofill / focus tracking, ARIA wiring,
+ * and standalone styling. Adds textarea-specific behavior: autosize composition
+ * via CDK's `CdkTextareaAutosize`, a `resize` axis for the user-resize handle,
+ * `rows` / `minRows` / `maxRows`, and `maxLength` with a `valueLength` signal
+ * for character counters.
+ *
+ * Like `InputDirective`, this directive deliberately does NOT implement
+ * `ControlValueAccessor`. Angular's built-in `DefaultValueAccessor` attaches to
+ * the native `<textarea>` and handles value I/O for template-driven
+ * (`ngModel`), reactive (`FormControl` / `formControlName`), and signal-forms
+ * (`formField`) bindings — no library glue required.
+ *
+ * Form-control input-cap exception applies (codified in CLAUDE.md): ARIA +
+ * forms baseline plus textarea-specific surface exceeds the 5–6 cap;
+ * `checkbox` is the canonical 12+ exemplar.
+ */
+declare class TextareaDirective extends InputDirective {
+    private readonly cdkAutosize;
+    /** Density of a standalone textarea. Maps to the inline-padding + font scale (`xs` … `xl`). Ignored inside a `<tw-form-field>` — the wrapper's `size` carries density. Defaults to `'md'`. */
+    readonly size: _angular_core.InputSignal<TwSize>;
+    /** Grows the textarea with its content (composed from CDK's `CdkTextareaAutosize`). When `true` the user-resize handle is forced off — autosize owns the height. Defaults to `false`. */
+    readonly autosize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Minimum number of rows the textarea collapses to when `autosize` is `true`. Ignored when autosize is off. Defaults to `1`. */
+    readonly minRows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Maximum number of rows the textarea expands to before scrolling, when `autosize` is `true`. `undefined` removes the cap. Ignored when autosize is off. Defaults to `undefined`. */
+    readonly maxRows: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Number of rows for the initial render height (native `rows` attribute). Browsers honor this even when `autosize` is `true`, so first paint uses this value. Defaults to `3`. */
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Controls the user-resize handle: `'none'` locks the size, `'vertical'` (default) allows vertical drag, `'both'` allows both axes. Forced to `'none'` when `autosize` is `true`. Horizontal-only is intentionally not supported. */
+    readonly resize: _angular_core.InputSignal<TwTextareaResize>;
+    /** Maximum character count. Mirrors to the native `maxlength` attribute when defined and is exposed via the `valueLength` signal so consumers can render a "X / N" hint. Defaults to `undefined`. */
+    readonly maxLength: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Current value length, updates on every `input` event. Wire `<span twHint align="end">{{ ta.valueLength() }} / {{ ta.maxLength() }}</span>` for a character counter. */
+    readonly valueLength: Signal<number>;
+    /** @internal Textarea-specific Tailwind classes (resize axis). Combined with the inherited `classes()` in the host `[class]` binding. */
+    readonly textareaClasses: Signal<string>;
+    constructor();
+    /** Triggers a CDK autosize recalculation. Useful after programmatic value changes that bypass the native `(input)` event (e.g., clipboard write APIs). No-op when `autosize` is `false`. */
+    resizeToFitContent(force?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextareaDirective, "textarea[twTextarea]", ["twTextarea"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "autosize": { "alias": "autosize"; "required": false; "isSignal": true; }; "minRows": { "alias": "minRows"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "resize": { "alias": "resize"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkTextareaAutosize; inputs: { "cdkAutosizeMinRows": "minRows"; "cdkAutosizeMaxRows": "maxRows"; }; outputs: {}; }]>;
+}
+
+export { TextareaDirective };
+export type { TwTextareaResize };

package/types/cdevhub-ngx-tw-theme.d.ts

@@ -0,0 +1,106 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, InjectionToken, EnvironmentProviders } from '@angular/core';
+
+/** The user-selectable theme. `'system'` defers to the OS `prefers-color-scheme` setting. */
+type TwTheme = 'light' | 'dark' | 'high-contrast' | 'system';
+/** The theme actually applied to the DOM after resolving `'system'` against the OS preference. */
+type TwResolvedTheme = 'light' | 'dark' | 'high-contrast';
+/** Ordered list of every {@link TwTheme} value, used by `cycleTheme()` and for UI iteration. */
+declare const TW_THEMES: readonly ["light", "dark", "high-contrast", "system"];
+/** Ordered list of every {@link TwResolvedTheme} value (i.e. {@link TW_THEMES} minus `'system'`). */
+declare const TW_RESOLVED_THEMES: readonly ["light", "dark", "high-contrast"];
+/** Runtime configuration for {@link provideTheme}; controls storage, attribute name, target element, and default. */
+interface TwThemeConfig {
+    /** The default theme when no preference is stored. Defaults to `'system'`. */
+    defaultTheme: TwTheme;
+    /** localStorage key for persisting theme preference. Defaults to `'ngx-tw-theme'`. */
+    storageKey: string;
+    /** The HTML attribute written to the target element. Defaults to `'data-theme'`. */
+    attribute: string;
+    /** Which element receives the theme attribute. Defaults to `'documentElement'`. */
+    target: 'documentElement' | 'body';
+}
+/** Composite snapshot of `ThemeService` state — selected, resolved, system, and boolean flags. */
+interface TwThemeState {
+    /** The user-selected theme — may be `'system'`. */
+    readonly theme: TwTheme;
+    /** The theme actually applied to the DOM — never `'system'`. */
+    readonly resolvedTheme: TwResolvedTheme;
+    /** The OS color-scheme preference detected via `prefers-color-scheme`. */
+    readonly systemTheme: TwResolvedTheme;
+    /** True when {@link resolvedTheme} is `'dark'`. */
+    readonly isDark: boolean;
+    /** True when {@link resolvedTheme} is `'light'`. */
+    readonly isLight: boolean;
+    /** True when {@link resolvedTheme} is `'high-contrast'`. */
+    readonly isHighContrast: boolean;
+}
+/** Built-in defaults merged under any user-provided {@link TwThemeConfig} by `provideTheme()`. */
+declare const DEFAULT_TW_THEME_CONFIG: TwThemeConfig;
+
+/**
+ * Stateful runtime service that owns the active theme, reacts to OS
+ * `prefers-color-scheme` changes, persists the user selection to
+ * `localStorage`, and writes the resolved theme onto the configured DOM
+ * target as a `data-theme` attribute.
+ *
+ * The selected {@link theme} may be `'system'` (defer to the OS); the
+ * {@link resolvedTheme} computed from it is always one of `'light'`,
+ * `'dark'`, or `'high-contrast'` — never `'system'`. Register via
+ * {@link provideTheme} in the app's environment providers.
+ */
+declare class ThemeService implements OnDestroy {
+    private readonly config;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly ngZone;
+    private mediaQuery;
+    private readonly mediaListener;
+    /** The user-selected theme (may be `'system'`). */
+    readonly theme: _angular_core.WritableSignal<TwTheme>;
+    /** The OS color scheme preference. */
+    readonly systemTheme: _angular_core.WritableSignal<TwResolvedTheme>;
+    /** The resolved theme actually applied to the DOM (never `'system'`). */
+    readonly resolvedTheme: _angular_core.Signal<TwResolvedTheme>;
+    /** True when the resolved theme is `'dark'`. */
+    readonly isDark: _angular_core.Signal<boolean>;
+    /** True when the resolved theme is `'light'`. */
+    readonly isLight: _angular_core.Signal<boolean>;
+    /** True when the resolved theme is `'high-contrast'`. */
+    readonly isHighContrast: _angular_core.Signal<boolean>;
+    /** Snapshot of the full theme state — selected, resolved, system, and boolean flags. */
+    readonly state: _angular_core.Signal<TwThemeState>;
+    constructor();
+    /** Sets the selected theme. Pass `'system'` to follow the OS preference. */
+    setTheme(theme: TwTheme): void;
+    /** Advances the selected theme to the next entry in {@link TW_THEMES}, wrapping around. */
+    cycleTheme(): void;
+    /** Writes the configured theme attribute onto an arbitrary element — used to scope themes to a subtree. */
+    applyToElement(element: HTMLElement, theme: TwResolvedTheme): void;
+    ngOnDestroy(): void;
+    private loadInitialTheme;
+    private detectSystemTheme;
+    private applyToDocument;
+    private persistTheme;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare class ThemeDirective {
+    /** Scopes a subtree to a specific resolved theme by writing `data-theme` on the host. Required. */
+    readonly twTheme: _angular_core.InputSignal<TwResolvedTheme>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThemeDirective, "[twTheme]", never, { "twTheme": { "alias": "twTheme"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Injection token carrying the resolved {@link TwThemeConfig} (storage key, attribute, target element, default theme). */
+declare const THEME_CONFIG: InjectionToken<TwThemeConfig>;
+/**
+ * Registers {@link ThemeService} and a {@link THEME_CONFIG} value built by
+ * merging `config` over {@link DEFAULT_TW_THEME_CONFIG}. Call once in the
+ * app's environment providers.
+ */
+declare function provideTheme(config?: Partial<TwThemeConfig>): EnvironmentProviders;
+
+export { DEFAULT_TW_THEME_CONFIG, THEME_CONFIG, TW_RESOLVED_THEMES, TW_THEMES, ThemeDirective, ThemeService, provideTheme };
+export type { TwResolvedTheme, TwTheme, TwThemeConfig, TwThemeState };

package/types/cdevhub-ngx-tw-time-picker.d.ts

@@ -0,0 +1,303 @@
+import * as _angular_core from '@angular/core';
+import { Provider, OnInit, Signal } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { TwSize, TwColor, TimePickerFormat, ErrorStateMatcher, TimePickerMeridiem } from '@cdevhub/ngx-tw/core';
+export { TimePickerFormat, TimePickerMeridiem } from '@cdevhub/ngx-tw/core';
+import { FormFieldControl } from '@cdevhub/ngx-tw/form-field';
+
+/**
+ * Localized strings + ARIA announcements consumed by the time-picker.
+ *
+ * Override per-field via Angular DI — provide a custom instance, or supply a
+ * `Partial<TimePickerIntl>` through `provideTimePickerIntl`. Unset fields
+ * fall through to the English defaults shipped here.
+ *
+ * All members take primitives so consumers can write straight string
+ * literals or template helpers without depending on internal types.
+ */
+declare class TimePickerIntl {
+    /** Accessible name for the fields group (the wrapper around hours/minutes/seconds). */
+    groupLabel: string;
+    /** Accessible name for the hours field. */
+    hoursLabel: string;
+    /** Accessible name for the minutes field. */
+    minutesLabel: string;
+    /** Accessible name for the seconds field. */
+    secondsLabel: string;
+    /** Accessible name for the meridiem (AM/PM) radio group. */
+    meridiemGroupLabel: string;
+    /** Display + accessible name for the AM option. */
+    amLabel: string;
+    /** Display + accessible name for the PM option. */
+    pmLabel: string;
+    /** Aria label template for the up stepper. Receives the active field name (`'hours'`, `'minutes'`, `'seconds'`). */
+    increaseLabel(field: string): string;
+    /** Aria label template for the down stepper. Receives the active field name (`'hours'`, `'minutes'`, `'seconds'`). */
+    decreaseLabel(field: string): string;
+    /** Aria label for the clear button. */
+    clearLabel: string;
+    /** Live-region message announced after the value is cleared. */
+    clearedAnnouncement: string;
+    /** Live-region message after a commit. Receives the pre-formatted time string (e.g. `'02:30 PM'`). */
+    selectedAnnouncement(formattedTime: string): string;
+    /** Spoken text for an empty hour/minute/second field — used as `aria-valuetext` when the field is blank. */
+    emptyValueText: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimePickerIntl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TimePickerIntl>;
+}
+/**
+ * Provides a custom `TimePickerIntl` instance. Place at any injector level —
+ * the time-picker resolves the closest one.
+ *
+ * @example
+ * ```ts
+ * providers: [
+ *   provideTimePickerIntl({
+ *     hoursLabel: 'Heures',
+ *     minutesLabel: 'Minutes',
+ *     meridiemGroupLabel: 'AM ou PM',
+ *   }),
+ * ]
+ * ```
+ */
+declare function provideTimePickerIntl(custom: Partial<TimePickerIntl>): Provider;
+
+/** Visual style of the time-picker chrome. */
+type TimePickerVariant = 'default' | 'naked';
+/** Logical field inside the time-picker. */
+type TimePickerField = 'hour' | 'minute' | 'second' | 'meridiem';
+/** Origin of a value change — useful when consumers need to distinguish user input from programmatic writes. */
+type TimePickerChangeSource = 'input' | 'stepper' | 'meridiem' | 'clear' | 'programmatic';
+/** Emitted by `timeChange` after a committed value update. */
+interface TimePickerChangeEvent<D> {
+    /** The committed value (`null` when cleared). */
+    readonly value: D | null;
+    /** The value before this change. */
+    readonly previousValue: D | null;
+    /** What triggered the change. */
+    readonly source: TimePickerChangeSource;
+}
+/** Emitted by `timeInput` before a commit, on every keystroke or stepper press. */
+interface TimePickerInputEvent<D> {
+    /** Which field was edited. */
+    readonly field: TimePickerField;
+    /** The raw text currently in that field (pre-commit). */
+    readonly rawText: string;
+    /** The parsed value if fields form a valid time, else `null`. */
+    readonly parsed: D | null;
+}
+
+/**
+ * Segmented time editor. Renders `HH : MM` (with an optional `: SS` and/or
+ * `AM/PM` toggle) and integrates with all three Angular form strategies via
+ * `ControlValueAccessor`. Also participates in `<tw-form-field>` through
+ * `FormFieldControl` — wrapping is optional.
+ *
+ * Value type is `D | null`. Every time operation flows through the injected
+ * `DateAdapter<D>`, so the component works with the default native adapter
+ * (`provideNativeDateAdapter()`) or any custom adapter a consumer ships.
+ */
+declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implements ControlValueAccessor, OnInit {
+    /** Id on the time-picker's host element. Auto-generated when not provided. Used by the form-field's `<label for>` attribute. */
+    readonly idInput: _angular_core.InputSignal<string | undefined>;
+    /** When true, the whole component is disabled and every field sets `aria-disabled="true"`. Defaults to `false`. */
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When true, exposes `aria-required="true"`. Validators.required on a bound NgControl is also honoured. Defaults to `false`. */
+    readonly requiredInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When true, blocks typing, stepping, and the AM/PM toggle — the value is still read-only visible. Defaults to `false`. */
+    readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Controls field height, font size, and stepper density. Defaults to `'md'`. */
+    readonly size: _angular_core.InputSignal<TwSize>;
+    /** Semantic color used for the focused border and focus ring. Defaults to `'primary'`. */
+    readonly color: _angular_core.InputSignal<TwColor>;
+    /** Visual style of the chrome. `'default'` draws its own border; `'naked'` strips chrome. Auto-resolves to `'naked'` inside `<tw-form-field>`. */
+    readonly variant: _angular_core.InputSignal<TimePickerVariant | undefined>;
+    /** `'12h'` renders 1–12 hours with an AM/PM toggle; `'24h'` renders 00–23. Defaults to `'24h'`. */
+    readonly format: _angular_core.InputSignal<TimePickerFormat>;
+    /** When true, renders a seconds field after minutes. Defaults to `false`. */
+    readonly showSeconds: _angular_core.InputSignal<boolean>;
+    /** Amount to add/subtract when stepping hours. Defaults to `1`. */
+    readonly hourStep: _angular_core.InputSignal<number>;
+    /** Amount to add/subtract when stepping minutes. Defaults to `1`. */
+    readonly minuteStep: _angular_core.InputSignal<number>;
+    /** Amount to add/subtract when stepping seconds. Defaults to `1`. */
+    readonly secondStep: _angular_core.InputSignal<number>;
+    /** Earliest accepted time-of-day. Values earlier than this set `errorState`. Defaults to `null`. Note: when `showSeconds` is `false`, the seconds component of any value still participates in the range comparison — supply `minTime` with zeroed seconds to match the 2-field display. */
+    readonly minTime: _angular_core.InputSignal<D | null>;
+    /** Latest accepted time-of-day. Values later than this set `errorState`. Defaults to `null`. Note: when `showSeconds` is `false`, the seconds component of any value still participates in the range comparison — supply `maxTime` with zeroed seconds to match the 2-field display. */
+    readonly maxTime: _angular_core.InputSignal<D | null>;
+    /** Date portion used when the user types a time while `value` is `null`. Defaults to today. */
+    readonly referenceDate: _angular_core.InputSignal<D | null>;
+    /** Placeholder shown in each field when empty. Defaults to `'--'`. */
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    /** Whether to render the up/down stepper column. Defaults to `true`. */
+    readonly showSteppers: _angular_core.InputSignal<boolean>;
+    /** Whether to render the clear affordance when a value is set. Defaults to `true`. */
+    readonly showClear: _angular_core.InputSignal<boolean>;
+    /** Accessible label for the clear button. Defaults to `'Clear time'`. */
+    readonly clearLabel: _angular_core.InputSignal<string>;
+    /** Per-instance override of the `ErrorStateMatcher`. */
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
+    /** Accessible name for the fields group. Required when no visible label is supplied. Alias: `aria-label`. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** ID of an external element that labels the group. Alias: `aria-labelledby`. */
+    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    /** Consumer-supplied `aria-describedby` ids. The form-field preserves these when merging hint/error ids. Alias: `aria-describedby`. */
+    readonly userAriaDescribedByInput: _angular_core.InputSignal<string | undefined>;
+    /** Two-way bound current time. `null` when empty. Setting programmatically updates the fields without firing `onChange`. */
+    readonly value: _angular_core.ModelSignal<D | null>;
+    /** Fires on every keystroke, stepper press, or AM/PM toggle — before the new value is committed. */
+    readonly timeInput: _angular_core.OutputEmitterRef<TimePickerInputEvent<D>>;
+    /** Fires after a committed change — digit + auto-advance, stepper, meridiem toggle, clear, or programmatic write. */
+    readonly timeChange: _angular_core.OutputEmitterRef<TimePickerChangeEvent<D>>;
+    private readonly adapter;
+    private readonly focusMonitor;
+    private readonly liveAnnouncer;
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly formField;
+    private readonly ngControl;
+    private readonly parentForm;
+    private readonly parentFormGroup;
+    private readonly defaultMatcher;
+    /** @internal — exposed for the template; consumers configure via `provideTimePickerIntl()`. */
+    protected readonly intl: TimePickerIntl;
+    private readonly hourInputRef;
+    private readonly minuteInputRef;
+    private readonly secondInputRef;
+    private readonly uid;
+    /** @internal */
+    readonly hostId: string;
+    /** @internal raw display text per field — always the numerals the user sees. */
+    readonly hourText: _angular_core.WritableSignal<string>;
+    /** @internal */
+    readonly minuteText: _angular_core.WritableSignal<string>;
+    /** @internal */
+    readonly secondText: _angular_core.WritableSignal<string>;
+    /** @internal */
+    readonly meridiem: _angular_core.WritableSignal<TimePickerMeridiem>;
+    /** @internal */
+    readonly focusedField: _angular_core.WritableSignal<TimePickerField | null>;
+    /** @internal */
+    readonly internalValue: _angular_core.WritableSignal<D | null>;
+    private readonly cvaDisabled;
+    private readonly describedByIdsSignal;
+    private readonly focusedSignal;
+    private readonly _ngControlRev;
+    private readonly _formSubmitRev;
+    /** When true, an effect should not rewrite field text from the external value. */
+    private editing;
+    private onChange;
+    private onTouched;
+    /** @internal */
+    readonly isDisabled: Signal<boolean>;
+    /** @internal */
+    readonly isEmpty: Signal<boolean>;
+    /** @internal Effective variant — auto-naked when wrapped in tw-form-field. */
+    readonly resolvedVariant: Signal<TimePickerVariant>;
+    /** @internal */
+    readonly hourMin: Signal<number>;
+    /** @internal */
+    readonly hourMax: Signal<number>;
+    /** @internal */
+    readonly hourDisplay: Signal<string>;
+    /** @internal */
+    readonly hourValueNow: Signal<number | null>;
+    /** @internal */
+    readonly hourValueText: Signal<string>;
+    /** @internal */
+    readonly minuteValueNow: Signal<number | null>;
+    /** @internal */
+    readonly minuteValueText: Signal<string>;
+    /** @internal */
+    readonly secondValueNow: Signal<number | null>;
+    /** @internal */
+    readonly secondValueText: Signal<string>;
+    /** @internal */
+    readonly groupAriaLabel: Signal<string>;
+    /** @internal Label of the currently focused field, used by stepper aria-labels. */
+    readonly focusedFieldLabel: Signal<string>;
+    /** @internal */
+    readonly describedBy: Signal<string>;
+    private readonly rangeError;
+    private readonly variantResult;
+    /** @internal */ readonly rootClasses: Signal<string>;
+    /** @internal */ readonly fieldGroupClasses: Signal<string>;
+    /** @internal */ readonly fieldClasses: Signal<string>;
+    /** @internal */ readonly separatorClasses: Signal<string>;
+    /** @internal */ readonly stepperGroupClasses: Signal<string>;
+    /** @internal */ readonly stepperClasses: Signal<string>;
+    /** @internal */ readonly stepperIconClasses: Signal<string>;
+    /** @internal */ readonly meridiemClasses: Signal<string>;
+    /** @internal */ readonly clearButtonClasses: Signal<string>;
+    /** @internal */
+    meridiemButtonClasses(which: TimePickerMeridiem): string;
+    /** @internal */ readonly id: Signal<string>;
+    /** @internal */ readonly focused: Signal<boolean>;
+    /** @internal */ readonly empty: Signal<boolean>;
+    /** @internal */ readonly disabled: Signal<boolean>;
+    /** @internal */ readonly required: Signal<boolean>;
+    /** @internal */
+    readonly errorState: Signal<boolean>;
+    /** @internal */ readonly controlType = "time-picker";
+    /** @internal */
+    readonly userAriaDescribedBy: Signal<string | undefined>;
+    constructor();
+    ngOnInit(): void;
+    /** Moves focus to the hours field. */
+    focus(): void;
+    /** Clears the value and emits `timeChange` with `source: 'clear'`. */
+    clear(): void;
+    /** @internal */
+    onFieldFocus(field: TimePickerField): void;
+    /** @internal */
+    onFieldBlur(_field: TimePickerField): void;
+    /** @internal */
+    onBeforeInput(event: Event, field: TimePickerField): void;
+    /** @internal Handle native delete events (Backspace/Delete). */
+    onInputEvent(event: Event, field: TimePickerField): void;
+    /** @internal */
+    onFieldKeydown(event: KeyboardEvent, field: TimePickerField): void;
+    /** @internal */
+    setMeridiem(m: TimePickerMeridiem): void;
+    /** @internal */
+    onMeridiemKeydown(event: KeyboardEvent, m: TimePickerMeridiem): void;
+    /** @internal */
+    onStepperMouseDown(event: MouseEvent): void;
+    /** @internal */
+    onStepperClick(direction: 1 | -1): void;
+    /** @internal */
+    onClearClick(event: MouseEvent): void;
+    private typeDigit;
+    private stepField;
+    private commitFromFields;
+    private buildValueIfComplete;
+    private toCanonicalHour;
+    private resolveBaseDate;
+    private commit;
+    private formatAnnouncement;
+    private isInRange;
+    private normalizeEmptyFields;
+    private moveFocus;
+    private isFieldCaretAtStart;
+    private isFieldCaretAtEnd;
+    private getFieldEl;
+    private getFieldText;
+    private setFieldText;
+    private stepFor;
+    private fieldMinFor;
+    private fieldMaxFor;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: D | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** @internal */
+    setDescribedByIds(ids: string[]): void;
+    /** @internal */
+    onContainerClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimePickerComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimePickerComponent<any>, "tw-time-picker", never, { "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "hourStep": { "alias": "hourStep"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "secondStep": { "alias": "secondStep"; "required": false; "isSignal": true; }; "minTime": { "alias": "minTime"; "required": false; "isSignal": true; }; "maxTime": { "alias": "maxTime"; "required": false; "isSignal": true; }; "referenceDate": { "alias": "referenceDate"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "showSteppers": { "alias": "showSteppers"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "userAriaDescribedByInput": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "timeInput": "timeInput"; "timeChange": "timeChange"; }, never, ["[slot=stepper-up]", "[slot=stepper-down]"], true, never>;
+}
+
+export { TimePickerComponent, TimePickerIntl, provideTimePickerIntl };
+export type { TimePickerChangeEvent, TimePickerChangeSource, TimePickerField, TimePickerInputEvent, TimePickerVariant };