@taiga-ui/core 4.52.0-canary.a4e325d → 4.52.0-canary.aaf153c

package/components/spin-button/spin-button.component.d.ts

@@ -1,16 +1,15 @@
-import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiSpinButton {
     protected readonly icons: import("@taiga-ui/core/tokens").TuiSpinIcons;
-    protected readonly spinTexts$: import("rxjs").Observable<readonly [previous: string, next: string]>;
-    focusable: boolean;
-    disabled: boolean;
-    leftDisabled: boolean;
-    rightDisabled: boolean;
-    readonly leftClick: EventEmitter<void>;
-    readonly rightClick: EventEmitter<void>;
+    protected readonly spinTexts: import("@angular/core").Signal<readonly [previous: string, next: string]>;
+    readonly focusable: import("@angular/core").InputSignal<boolean>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly leftDisabled: import("@angular/core").InputSignal<boolean>;
+    readonly rightDisabled: import("@angular/core").InputSignal<boolean>;
+    readonly leftClick: import("@angular/core").OutputEmitterRef<void>;
+    readonly rightClick: import("@angular/core").OutputEmitterRef<void>;
     onLeftClick(): void;
     onRightClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSpinButton, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSpinButton, "tui-spin-button", never, { "focusable": { "alias": "focusable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "leftDisabled": { "alias": "leftDisabled"; "required": false; }; "rightDisabled": { "alias": "rightDisabled"; "required": false; }; }, { "leftClick": "leftClick"; "rightClick": "rightClick"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSpinButton, "tui-spin-button", never, { "focusable": { "alias": "focusable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "leftDisabled": { "alias": "leftDisabled"; "required": false; "isSignal": true; }; "rightDisabled": { "alias": "rightDisabled"; "required": false; "isSignal": true; }; }, { "leftClick": "leftClick"; "rightClick": "rightClick"; }, never, ["*"], true, never>;
 }

package/components/textfield/index.d.ts

@@ -6,9 +6,7 @@ export * from './textfield.options';
 export * from './textfield-accessor';
 export * from './textfield-auxiliary';
 export * from './textfield-content.directive';
-export * from './textfield-dropdown.directive';
 export * from './textfield-icon';
-export * from './with-native-picker.directive';
-export * from './select.directive';
 export * from './textfield-multi/textfield-item.component';
 export * from './textfield-multi/textfield-multi.component';
+export * from './with-native-picker.directive';

package/components/textfield/textfield-content.directive.d.ts

@@ -1,8 +1,9 @@
-import { type DoCheck } from '@angular/core';
+import { type DoCheck, type OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class TuiTextfieldContent implements DoCheck {
+export declare class TuiTextfieldContent implements DoCheck, OnDestroy {
     private readonly ref;
     ngDoCheck(): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldContent, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldContent, "ng-template[tuiTextfieldContent]", never, {}, {}, never, never, true, never>;
 }

package/components/textfield/textfield-icon.d.ts

@@ -1,6 +1,6 @@
 import { type ProviderToken, type Signal } from '@angular/core';
-import { type TuiHandler } from '@taiga-ui/cdk/types';
+import { type TuiStringHandler } from '@taiga-ui/cdk/types';
 import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
-export declare function tuiTextfieldIconBinding(token: ProviderToken<{
-    icon: TuiHandler<TuiSizeL | TuiSizeS, string>;
+export declare function tuiTextfieldIcon(token: ProviderToken<{
+    icon: TuiStringHandler<TuiSizeL | TuiSizeS>;
 }>): Signal<string>;

package/components/textfield/textfield-multi/textfield-multi.component.d.ts

@@ -5,22 +5,21 @@ import { TuiTextfieldBaseComponent } from '../textfield.component';
 import { type TuiTextfieldItem } from './textfield-item.component';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/dropdown";
-import * as i2 from "../textfield-dropdown.directive";
-import * as i3 from "@taiga-ui/core/directives/icons";
-import * as i4 from "@taiga-ui/core/directives";
-import * as i5 from "@taiga-ui/core/components/data-list";
+import * as i2 from "@taiga-ui/core/directives/icons";
+import * as i3 from "@taiga-ui/core/directives";
+import * as i4 from "@taiga-ui/core/components/data-list";
 export declare class TuiTextfieldMultiComponent<T> extends TuiTextfieldBaseComponent<T> {
     protected readonly height: import("@angular/core").WritableSignal<number | null>;
     protected readonly handlers: import("@taiga-ui/core/directives").TuiItemsHandlers<unknown>;
     protected readonly component: PolymorpheusContent<TuiContext<TuiTextfieldItem<T>>>;
     protected readonly sub: import("rxjs").Subscription;
     readonly item?: TemplateRef<unknown>;
-    rows: number;
+    readonly rows: import("@angular/core").InputSignal<number>;
     handleOption(option: T): void;
     protected get placeholder(): string;
     protected onItems({ target }: ResizeObserverEntry): void;
     protected onLeft(event: any): void;
     protected onClick(target: HTMLElement): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldMultiComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldMultiComponent<any>, "tui-textfield[multi]", never, { "rows": { "alias": "rows"; "required": false; }; }, {}, ["item"], ["label", "input", "select", "*", "tui-icon"], true, [{ directive: typeof i1.TuiDropdownFixed; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithTextfieldDropdown; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithIcons; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithItemsHandlers; inputs: {}; outputs: {}; }, { directive: typeof i5.TuiWithOptionContent; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithAppearance; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldMultiComponent<any>, "tui-textfield[multi]", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, {}, ["item"], ["label", "input", "select", "*", "tui-icon"], true, [{ directive: typeof i1.TuiDropdownFixed; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithItemsHandlers; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithOptionContent; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithAppearance; inputs: {}; outputs: {}; }]>;
 }

package/components/textfield/textfield.component.d.ts

@@ -13,9 +13,7 @@ import * as i2 from "@taiga-ui/cdk/directives/transitioned";
 import * as i3 from "@taiga-ui/core/directives/icons";
 import * as i4 from "@taiga-ui/core/directives/items-handlers";
 import * as i5 from "@taiga-ui/core/components/data-list";
-import * as i6 from "./textfield-dropdown.directive";
 export declare class TuiTextfieldBaseComponent<T> implements TuiDataListHost<T>, AfterContentChecked {
-    private readonly filler;
     private readonly autoId;
     private readonly focusedIn;
     private readonly contentReady$;
@@ -28,7 +26,7 @@ export declare class TuiTextfieldBaseComponent<T> implements TuiDataListHost<T>,
     protected readonly dropdown: TuiDropdownDirective;
     protected readonly dropdownOpen: TuiDropdownOpen;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    protected readonly clear: import("@angular/core").Signal<string | undefined>;
+    protected readonly clear: import("@angular/core").Signal<string>;
     protected readonly computedFiller: import("@angular/core").Signal<string>;
     protected readonly showFiller: import("@angular/core").Signal<boolean>;
     readonly vcr?: ViewContainerRef;
@@ -36,13 +34,13 @@ export declare class TuiTextfieldBaseComponent<T> implements TuiDataListHost<T>,
     readonly control?: NgControl;
     readonly cva?: TuiControl<unknown>;
     readonly input?: ElementRef<HTMLInputElement>;
-    content: PolymorpheusContent<TuiContext<T>>;
+    readonly content: import("@angular/core").InputSignal<PolymorpheusContent<TuiContext<T>>>;
     readonly focused: import("@angular/core").Signal<boolean>;
     readonly options: import("./textfield.options").TuiTextfieldOptions;
     readonly el: HTMLElement;
     readonly value: import("@angular/core").WritableSignal<string>;
     readonly auxiliaries: import("@angular/core").Signal<readonly object[]>;
-    set fillerSetter(filler: string);
+    readonly filler: import("@angular/core").InputSignal<string>;
     get id(): string;
     get size(): TuiSizeL | TuiSizeS;
     ngAfterContentChecked(): void;
@@ -52,9 +50,9 @@ export declare class TuiTextfieldBaseComponent<T> implements TuiDataListHost<T>,
     protected onIconClick(): void;
     protected onScroll(element: HTMLElement): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldBaseComponent<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldBaseComponent<any>, never, never, { "content": { "alias": "content"; "required": false; }; "fillerSetter": { "alias": "filler"; "required": false; }; }, {}, ["label", "_input", "accessor", "control", "cva", "input", "auxiliaryQuery"], never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldBaseComponent<any>, never, never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "filler": { "alias": "filler"; "required": false; "isSignal": true; }; }, {}, ["label", "_input", "accessor", "control", "cva", "input", "auxiliaryQuery"], never, true, never>;
 }
 export declare class TuiTextfieldComponent<T> extends TuiTextfieldBaseComponent<T> {
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldComponent<any>, "tui-textfield:not([multi])", never, {}, {}, never, ["input", "select", "textarea", "label", "*", "tui-icon"], true, [{ directive: typeof i1.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiDropdownFixed; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiTransitioned; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithIcons; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithItemsHandlers; inputs: {}; outputs: {}; }, { directive: typeof i5.TuiWithOptionContent; inputs: {}; outputs: {}; }, { directive: typeof i6.TuiWithTextfieldDropdown; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldComponent<any>, "tui-textfield:not([multi])", never, {}, {}, never, ["input", "select", "textarea", "label", "*", "tui-icon"], true, [{ directive: typeof i1.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiDropdownFixed; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiTransitioned; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithIcons; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithItemsHandlers; inputs: {}; outputs: {}; }, { directive: typeof i5.TuiWithOptionContent; inputs: {}; outputs: {}; }]>;
 }

package/components/textfield/textfield.d.ts

@@ -1,9 +1,8 @@
 import { TuiItem } from '@taiga-ui/cdk/directives/item';
 import { TuiLabel } from '@taiga-ui/core/components/label';
-import { TuiSelect } from './select.directive';
+import { TuiDropdownContent } from '@taiga-ui/core/directives/dropdown';
 import { TuiTextfieldComponent } from './textfield.component';
 import { TuiTextfieldDirective } from './textfield.directive';
 import { TuiTextfieldOptionsDirective } from './textfield.options';
-import { TuiTextfieldDropdownDirective } from './textfield-dropdown.directive';
 import { TuiTextfieldMultiComponent } from './textfield-multi/textfield-multi.component';
-export declare const TuiTextfield: readonly [typeof TuiItem, typeof TuiLabel, typeof TuiSelect, typeof TuiTextfieldComponent, typeof TuiTextfieldDirective, typeof TuiTextfieldOptionsDirective, typeof TuiTextfieldDropdownDirective, typeof TuiTextfieldMultiComponent];
+export declare const TuiTextfield: readonly [typeof TuiItem, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldDirective, typeof TuiTextfieldOptionsDirective, typeof TuiTextfieldMultiComponent, typeof TuiDropdownContent];

package/components/textfield/textfield.directive.d.ts

@@ -1,4 +1,3 @@
-import { type OnChanges } from '@angular/core';
 import { NgControl } from '@angular/forms';
 import { type TuiItemsHandlers } from '@taiga-ui/core/directives/items-handlers';
 import { type TuiInteractiveState } from '@taiga-ui/core/types';
@@ -7,30 +6,28 @@ import { type TuiTextfieldAccessor } from './textfield-accessor';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/native-validator";
 import * as i2 from "@taiga-ui/core/directives/appearance";
-export declare class TuiTextfieldBase<T> implements OnChanges, TuiTextfieldAccessor<T> {
-    private readonly focused;
+export declare class TuiTextfieldBase<T> implements TuiTextfieldAccessor<T> {
     protected readonly control: NgControl | null;
-    protected readonly a: import("@angular/core").WritableSignal<string>;
-    protected readonly s: import("@angular/core").WritableSignal<TuiInteractiveState | null>;
-    protected readonly m: import("@angular/core").WritableSignal<string | readonly string[] | null>;
+    protected readonly a: import("@angular/core").Signal<string>;
+    protected readonly s: import("@angular/core").Signal<TuiInteractiveState | null>;
+    protected readonly m: import("@angular/core").Signal<string | readonly string[] | null>;
     protected readonly f: import("@angular/core").Signal<boolean | null>;
     protected readonly el: HTMLInputElement;
     protected readonly handlers: TuiItemsHandlers<T>;
     protected readonly textfield: TuiTextfieldComponent<T>;
-    readOnly: boolean;
-    invalid: boolean | null;
+    readonly readOnly: import("@angular/core").InputSignal<boolean>;
+    readonly invalid: import("@angular/core").InputSignal<boolean | null>;
     readonly value: import("@angular/core").WritableSignal<string>;
-    set focusedSetter(focused: boolean | null);
-    set stateSetter(state: TuiInteractiveState | null);
-    get mode(): string | null;
-    ngOnChanges(): void;
+    readonly focused: import("@angular/core").InputSignal<boolean | null>;
+    readonly state: import("@angular/core").InputSignal<TuiInteractiveState | null>;
+    readonly mode: import("@angular/core").Signal<string | null>;
     setValue(value: T | null): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldBase<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldBase<any>, never, never, { "readOnly": { "alias": "readOnly"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "focusedSetter": { "alias": "focused"; "required": false; }; "stateSetter": { "alias": "state"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldBase<any>, never, never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "focused": { "alias": "focused"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 export declare class TuiTextfieldDirective<T> extends TuiTextfieldBase<T> {
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldDirective<any>, "input[tuiTextfield]:not([tuiInputCard]):not([tuiInputExpire]):not([tuiInputCVC])", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiAppearance; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldDirective<any>, "input[tuiTextfield]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiAppearance; inputs: {}; outputs: {}; }]>;
 }
 export declare class TuiWithTextfield {
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiWithTextfield, never>;

package/components/textfield/textfield.options.d.ts

@@ -1,21 +1,18 @@
-import { InjectionToken, type Provider, type WritableSignal } from '@angular/core';
+import { InjectionToken, type Provider, type Signal } from '@angular/core';
 import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export interface TuiTextfieldOptions {
-    readonly appearance: WritableSignal<string>;
-    readonly size: WritableSignal<TuiSizeL | TuiSizeS>;
-    readonly cleaner: WritableSignal<boolean>;
+    readonly appearance: Signal<string>;
+    readonly size: Signal<TuiSizeL | TuiSizeS>;
+    readonly cleaner: Signal<boolean>;
 }
 export declare const TUI_TEXTFIELD_OPTIONS: InjectionToken<TuiTextfieldOptions>;
 export declare function tuiTextfieldOptionsProvider(options: Partial<TuiTextfieldOptions>): Provider;
 export declare class TuiTextfieldOptionsDirective implements TuiTextfieldOptions {
     private readonly options;
-    appearance: WritableSignal<string>;
-    size: WritableSignal<"l" | "m" | "s">;
-    cleaner: WritableSignal<boolean>;
-    set tuiTextfieldAppearance(appearance: string);
-    set tuiTextfieldSize(size: TuiSizeL | TuiSizeS);
-    set tuiTextfieldCleaner(enabled: boolean);
+    readonly appearance: import("@angular/core").InputSignal<string>;
+    readonly size: import("@angular/core").InputSignalWithTransform<"l" | "m" | "s", "" | "l" | "m" | "s">;
+    readonly cleaner: import("@angular/core").InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldOptionsDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldOptionsDirective, "[tuiTextfieldAppearance],[tuiTextfieldSize],[tuiTextfieldCleaner]", never, { "tuiTextfieldAppearance": { "alias": "tuiTextfieldAppearance"; "required": false; }; "tuiTextfieldSize": { "alias": "tuiTextfieldSize"; "required": false; }; "tuiTextfieldCleaner": { "alias": "tuiTextfieldCleaner"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldOptionsDirective, "[tuiTextfieldAppearance],[tuiTextfieldSize],[tuiTextfieldCleaner]", never, { "appearance": { "alias": "tuiTextfieldAppearance"; "required": false; "isSignal": true; }; "size": { "alias": "tuiTextfieldSize"; "required": false; "isSignal": true; }; "cleaner": { "alias": "tuiTextfieldCleaner"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/appearance/appearance.directive.d.ts

@@ -1,21 +1,13 @@
 import { type TuiInteractiveState } from '@taiga-ui/core/types';
-import { type TuiAppearanceOptions } from './appearance.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/transitioned";
 export declare class TuiAppearance {
-    private readonly cdr;
-    private readonly el;
     protected readonly nothing: undefined;
     protected readonly modes: import("@angular/core").Signal<string | null>;
-    readonly appearance: import("@angular/core").WritableSignal<"accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "floating" | "glass" | "icon" | "info" | "negative" | "neutral" | "outline-destructive" | "outline-grayscale" | "outline" | "positive" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield" | "warning" | (Record<never, never> & string)>;
-    readonly state: import("@angular/core").WritableSignal<TuiInteractiveState | null>;
-    readonly focus: import("@angular/core").WritableSignal<boolean | null>;
-    readonly mode: import("@angular/core").WritableSignal<string | readonly string[] | null>;
-    readonly update: import("@angular/core").EffectRef;
-    set tuiAppearance(appearance: TuiAppearanceOptions['appearance']);
-    set tuiAppearanceState(state: TuiInteractiveState | null);
-    set tuiAppearanceFocus(focus: boolean | null);
-    set tuiAppearanceMode(mode: string | readonly string[] | null);
+    readonly tuiAppearance: import("@angular/core").InputSignal<"" | ("accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "floating" | "glass" | "icon" | "info" | "negative" | "neutral" | "outline-destructive" | "outline-grayscale" | "outline" | "positive" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield" | "warning" | (Record<never, never> & string))>;
+    readonly tuiAppearanceState: import("@angular/core").InputSignal<TuiInteractiveState | null>;
+    readonly tuiAppearanceFocus: import("@angular/core").InputSignal<boolean | null>;
+    readonly tuiAppearanceMode: import("@angular/core").InputSignal<string | readonly string[] | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAppearance, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAppearance, "[tuiAppearance]", never, { "tuiAppearance": { "alias": "tuiAppearance"; "required": false; }; "tuiAppearanceState": { "alias": "tuiAppearanceState"; "required": false; }; "tuiAppearanceFocus": { "alias": "tuiAppearanceFocus"; "required": false; }; "tuiAppearanceMode": { "alias": "tuiAppearanceMode"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiTransitioned; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAppearance, "[tuiAppearance]", never, { "tuiAppearance": { "alias": "tuiAppearance"; "required": false; "isSignal": true; }; "tuiAppearanceState": { "alias": "tuiAppearanceState"; "required": false; "isSignal": true; }; "tuiAppearanceFocus": { "alias": "tuiAppearanceFocus"; "required": false; "isSignal": true; }; "tuiAppearanceMode": { "alias": "tuiAppearanceMode"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiTransitioned; inputs: {}; outputs: {}; }]>;
 }

package/directives/appearance/appearance.options.d.ts

@@ -5,7 +5,7 @@ import { type TuiLooseUnion } from '@taiga-ui/cdk/types';
  */
 type Appearance = TuiLooseUnion<'accent' | 'action-destructive' | 'action-grayscale' | 'action' | 'flat-destructive' | 'flat-grayscale' | 'flat' | 'floating' | 'glass' | 'icon' | 'info' | 'negative' | 'neutral' | 'outline-destructive' | 'outline-grayscale' | 'outline' | 'positive' | 'primary-destructive' | 'primary-grayscale' | 'primary' | 'secondary-destructive' | 'secondary-grayscale' | 'secondary' | 'textfield' | 'warning'>;
 export interface TuiAppearanceOptions {
-    readonly appearance: Appearance;
+    readonly appearance: Appearance | '';
 }
 export declare const TUI_APPEARANCE_DEFAULT_OPTIONS: TuiAppearanceOptions;
 export declare const TUI_APPEARANCE_OPTIONS: InjectionToken<TuiAppearanceOptions>;

package/directives/dropdown/dropdown-content.directive.d.ts

@@ -0,0 +1,9 @@
+import { type OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TuiDropdownContent implements OnDestroy {
+    private readonly directive;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownContent, "ng-template[tuiDropdown]", never, {}, {}, never, never, true, never>;
+}

package/directives/dropdown/dropdown.d.ts

@@ -1,14 +1,14 @@
 import { TuiDropdownComponent } from './dropdown.component';
 import { TuiDropdownDirective } from './dropdown.directive';
 import { TuiDropdownDriverDirective } from './dropdown.driver';
+import { TuiDropdownContent } from './dropdown-content.directive';
 import { TuiDropdownContext } from './dropdown-context.directive';
 import { TuiDropdownHover } from './dropdown-hover.directive';
 import { TuiDropdownManual } from './dropdown-manual.directive';
 import { TuiDropdownOpen } from './dropdown-open.directive';
 import { TuiDropdownOpenLegacy } from './dropdown-open-legacy.directive';
 import { TuiDropdownOptionsDirective } from './dropdown-options.directive';
-import { TuiDropdownPortal } from './dropdown-portal.directive';
 import { TuiDropdownPosition } from './dropdown-position.directive';
 import { TuiDropdownPositionSided } from './dropdown-position-sided.directive';
 import { TuiDropdownSelection } from './dropdown-selection.directive';
-export declare const TuiDropdown: readonly [typeof TuiDropdownOptionsDirective, typeof TuiDropdownDriverDirective, typeof TuiDropdownDirective, typeof TuiDropdownComponent, typeof TuiDropdownOpen, typeof TuiDropdownOpenLegacy, typeof TuiDropdownPortal, typeof TuiDropdownManual, typeof TuiDropdownHover, typeof TuiDropdownContext, typeof TuiDropdownPosition, typeof TuiDropdownPositionSided, typeof TuiDropdownSelection];
+export declare const TuiDropdown: readonly [typeof TuiDropdownOptionsDirective, typeof TuiDropdownDriverDirective, typeof TuiDropdownDirective, typeof TuiDropdownComponent, typeof TuiDropdownOpen, typeof TuiDropdownOpenLegacy, typeof TuiDropdownManual, typeof TuiDropdownHover, typeof TuiDropdownContent, typeof TuiDropdownContext, typeof TuiDropdownPosition, typeof TuiDropdownPositionSided, typeof TuiDropdownSelection];

package/directives/dropdown/dropdown.directive.d.ts

@@ -1,12 +1,11 @@
 import { type AfterViewChecked, type ComponentRef, type OnDestroy } from '@angular/core';
 import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type TuiRectAccessor, type TuiVehicle } from '@taiga-ui/core/classes';
-import { type TuiPortalItem } from '@taiga-ui/core/types';
 import { PolymorpheusComponent, type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
 import * as i1 from "./dropdown.driver";
 import * as i2 from "./dropdown-position.directive";
-export declare class TuiDropdownDirective implements AfterViewChecked, OnDestroy, TuiPortalItem, TuiRectAccessor, TuiVehicle {
+export declare class TuiDropdownDirective implements AfterViewChecked, OnDestroy, TuiRectAccessor, TuiVehicle {
     private readonly refresh$;
     private readonly service;
     private readonly cdr;

package/directives/dropdown/index.d.ts

@@ -4,7 +4,7 @@ export * from './dropdown.component';
 export * from './dropdown.directive';
 export * from './dropdown.driver';
 export * from './dropdown.providers';
-export * from './dropdown.service';
+export * from './dropdown-content.directive';
 export * from './dropdown-context.directive';
 export * from './dropdown-hover.directive';
 export * from './dropdown-hover.options';
@@ -13,9 +13,7 @@ export * from './dropdown-manual.directive';
 export * from './dropdown-open.directive';
 export * from './dropdown-open-legacy.directive';
 export * from './dropdown-options.directive';
-export * from './dropdown-portal.directive';
 export * from './dropdown-position.directive';
 export * from './dropdown-position-sided.directive';
 export * from './dropdown-selection.directive';
-export * from './dropdowns.component';
 export * from './with-dropdown-open.directive';

package/directives/hint/hint-describe.directive.d.ts

@@ -3,14 +3,12 @@ import * as i0 from "@angular/core";
 export declare class TuiHintDescribe extends TuiDriver {
     private readonly doc;
     private readonly el;
-    private readonly zone;
-    private readonly id$;
-    private readonly stream$;
+    protected readonly element: import("@angular/core").Signal<Element>;
+    readonly id: import("@angular/core").InputSignal<string | null | undefined>;
     readonly type = "hint";
+    protected readonly stream$: import("rxjs").Observable<boolean>;
     constructor();
-    set tuiHintDescribe(id: string | null | undefined);
-    private get element();
     private get focused();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintDescribe, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintDescribe, "[tuiHintDescribe]", never, { "tuiHintDescribe": { "alias": "tuiHintDescribe"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintDescribe, "[tuiHintDescribe]", never, { "id": { "alias": "tuiHintDescribe"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/hint/hint-host.directive.d.ts

@@ -1,9 +1,9 @@
 import { TuiRectAccessor } from '@taiga-ui/core/classes';
 import * as i0 from "@angular/core";
 export declare class TuiHintHost extends TuiRectAccessor {
-    tuiHintHost?: HTMLElement;
+    readonly tuiHintHost: import("@angular/core").InputSignal<HTMLElement | undefined>;
     readonly type = "hint";
     getClientRect(): DOMRect;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintHost, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHost, "[tuiHint][tuiHintHost]", never, { "tuiHintHost": { "alias": "tuiHintHost"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHost, "[tuiHint][tuiHintHost]", never, { "tuiHintHost": { "alias": "tuiHintHost"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/hint/hint-hover.directive.d.ts

@@ -1,5 +1,4 @@
 import { TuiDriver } from '@taiga-ui/core/classes';
-import { type TuiHintOptions } from './hint-options.directive';
 import * as i0 from "@angular/core";
 export declare class TuiHintHover extends TuiDriver {
     private readonly isMobile;
@@ -10,13 +9,13 @@ export declare class TuiHintHover extends TuiDriver {
     private readonly toggle$;
     private readonly stream$;
     private readonly parent;
-    tuiHintShowDelay: TuiHintOptions['showDelay'];
-    tuiHintHideDelay: TuiHintOptions['hideDelay'];
+    readonly showDelay: import("@angular/core").InputSignal<number>;
+    readonly hideDelay: import("@angular/core").InputSignal<number>;
     readonly type = "hint";
     enabled: boolean;
     constructor();
     toggle(visible?: boolean): void;
     close(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintHover, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHover, never, ["tuiHintHover"], { "tuiHintShowDelay": { "alias": "tuiHintShowDelay"; "required": false; }; "tuiHintHideDelay": { "alias": "tuiHintHideDelay"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintHover, never, ["tuiHintHover"], { "showDelay": { "alias": "tuiHintShowDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "tuiHintHideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/hint/hint-manual.directive.d.ts

@@ -4,10 +4,10 @@ import * as i0 from "@angular/core";
 export declare class TuiHintManual extends TuiDriver implements OnChanges {
     private readonly hover;
     private readonly stream$;
-    tuiHintManual: boolean | null;
+    readonly visible: import("@angular/core").InputSignal<boolean | null>;
     readonly type = "hint";
     constructor();
     ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintManual, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintManual, "[tuiHint][tuiHintManual]", never, { "tuiHintManual": { "alias": "tuiHintManual"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintManual, "[tuiHint][tuiHintManual]", never, { "visible": { "alias": "tuiHintManual"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/hint/hint-options.directive.d.ts

@@ -1,11 +1,11 @@
 import { type FactoryProvider, InjectionToken, type OnChanges } from '@angular/core';
+import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 export type TuiHintDirection = 'bottom-left' | 'bottom-right' | 'bottom' | 'left-bottom' | 'left-top' | 'left' | 'right-bottom' | 'right-top' | 'right' | 'top-left' | 'top-right' | 'top';
 export declare const TUI_HINT_DIRECTIONS: readonly TuiHintDirection[];
-export interface TuiHintOptions {
-    readonly appearance: string;
+export interface TuiHintOptions extends TuiAppearanceOptions {
     readonly direction: TuiHintDirection | TuiHintDirection[];
     readonly hideDelay: number;
     readonly icon: string;
@@ -25,7 +25,7 @@ export declare class TuiHintOptionsDirective implements TuiHintOptions, OnChange
     private readonly options;
     content: PolymorpheusContent;
     direction: TuiHintDirection | TuiHintDirection[];
-    appearance: string;
+    appearance: "" | ("accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "floating" | "glass" | "icon" | "info" | "negative" | "neutral" | "outline-destructive" | "outline-grayscale" | "outline" | "positive" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield" | "warning" | (Record<never, never> & string));
     showDelay: number;
     hideDelay: number;
     icon: string;

package/directives/hint/hint-overflow.directive.d.ts

@@ -2,8 +2,8 @@ import * as i0 from "@angular/core";
 import * as i1 from "./hint.directive";
 export declare class TuiHintOverflow {
     private readonly hint;
-    tuiHintOverflow: string | null;
+    readonly content: import("@angular/core").InputSignal<string | null>;
     protected onMouseEnter({ scrollWidth, clientWidth, textContent }: Element): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintOverflow, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintOverflow, "[tuiHintOverflow]", never, { "tuiHintOverflow": { "alias": "tuiHintOverflow"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiHintDirective; inputs: { "tuiHintAppearance": "tuiHintAppearance"; }; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintOverflow, "[tuiHintOverflow]", never, { "content": { "alias": "tuiHintOverflow"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiHintDirective; inputs: { "tuiHintAppearance": "tuiHintAppearance"; }; outputs: {}; }]>;
 }

package/directives/hint/hint-position.directive.d.ts

@@ -1,7 +1,6 @@
-import { EventEmitter } from '@angular/core';
 import { TuiPositionAccessor } from '@taiga-ui/core/classes';
 import { type TuiPoint } from '@taiga-ui/core/types';
-import { type TuiHintDirection, type TuiHintOptions } from './hint-options.directive';
+import { type TuiHintDirection } from './hint-options.directive';
 import * as i0 from "@angular/core";
 export declare class TuiHintPosition extends TuiPositionAccessor {
     private readonly el;
@@ -9,13 +8,13 @@ export declare class TuiHintPosition extends TuiPositionAccessor {
     private readonly viewport;
     private readonly accessor;
     private readonly points;
-    direction: TuiHintOptions['direction'];
-    readonly directionChange: EventEmitter<TuiHintDirection>;
+    readonly direction: import("@angular/core").InputSignal<TuiHintDirection | TuiHintDirection[]>;
+    readonly directionChange: import("@angular/core").OutputEmitterRef<TuiHintDirection>;
     readonly type = "hint";
     emitDirection(direction: TuiHintDirection): void;
     getPosition(rect: DOMRect, el?: HTMLElement): TuiPoint;
     private get fallback();
     private checkPosition;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintPosition, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintPosition, never, never, { "direction": { "alias": "tuiHintDirection"; "required": false; }; }, { "directionChange": "tuiHintDirectionChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintPosition, never, never, { "direction": { "alias": "tuiHintDirection"; "required": false; "isSignal": true; }; }, { "directionChange": "tuiHintDirectionChange"; }, never, never, true, never>;
 }

package/directives/hint/hint-unstyled.component.d.ts

@@ -1,12 +1,7 @@
-import { type WritableSignal } from '@angular/core';
-import { type TuiContext } from '@taiga-ui/cdk/types';
-import { type TuiPortalItem } from '@taiga-ui/core/types';
-import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { TuiHintDirective } from './hint.directive';
 import * as i0 from "@angular/core";
 export declare class TuiHintUnstyledComponent {
-    protected readonly context: TuiContext<TuiPortalItem<any> & {
-        content: WritableSignal<PolymorpheusContent>;
-    }>;
+    protected readonly hint: TuiHintDirective<any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintUnstyledComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiHintUnstyledComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }

package/directives/hint/hint.component.d.ts

@@ -4,27 +4,26 @@ import { TuiPositionService } from '@taiga-ui/core/services';
 import { TuiHintDirective } from './hint.directive';
 import { TuiHintPointer } from './hint-pointer.directive';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/cdk/directives/animated";
+import * as i1 from "@taiga-ui/core/directives/appearance";
+import * as i2 from "@taiga-ui/cdk/directives/animated";
+import * as i3 from "@taiga-ui/cdk/directives/active-zone";
 export declare const TUI_HINT_PROVIDERS: (import("@angular/core").FactoryProvider | typeof TuiHoveredService | typeof TuiPositionService)[];
-export declare class TuiHintBaseComponent<C = any> {
+export declare class TuiHintComponent {
     private readonly el;
     private readonly hover;
     private readonly vvs;
     private readonly viewport;
     protected readonly pointer: TuiHintPointer | null;
     protected readonly accessor: TuiRectAccessor;
-    protected readonly hint: TuiHintDirective<C>;
+    protected readonly hint: TuiHintDirective<any>;
     protected readonly isMobile: boolean;
-    protected readonly content: import("@angular/core").WritableSignal<import("@taiga-ui/polymorpheus").PolymorpheusContent<C>>;
-    protected readonly appearance: string | null | undefined;
+    protected readonly content: import("@angular/core").InputSignal<import("@taiga-ui/polymorpheus").PolymorpheusContent<any>> | import("@angular/core").WritableSignal<string>;
+    protected readonly theme: string | null | undefined;
+    protected readonly appearance: import("@angular/core").Signal<string>;
     constructor();
     protected onClick(target: HTMLElement): void;
     private apply;
     private update;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintBaseComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiHintBaseComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
-}
-export declare class TuiHintComponent<C = any> extends TuiHintBaseComponent<C> {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiHintComponent<any>, "tui-hint", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiHintComponent, "tui-hint", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.TuiAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiAnimated; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiActiveZone; inputs: {}; outputs: {}; }]>;
 }

package/directives/hint/hint.directive.d.ts

@@ -1,26 +1,24 @@
-import { EventEmitter, type OnDestroy } from '@angular/core';
-import { TuiActiveZone } from '@taiga-ui/cdk/directives/active-zone';
+import { type OnChanges, type OnDestroy } from '@angular/core';
 import { type TuiRectAccessor, type TuiVehicle } from '@taiga-ui/core/classes';
-import { type TuiPortalItem } from '@taiga-ui/core/types';
 import { PolymorpheusComponent, type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
 import * as i1 from "./hint-driver.directive";
 import * as i2 from "./hint-hover.directive";
 import * as i3 from "./hint-position.directive";
-export declare class TuiHintDirective<C> implements OnDestroy, TuiPortalItem<C>, TuiRectAccessor, TuiVehicle {
+export declare class TuiHintDirective<C> implements OnDestroy, OnChanges, TuiRectAccessor, TuiVehicle {
     private readonly service;
-    context?: C;
-    appearance: string;
-    readonly visible: EventEmitter<boolean>;
-    content: import("@angular/core").WritableSignal<PolymorpheusContent<C>>;
+    private ref?;
+    readonly content: import("@angular/core").InputSignal<PolymorpheusContent<C>>;
+    readonly context: import("@angular/core").InputSignal<C | undefined>;
+    readonly appearance: import("@angular/core").InputSignal<"" | ("accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "floating" | "glass" | "icon" | "info" | "negative" | "neutral" | "outline-destructive" | "outline-grayscale" | "outline" | "positive" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield" | "warning" | (Record<never, never> & string))>;
+    readonly visible: import("@angular/core").OutputEmitterRef<boolean>;
     component: PolymorpheusComponent<any>;
     readonly el: HTMLElement;
-    readonly activeZone?: TuiActiveZone | null | undefined;
     readonly type = "hint";
-    set tuiHint(content: PolymorpheusContent<C>);
+    ngOnChanges(): void;
     ngOnDestroy(): void;
     getClientRect(): DOMRect;
     toggle(show: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintDirective<any>, "[tuiHint]:not(ng-container):not(ng-template)", never, { "context": { "alias": "tuiHintContext"; "required": false; }; "appearance": { "alias": "tuiHintAppearance"; "required": false; }; "tuiHint": { "alias": "tuiHint"; "required": false; }; }, { "visible": "tuiHintVisible"; }, never, never, true, [{ directive: typeof i1.TuiHintDriver; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiHintHover; inputs: { "tuiHintHideDelay": "tuiHintHideDelay"; "tuiHintShowDelay": "tuiHintShowDelay"; }; outputs: {}; }, { directive: typeof i3.TuiHintPosition; inputs: { "tuiHintDirection": "tuiHintDirection"; }; outputs: { "tuiHintDirectionChange": "tuiHintDirectionChange"; }; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHintDirective<any>, "[tuiHint]:not(ng-container):not(ng-template)", never, { "content": { "alias": "tuiHint"; "required": false; "isSignal": true; }; "context": { "alias": "tuiHintContext"; "required": false; "isSignal": true; }; "appearance": { "alias": "tuiHintAppearance"; "required": false; "isSignal": true; }; }, { "visible": "tuiHintVisible"; }, never, never, true, [{ directive: typeof i1.TuiHintDriver; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiHintHover; inputs: { "tuiHintHideDelay": "tuiHintHideDelay"; "tuiHintShowDelay": "tuiHintShowDelay"; }; outputs: {}; }, { directive: typeof i3.TuiHintPosition; inputs: { "tuiHintDirection": "tuiHintDirection"; }; outputs: { "tuiHintDirectionChange": "tuiHintDirectionChange"; }; }]>;
 }

package/directives/hint/index.d.ts

@@ -2,7 +2,6 @@ export * from './hint';
 export * from './hint.component';
 export * from './hint.directive';
 export * from './hint.providers';
-export * from './hint.service';
 export * from './hint-describe.directive';
 export * from './hint-driver.directive';
 export * from './hint-host.directive';
@@ -13,4 +12,3 @@ export * from './hint-overflow.directive';
 export * from './hint-pointer.directive';
 export * from './hint-position.directive';
 export * from './hint-unstyled.component';
-export * from './hints.component';