@cute-widgets/base 20.0.1

package/tabs/index.d.ts

@@ -0,0 +1,307 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, TemplateRef, SimpleChanges, ComponentRef, DestroyRef, QueryList, ViewContainerRef, ElementRef, EventEmitter } from '@angular/core';
+import * as _cute_widgets_base_tabs from '@cute-widgets/base/tabs';
+import { CuteFocusableControl, CuteLayoutControl } from '@cute-widgets/base/abstract';
+import { Subject } from 'rxjs';
+import { CuteNavLink, CuteNavStretch, CuteNavChangeEvent, CuteNavChangingEvent } from '@cute-widgets/base/core/nav';
+import * as _angular_animations from '@angular/animations';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { ContentAlignment, ViewportEdge } from '@cute-widgets/base/core';
+import * as i1 from '@angular/common';
+
+/**
+ * Used to provide a tab label to a tab without causing a circular dependency.
+ * @docs-private
+ */
+declare const CUTE_TAB: InjectionToken<CuteTab>;
+declare class CuteTab extends CuteFocusableControl {
+    protected _tabGroup: _cute_widgets_base_tabs.CuteTabGroup | null;
+    private _intersectionRatio;
+    /** Plain text label for the tab, used when there is no template label. */
+    textLabel: string;
+    /** Explicit reference to the external content template. */
+    contentTemplate: TemplateRef<any> | undefined;
+    /** Lazy loading label's outlet context */
+    labelContext: any;
+    /** Lazy loading content's outlet context */
+    contentContext: any;
+    /** Whether the tab is closable. */
+    closable: boolean;
+    /** Whether the tab preserves lazing content */
+    preserveContent: boolean | undefined;
+    /** Content for the tab label given by `<ng-template cute-tab-label>`. */
+    readonly _templateLabel: TemplateRef<any> | undefined;
+    /**
+     * Template provided in the tab content by <ng-template cute-tab-content>, used to enable lazy-loading
+     */
+    private _explicitContent;
+    /** Reference to `<cute-nav-link>` element. */
+    readonly link: CuteNavLink | undefined;
+    /** Whether the tab is currently active. */
+    get active(): boolean;
+    set active(value: boolean);
+    private _active;
+    /** Whether the tab is intersected the containing box and needs to scroll to display its full size */
+    get scrollNeeded(): boolean;
+    /** Whether the tab was added dynamically */
+    isDynamic: boolean;
+    protected isPreserveContent(): boolean;
+    /** Tab content defined by <ng-template cute-tab-content> or directly referenced where the latter has more priority. */
+    protected get explicitContent(): TemplateRef<any> | undefined;
+    /** Emits whenever the internal state of the tab changes. */
+    readonly _stateChanges: Subject<void>;
+    /** Whether the tab content was loaded */
+    loaded: i0.WritableSignal<boolean>;
+    /** Template inside the CuteTab view that contains an `<ng-content>`. */
+    constructor();
+    protected generateId(): string;
+    /** Gets the content template's context object */
+    getContentContext(): any;
+    /**
+     * Removes this tab from the tab group.
+     */
+    remove(): Promise<void>;
+    _visibilityChanged(entries: IntersectionObserverEntry[]): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteTab, "cute-tab", never, { "textLabel": { "alias": "label"; "required": false; }; "contentTemplate": { "alias": "contentTemplate"; "required": false; }; "labelContext": { "alias": "labelContext"; "required": false; }; "contentContext": { "alias": "contentContext"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "preserveContent": { "alias": "preserveContent"; "required": false; }; }, {}, ["_templateLabel", "_explicitContent", "link"], ["*"], true, never>;
+    static ngAcceptInputType_closable: unknown;
+    static ngAcceptInputType_preserveContent: unknown;
+}
+
+declare const transitionAnimation: _angular_animations.AnimationReferenceMetadata;
+/**
+ * Used to provide a tab group to a tab without causing a circular dependency.
+ */
+declare const CUTE_TAB_GROUP: InjectionToken<CuteTabGroup>;
+/** Cancelable event emitted when the `cute-tab` selection is about to change. */
+declare class CuteTabChangingEvent extends Event {
+    /** Index of the currently-selected tab. */
+    readonly index: number;
+    /** Reference to the currently-selected tab. */
+    readonly tab: CuteTab;
+    /** Index of the previously-selected tab. */
+    readonly fromIndex: number | null;
+    /** Reference to the previously-selected tab. */
+    readonly fromTab: CuteTab | null;
+    /** How the tab was focused. */
+    readonly origin: FocusOrigin;
+    constructor(
+    /** Index of the currently-selected tab. */
+    index: number, 
+    /** Reference to the currently-selected tab. */
+    tab: CuteTab, 
+    /** Index of the previously-selected tab. */
+    fromIndex: number | null, 
+    /** Reference to the previously-selected tab. */
+    fromTab: CuteTab | null, 
+    /** How the tab was focused. */
+    origin: FocusOrigin);
+}
+/** A simple change event emitted on focus or selection changes. */
+declare class CuteTabChangeEvent extends Event {
+    /** Index of the currently-selected tab. */
+    readonly index: number;
+    /** Reference to the currently-selected tab. */
+    readonly tab: CuteTab;
+    /** Index of the previously-selected tab. */
+    readonly fromIndex: number | null;
+    /** Reference to the previously-selected tab. */
+    readonly fromTab: CuteTab | null;
+    /** How the tab was focused. */
+    readonly origin: FocusOrigin;
+    constructor(
+    /** Index of the currently-selected tab. */
+    index: number, 
+    /** Reference to the currently-selected tab. */
+    tab: CuteTab, 
+    /** Index of the previously-selected tab. */
+    fromIndex: number | null, 
+    /** Reference to the previously-selected tab. */
+    fromTab: CuteTab | null, 
+    /** How the tab was focused. */
+    origin: FocusOrigin);
+}
+/**
+ * A flexible, feature-rich tab component for Angular applications with Bootstrap integration.
+ */
+declare class CuteTabGroup extends CuteLayoutControl {
+    private _indexToChange;
+    private _scrollDebounce;
+    private _resizeObserver;
+    protected showScrollButtons: boolean;
+    protected canScrollLeft: boolean;
+    protected canScrollRight: boolean;
+    /** Number of pixels to scroll left or right */
+    protected scrollAmount: number;
+    protected dynamicTabs: ComponentRef<CuteTab>[];
+    protected destroyRef: DestroyRef;
+    protected tabs: QueryList<CuteTab> | undefined;
+    protected tabLinks: QueryList<CuteNavLink> | undefined;
+    protected dynamicTabsContainer: ViewContainerRef | undefined;
+    headerContainer: ElementRef<HTMLElement>;
+    headerScroll: ElementRef<HTMLElement>;
+    /** The index of the active tab. */
+    get selectedIndex(): number | undefined;
+    set selectedIndex(value: number);
+    private _selectedIndex;
+    /**
+     *  Alignment for tabs.
+     *  @default start
+     */
+    alignTabs: ContentAlignment;
+    /**
+     * The style a `cute-tab`’s content extends the full available width, proportionately (**fill**) or equal-width (**justified**).
+     * The width is determined by the longest `cute-tab-label`'s content. By default, stretching of items is not used (**none**).
+     */
+    get stretchTabs(): CuteNavStretch;
+    set stretchTabs(value: CuteNavStretch | boolean | "false" | "true" | undefined);
+    private _stretchTabs;
+    /**
+     * By default, tabs remove their lazy content from the DOM while it's off-screen. Setting this to _true_ will keep it in the DOM,
+     * which will prevent elements like `iframe` and `video` from reloading next time it comes back into the view.
+     */
+    preserveContent: boolean | undefined;
+    /** Whether the tab group will change its height to the height of the currently active tab. */
+    dynamicHeight: boolean;
+    /**
+     * Possible positions for the tab header.
+     * @default top
+     */
+    headerPosition: ViewportEdge;
+    /** Use `underline` style for horizontal tabs. */
+    underlineTabs: boolean;
+    /**
+     * Whether tabs can be draggable.
+     * @default false
+     */
+    dragEnabled: boolean;
+    /**
+     * Defines the horizontal alignment when scrolling the tabs.
+     * @default center
+     */
+    tabScrollingAlignment: ScrollLogicalPosition;
+    /** Output to enable support for two-way binding on `[(selectedIndex)]` */
+    selectedIndexChange: EventEmitter<number>;
+    /** Event emitted when the active tab selection is about to change. */
+    selectedTabChanging: EventEmitter<CuteTabChangingEvent>;
+    /** Event emitted when the tab selection has changed. */
+    selectedTabChange: EventEmitter<CuteTabChangeEvent>;
+    /** Event emitted when focus has changed within a tab group. */
+    focusChange: EventEmitter<CuteTabChangeEvent>;
+    /** Event emitted after the new tab was added. */
+    tabAdded: EventEmitter<void>;
+    /** Event emitted after the closable tab was removed. */
+    tabRemoved: EventEmitter<number>;
+    constructor();
+    /** Whether the tab group currently has a horizontal layout */
+    get isHorizontal(): boolean;
+    /** The active tab. */
+    get selectedTab(): CuteTab | undefined;
+    /** The number of tabs in the tab group. */
+    get tabCount(): number;
+    /**
+     * Returns the first element in the array of tabs that satisfies the provided testing function.
+     * Otherwise, _undefined_ is returned.
+     * @param predicate Testing function
+     * @returns `CuteTab` object or _undefined_ if there are no tabs with the specified condition.
+     */
+    findTab(predicate: (tab: CuteTab, index: number) => boolean): CuteTab | undefined;
+    protected generateId(): string;
+    private checkScrollButtons;
+    private setupScrollListener;
+    protected scrollHeader(direction: number): void;
+    /**
+     * Activates tab with specified index.
+     * @param index Tab index
+     * @param origin (optional) Focus origin
+     */
+    selectTab(index: number, origin?: FocusOrigin): void;
+    private _createChangeEvent;
+    private _createChangingEvent;
+    protected onNavFocusChange(event: CuteNavChangeEvent): void;
+    protected onNavLinkChange(event: CuteNavChangeEvent): void;
+    protected onNavLinkChanging(event: CuteNavChangingEvent): void;
+    protected getLabelContext(tab: CuteTab, index: number): any;
+    /** Gets the current index of the specified tab object. */
+    getTabIndex(tab: CuteTab): number | undefined;
+    private scrollToTab;
+    /** Drop event */
+    protected onDrop(event: CdkDragDrop<CuteTab[]>): void;
+    /** Sets a new active index after the dragging tabs */
+    private _adjustActiveIndex;
+    /**
+     * Adds a new tab to the end of `tab-group` dynamically.
+     *
+     * @param label Tab label
+     * @param content Tab template reference
+     * @param context (optional) Template context object
+     * @param closable (optional) Whether the tab is closable. Default is _true_.
+     * @returns `ComponentRef` object of the new Tab.
+     */
+    addTab(label: string, content: TemplateRef<any>, context?: any, closable?: boolean): Promise<ComponentRef<CuteTab>>;
+    /**
+     * Removes the tab with specified index.
+     * @param index Tab index
+     */
+    removeTab(index: number): Promise<void>;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTabGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteTabGroup, "cute-tab-group", ["cuteTabGroup"], { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "alignTabs": { "alias": "cute-align-tabs"; "required": false; }; "stretchTabs": { "alias": "cute-stretch-tabs"; "required": false; }; "preserveContent": { "alias": "preserveContent"; "required": false; }; "dynamicHeight": { "alias": "dynamicHeight"; "required": false; }; "headerPosition": { "alias": "headerPosition"; "required": false; }; "underlineTabs": { "alias": "underlineTabs"; "required": false; }; "dragEnabled": { "alias": "dragEnabled"; "required": false; }; "tabScrollingAlignment": { "alias": "tabScrollingAlignment"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "selectedTabChanging": "selectedTabChanging"; "selectedTabChange": "selectedTabChange"; "focusChange": "focusChange"; "tabAdded": "tabAdded"; "tabRemoved": "tabRemoved"; }, ["tabs"], ["*"], true, never>;
+    static ngAcceptInputType_selectedIndex: unknown;
+    static ngAcceptInputType_preserveContent: unknown;
+    static ngAcceptInputType_dynamicHeight: unknown;
+    static ngAcceptInputType_underlineTabs: unknown;
+    static ngAcceptInputType_dragEnabled: unknown;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Injection token that can be used to reference instances of `CuteTabContent`. It serves as
+ * alternative token to the actual `CuteTabContent` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CUTE_TAB_CONTENT: InjectionToken<CuteTabContent>;
+/** Decorates the `ng-template` tags and reads out the template from it. */
+declare class CuteTabContent {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTabContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTabContent, "ng-template[cute-tab-content], ng-template[cuteTabContent]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Injection token that can be used to reference instances of `CuteTabLabel`. It serves as
+ * alternative token to the actual `CuteTabLabel` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+declare const CUTE_TAB_LABEL: InjectionToken<CuteTabLabel>;
+/** Used to flag tab labels for use with the portal directive */
+declare class CuteTabLabel {
+    _closestTab: _cute_widgets_base_tabs.CuteTab | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTabLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTabLabel, "ng-template[cute-tab-label], ng-template[cuteTabLabel]", ["cuteTabLabel"], {}, {}, never, never, true, never>;
+}
+
+declare class CuteTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteTabsModule, never, [typeof i1.CommonModule, typeof CuteTab, typeof CuteTabGroup, typeof CuteTabLabel, typeof CuteTabContent], [typeof CuteTab, typeof CuteTabGroup, typeof CuteTabLabel, typeof CuteTabContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteTabsModule>;
+}
+
+export { CUTE_TAB, CUTE_TAB_CONTENT, CUTE_TAB_GROUP, CUTE_TAB_LABEL, CuteTab, CuteTabChangeEvent, CuteTabChangingEvent, CuteTabContent, CuteTabGroup, CuteTabLabel, CuteTabsModule, transitionAnimation };

package/timepicker/index.d.ts

@@ -0,0 +1,350 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnDestroy, Signal, TemplateRef, InputSignalWithTransform, InputSignal, OutputEmitterRef, ElementRef, ModelSignal } from '@angular/core';
+import { CuteOptionParentComponent, CuteOption } from '@cute-widgets/base/core/option';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as i4 from '@angular/cdk/scrolling';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Object that can be used to configure the default options for the timepicker component.
+ */
+interface CuteTimepickerConfig {
+    /** Default interval for all time pickers. */
+    interval?: string | number;
+    /** Whether ripples inside the timepicker should be disabled by default. */
+    disableRipple?: boolean;
+}
+/**
+ * Injection token that can be used to configure the default options for the timepicker component.
+ */
+declare const CUTE_TIMEPICKER_CONFIG: InjectionToken<CuteTimepickerConfig>;
+/**
+ * Time selection option that can be displayed within a `cute-timepicker`.
+ */
+interface CuteTimepickerOption<D = unknown> {
+    /** Date value of the option. */
+    value: D;
+    /** Label to show to the user. */
+    label: string;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/** Event emitted when a value is selected in the timepicker. */
+interface CuteTimepickerSelected<D> {
+    value: D;
+    source: CuteTimepicker<D>;
+}
+/** Injection token used to configure the behavior of the timepicker dropdown while scrolling. */
+declare const CUTE_TIMEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** Represents an input that is connected to a `cute-timepicker`. */
+interface CuteTimepickerConnectedInput<D> {
+    /** Current value of the input. */
+    value: Signal<D | null>;
+    /** Minimum allowed time. */
+    min: Signal<D | null>;
+    /** Maximum allowed time. */
+    max: Signal<D | null>;
+    /** Whether the input is disabled. */
+    disabled: Signal<boolean>;
+    /** Focuses the input. */
+    focus(): void;
+    /** Gets the element to which to connect the timepicker overlay. */
+    getOverlayOrigin(): ElementRef<HTMLElement>;
+    /** Gets the ID of the input's label. */
+    getLabelId(): string | null;
+    /** Callback invoked when the timepicker assigns a value. */
+    timepickerValueAssigned(value: D | null): void;
+}
+/**
+ * Renders out a listbox that can be used to select a time of day.
+ * Intended to be used together with `CuteTimepickerInput`.
+ */
+declare class CuteTimepicker<D> implements OnDestroy, CuteOptionParentComponent {
+    private _overlay;
+    private _dir;
+    private _viewContainerRef;
+    private _injector;
+    private _defaultConfig;
+    private _dateAdapter;
+    private _dateFormats;
+    private _scrollStrategyFactory;
+    protected _animationsDisabled: boolean;
+    private _isOpen;
+    private _activeDescendant;
+    private _input;
+    private _overlayRef;
+    private _portal;
+    private _optionsCacheKey;
+    private _localeChanges;
+    private _onOpenRender;
+    protected _panelTemplate: Signal<TemplateRef<unknown>>;
+    protected _timeOptions: readonly CuteTimepickerOption<D>[];
+    protected _options: Signal<readonly CuteOption<any>[]>;
+    private _keyManager;
+    /**
+     * Interval between each option in the timepicker. The value can either be an amount of
+     * seconds (e.g. 90) or a number with a unit (e.g. 45m). Supported units are `s` for seconds,
+     * `m` for minutes or `h` for hours.
+     */
+    readonly interval: InputSignalWithTransform<number | null, number | string | null>;
+    /**
+     * Array of pre-defined options that the user can select from, as an alternative to using the
+     * `interval` input. An error will be thrown if both `options` and `interval` are specified.
+     */
+    readonly options: InputSignal<readonly CuteTimepickerOption<D>[] | null>;
+    /** Whether the timepicker is open. */
+    readonly isOpen: Signal<boolean>;
+    /** Emits when the user selects a time. */
+    readonly selected: OutputEmitterRef<CuteTimepickerSelected<D>>;
+    /** Emits when the timepicker is opened. */
+    readonly opened: OutputEmitterRef<void>;
+    /** Emits when the timepicker is closed. */
+    readonly closed: OutputEmitterRef<void>;
+    /** ID of the active descendant option. */
+    readonly activeDescendant: Signal<string | null>;
+    /** Unique ID of the timepicker's panel */
+    readonly panelId: string;
+    /** Whether ripples within the timepicker should be disabled. */
+    readonly disableRipple: InputSignalWithTransform<boolean, unknown>;
+    /** ARIA label for the timepicker panel. */
+    readonly ariaLabel: InputSignal<string | null>;
+    /** ID of the label element for the timepicker panel. */
+    readonly ariaLabelledby: InputSignal<string | null>;
+    /** Whether the timepicker is currently disabled. */
+    readonly disabled: Signal<boolean>;
+    constructor();
+    /** Opens the timepicker. */
+    open(): void;
+    /** Closes the timepicker. */
+    close(): void;
+    /** Registers an input with the timepicker. */
+    registerInput(input: CuteTimepickerConnectedInput<D>): void;
+    ngOnDestroy(): void;
+    _getOverlayHost(): HTMLElement | undefined;
+    /** Selects a specific time value. */
+    protected _selectValue(option: CuteOption<D>): void;
+    /** Gets the value of the `aria-labelledby` attribute. */
+    protected _getAriaLabelledby(): string | null;
+    /** Handles animation events coming from the panel. */
+    protected _handleAnimationEnd(event: AnimationEvent): void;
+    /** Creates an overlay reference for the timepicker panel. */
+    private _getOverlayRef;
+    /** Generates the list of options from which the user can select. */
+    private _generateOptions;
+    /**
+     * Synchronizes the internal state of the component based on a specific selected date.
+     * @param value Currently selected date.
+     * @param options Options rendered out in the timepicker.
+     * @param fallback Option to set as active if no option is selected.
+     */
+    private _syncSelectedState;
+    /** Handles keyboard events while the overlay is open. */
+    private _handleKeydown;
+    /** Sets up the logic that updates the timepicker when the locale changes. */
+    private _handleLocaleChanges;
+    /**
+     * Sets up the logic that updates the timepicker when the state of the connected input changes.
+     */
+    private _handleInputStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTimepicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteTimepicker<any>, "cute-timepicker", ["cuteTimepicker"], { "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+
+/**
+ * Input that can be used to enter time and connect to a `cute-timepicker`.
+ */
+declare class CuteTimepickerInput<D> implements CuteTimepickerConnectedInput<D>, ControlValueAccessor, Validator, OnDestroy {
+    private _elementRef;
+    private _dateAdapter;
+    private _dateFormats;
+    private _formField;
+    private _onChange;
+    private _onTouched;
+    private _validatorOnChange;
+    private _cleanupClick;
+    private _accessorDisabled;
+    private _localeSubscription;
+    private _timepickerSubscription;
+    private _validator;
+    private _lastValueValid;
+    private _minValid;
+    private _maxValid;
+    private _lastValidDate;
+    /** Value of the `aria-activedescendant` attribute. */
+    protected readonly _ariaActiveDescendant: Signal<string | null>;
+    /** Value of the `aria-expanded` attribute. */
+    protected readonly _ariaExpanded: Signal<string>;
+    /** Value of the `aria-controls` attribute. */
+    protected readonly _ariaControls: Signal<string | null>;
+    /** Current value of the input. */
+    readonly value: ModelSignal<D | null>;
+    /** Timepicker that the input is associated with. */
+    readonly timepicker: InputSignal<CuteTimepicker<D>>;
+    /**
+     * Minimum time that can be selected or typed in. Can be either
+     * a date object (only time will be used) or a valid time string.
+     */
+    readonly min: InputSignalWithTransform<D | null, unknown>;
+    /**
+     * Maximum time that can be selected or typed in. Can be either
+     * a date object (only time will be used) or a valid time string.
+     */
+    readonly max: InputSignalWithTransform<D | null, unknown>;
+    /**
+     * Whether to open the timepicker overlay when clicking on the input. Enabled by default.
+     * Note that when disabling this option, you'll have to provide your own logic for opening
+     * the overlay.
+     */
+    readonly openOnClick: InputSignalWithTransform<boolean, unknown>;
+    /** Whether the input is disabled. */
+    readonly disabled: Signal<boolean>;
+    /**
+     * Whether the input should be disabled through the template.
+     * @docs-private
+     */
+    readonly disabledInput: InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    writeValue(value: any): void;
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    registerOnChange(fn: (value: any) => void): void;
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    registerOnTouched(fn: () => void): void;
+    /**
+     * Implemented as a part of `ControlValueAccessor`.
+     * @docs-private
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Implemented as a part of `Validator`.
+     * @docs-private
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    /**
+     * Implemented as a part of `Validator`.
+     * @docs-private
+     */
+    registerOnValidatorChange(fn: () => void): void;
+    /** Gets the element to which the timepicker popup should be attached. */
+    getOverlayOrigin(): ElementRef<HTMLElement>;
+    /** Focuses the input. */
+    focus(): void;
+    ngOnDestroy(): void;
+    /** Gets the ID of the input's label. */
+    getLabelId(): string | null;
+    /** Handles clicks on the input or the containing form field. */
+    private _handleClick;
+    /** Handles the `input` event. */
+    protected _handleInput(event: Event): void;
+    /** Handles the `blur` event. */
+    protected _handleBlur(): void;
+    /** Handles the `keydown` event. */
+    protected _handleKeydown(event: KeyboardEvent): void;
+    /** Called by the timepicker to sync up the user-selected value. */
+    timepickerValueAssigned(value: D | null): void;
+    /** Sets up the code that keeps the input state in sync with the forms module. */
+    private _updateFormsState;
+    /** Sets up the logic that registers the input with the timepicker. */
+    private _registerTimepicker;
+    /**
+     * Assigns a value set by the user to the input's model.
+     * @param selection Time selected by the user that should be assigned.
+     * @param propagateToAccessor Whether the value should be propagated to the ControlValueAccessor.
+     */
+    private _assignUserSelection;
+    /** Formats the current value and assigns it to the input. */
+    private _formatValue;
+    /** Checks whether a value is valid. */
+    private _isValid;
+    /** Transforms an arbitrary value into a value that can be assigned to a date-based input. */
+    private _transformDateInput;
+    /** Whether the input is currently focused. */
+    private _hasFocus;
+    /** Gets a function that can be used to validate the input. */
+    private _getValidator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTimepickerInput<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteTimepickerInput<any>, "input[cuteTimepicker]", ["cuteTimepickerInput"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "timepicker": { "alias": "cuteTimepicker"; "required": true; "isSignal": true; }; "min": { "alias": "cuteTimepickerMin"; "required": false; "isSignal": true; }; "max": { "alias": "cuteTimepickerMax"; "required": false; "isSignal": true; }; "openOnClick": { "alias": "cuteTimepickerOpenOnClick"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/** Button that can be used to open a `cute-timepicker`. */
+declare class CuteTimepickerToggle<D> {
+    private _defaultConfig;
+    private _defaultTabIndex;
+    protected _isDisabled: i0.Signal<boolean>;
+    /** Timepicker instance that the button will toggle. */
+    readonly timepicker: InputSignal<CuteTimepicker<D>>;
+    /** Screen-reader label for the button. */
+    readonly ariaLabel: InputSignal<string | undefined>;
+    /** Screen-reader labelled by id for the button. */
+    readonly ariaLabelledby: InputSignal<string | undefined>;
+    /** Default aria-label for the toggle if none is provided. */
+    private readonly _defaultAriaLabel;
+    /** Whether the toggle button is disabled. */
+    readonly disabled: InputSignalWithTransform<boolean, unknown>;
+    /** Tabindex for the toggle. */
+    readonly tabIndex: InputSignal<number | null>;
+    /** Whether ripples on the toggle should be disabled. */
+    readonly disableRipple: InputSignalWithTransform<boolean, unknown>;
+    /** Opens the connected timepicker. */
+    protected _open(event: Event): void;
+    /**
+     * Checks for ariaLabelledby and if empty uses custom
+     * aria-label or defaultAriaLabel if neither is provided.
+     */
+    getAriaLabel(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTimepickerToggle<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CuteTimepickerToggle<any>, "cute-timepicker-toggle", ["cuteTimepickerToggle"], { "timepicker": { "alias": "for"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; }, {}, never, ["[cuteTimepickerToggleIcon]"], true, never>;
+}
+
+declare class CuteTimepickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteTimepickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteTimepickerModule, never, [typeof CuteTimepicker, typeof CuteTimepickerInput, typeof CuteTimepickerToggle], [typeof i4.CdkScrollableModule, typeof CuteTimepicker, typeof CuteTimepickerInput, typeof CuteTimepickerToggle]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CuteTimepickerModule>;
+}
+
+export { CUTE_TIMEPICKER_CONFIG, CUTE_TIMEPICKER_SCROLL_STRATEGY, CuteTimepicker, CuteTimepickerInput, CuteTimepickerModule, CuteTimepickerToggle };
+export type { CuteTimepickerConfig, CuteTimepickerConnectedInput, CuteTimepickerOption, CuteTimepickerSelected };