@taiga-ui/core 4.0.0-alpha.0 → 4.0.0-rc.10

package/components/alert/alert.component.d.ts

@@ -1,14 +1,13 @@
-import type { OnInit } from '@angular/core';
 import type { TuiPopover } from '@taiga-ui/cdk/services';
 import type { TuiAlertOptions } from './alert.interfaces';
 import * as i0 from "@angular/core";
-export declare class TuiAlert<O, I> implements OnInit {
+export declare class TuiAlertComponent<O, I> {
     private readonly el;
-    private readonly destroyRef;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly options: import("@angular/animations").AnimationOptions;
+    protected readonly close: import("@angular/core").Signal<string | undefined>;
     protected readonly position: string;
     protected readonly item: TuiPopover<TuiAlertOptions<I>, O>;
-    protected readonly autoClose: number;
-    protected readonly options: import("@angular/animations").AnimationOptions;
     protected readonly animation: {
         value: string;
         delay?: string | number | undefined;
@@ -16,9 +15,7 @@ export declare class TuiAlert<O, I> implements OnInit {
             [name: string]: any;
         } | undefined;
     };
-    ngOnInit(): void;
-    protected close(): void;
-    private initAutoClose;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlert<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAlert<any, any>, "tui-alert", never, {}, {}, never, never, true, never>;
+    protected readonly sub: import("rxjs").Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlertComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAlertComponent<any, any>, "tui-alert", never, {}, {}, never, never, true, never>;
 }

package/components/alert/alert.directive.d.ts

@@ -1,7 +1,7 @@
 import { TuiPopoverDirective } from '@taiga-ui/cdk/directives/popover';
 import type { TuiAlertOptions } from './alert.interfaces';
 import * as i0 from "@angular/core";
-export declare class TuiAlertDirective<T> extends TuiPopoverDirective<TuiAlertOptions<T>> {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlertDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAlertDirective<any>, "ng-template[tuiAlert]", never, { "options": { "alias": "tuiAlertOptions"; "required": false; }; "open": { "alias": "tuiAlert"; "required": false; }; }, { "openChange": "tuiAlertChange"; }, never, never, true, never>;
+export declare class TuiAlert<T> extends TuiPopoverDirective<TuiAlertOptions<T>> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlert<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAlert<any>, "ng-template[tuiAlert]", never, { "options": { "alias": "tuiAlertOptions"; "required": false; }; "open": { "alias": "tuiAlert"; "required": false; }; }, { "openChange": "tuiAlertChange"; }, never, never, true, never>;
 }

package/components/alert/alert.interfaces.d.ts

@@ -1,10 +1,9 @@
 import type { TuiPopoverContext } from '@taiga-ui/cdk/services';
 import type { TuiHandler } from '@taiga-ui/cdk/types';
-import type { TuiNotificationOptions, TuiNotificationStatus } from '@taiga-ui/core/components/notification';
+import type { TuiNotificationOptions } from '@taiga-ui/core/components/notification';
 import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
-export type TuiAlertAutoClose = TuiHandler<TuiNotificationStatus, number> | number;
 export interface TuiAlertOptions<I = undefined> extends Omit<TuiNotificationOptions, 'size'> {
-    readonly autoClose: TuiAlertAutoClose;
+    readonly autoClose: TuiHandler<string, number> | number;
     readonly data: I;
     readonly closeable: boolean;
     readonly label: PolymorpheusContent<TuiAlertOptions<I>>;

package/components/alert/alert.tokens.d.ts

@@ -1,6 +1,6 @@
 import { BehaviorSubject } from 'rxjs';
 import type { TuiAlertOptions } from './alert.interfaces';
-export declare const TUI_ALERT_DEFAULT_OPTIONS: Omit<TuiAlertOptions, 'icon' | 'status'>;
+export declare const TUI_ALERT_DEFAULT_OPTIONS: Omit<TuiAlertOptions, 'appearance' | 'icon'>;
 export declare const TUI_ALERT_OPTIONS: import("@angular/core").InjectionToken<TuiAlertOptions<undefined>>;
 export declare const TUI_ALERT_POSITION: import("@angular/core").InjectionToken<string>;
 export declare const TUI_ALERTS: import("@angular/core").InjectionToken<BehaviorSubject<readonly any[]>>;

package/components/calendar/calendar-sheet.component.d.ts

@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
 export type TuiMarkerHandler = TuiHandler<TuiDay, [] | [string, string] | [string]>;
 export declare class TuiCalendarSheet {
     private readonly today;
-    protected readonly unorderedWeekDays$: import("rxjs").Observable<[string, string, string, string, string, string, string]>;
+    protected readonly unorderedWeekDays$: import("rxjs").Observable<[Monday: string, Tuesday: string, Wednesday: string, Thursday: string, Friday: string, Saturday: string, Sunday: string]>;
     protected readonly dayTypeHandler: TuiHandler<TuiDay, string>;
     month: TuiMonth;
     disabledItemHandler: TuiBooleanHandler<TuiDay>;

package/components/data-list/data-list.component.d.ts

@@ -1,20 +1,21 @@
+import type { AfterContentChecked } from '@angular/core';
 import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
 import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
-import type { Observable } from 'rxjs';
 import type { TuiDataListAccessor } from './data-list.tokens';
 import * as i0 from "@angular/core";
 export declare function tuiInjectDataListSize(): TuiSizeL | TuiSizeS;
-export declare class TuiDataListComponent<T> implements TuiDataListAccessor<T> {
+export declare class TuiDataListComponent<T> implements TuiDataListAccessor<T>, AfterContentChecked {
     private readonly options;
     private origin?;
     private readonly el;
-    protected readonly defaultEmptyContent$: Observable<string>;
+    protected readonly fallback: import("@angular/core").Signal<string | undefined>;
+    protected empty: boolean;
     emptyContent: PolymorpheusContent;
     size: "m" | "l" | "s";
     onKeyDownArrow(current: HTMLElement, step: number): void;
     handleFocusLossIfNecessary(element?: Element): void;
+    ngAfterContentChecked(): void;
     getOptions(includeDisabled?: boolean): readonly T[];
-    protected get empty$(): Observable<boolean>;
     protected onFocusIn(relatedTarget: HTMLElement, currentTarget: HTMLElement): void;
     protected noop(): void;
     private get elements();

package/components/data-list/data-list.tokens.d.ts

@@ -8,7 +8,7 @@ export interface TuiDataListAccessor<T = unknown> {
 }
 export interface TuiDataListHost<T> {
     checkOption?(option: T): void;
-    handleOption(option: T): void;
+    handleOption?(option: T): void;
     readonly identityMatcher?: TuiIdentityMatcher<T>;
     readonly stringify?: TuiStringHandler<T>;
     readonly size?: TuiSizeL | TuiSizeS;
@@ -27,4 +27,4 @@ export declare function tuiAsDataListAccessor(accessor: Type<TuiDataListAccessor
  * DataList controller
  */
 export declare const TUI_DATA_LIST_HOST: InjectionToken<TuiDataListHost<unknown>>;
-export declare function tuiAsDataListHost(host: Type<TuiDataListHost<unknown>>): Provider;
+export declare function tuiAsDataListHost<T>(host: Type<TuiDataListHost<T>>): Provider;

package/components/data-list/index.d.ts

@@ -4,4 +4,3 @@ export * from './data-list.directive';
 export * from './data-list.tokens';
 export * from './opt-group.directive';
 export * from './option.component';
-export * from './with-data-list.directive';

package/components/data-list/option.component.d.ts

@@ -1,6 +1,5 @@
 import type { OnDestroy, TemplateRef } from '@angular/core';
 import type { TuiContext } from '@taiga-ui/cdk/types';
-import { TuiDropdownDirective } from '@taiga-ui/core/directives/dropdown';
 import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/icons";
@@ -10,11 +9,10 @@ export declare class TuiOption<T = unknown> implements OnDestroy {
     private readonly dataList;
     private readonly host;
     protected readonly content: PolymorpheusContent<TuiContext<TemplateRef<Record<string, unknown>>>>;
-    protected readonly dropdown: TuiDropdownDirective | null;
+    protected readonly dropdown: import("@angular/core").WritableSignal<import("@angular/core").ComponentRef<unknown> | null> | undefined;
     disabled: boolean;
     value?: T;
     ngOnDestroy(): void;
-    protected get active(): boolean;
     protected onClick(): void;
     protected onMouseMove(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiOption<any>, never>;

package/components/dialog/dialog.directive.d.ts

@@ -1,7 +1,7 @@
 import { TuiPopoverDirective } from '@taiga-ui/cdk/directives/popover';
 import type { TuiDialogOptions } from './dialog.interfaces';
 import * as i0 from "@angular/core";
-export declare class TuiDialogDirective<T> extends TuiPopoverDirective<TuiDialogOptions<T>> {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDialogDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDialogDirective<any>, "ng-template[tuiDialog]", never, { "options": { "alias": "tuiDialogOptions"; "required": false; }; "open": { "alias": "tuiDialog"; "required": false; }; }, { "openChange": "tuiDialogChange"; }, never, never, true, never>;
+export declare class TuiDialog<T> extends TuiPopoverDirective<TuiDialogOptions<T>> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDialog<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDialog<any>, "ng-template[tuiDialog]", never, { "options": { "alias": "tuiDialogOptions"; "required": false; }; "open": { "alias": "tuiDialog"; "required": false; }; }, { "openChange": "tuiDialogChange"; }, never, never, true, never>;
 }

package/components/dialog/index.d.ts

@@ -1,4 +1,3 @@
-export * from './dialog';
 export * from './dialog.component';
 export * from './dialog.directive';
 export * from './dialog.interfaces';

package/components/group/group.directive.d.ts

@@ -1,4 +1,5 @@
-import type { TuiOrientation, TuiSizeL } from '@taiga-ui/core/types';
+import type { Signal } from '@angular/core';
+import type { TuiOrientation, TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiGroup {
     private readonly options;
@@ -6,7 +7,8 @@ export declare class TuiGroup {
     orientation: TuiOrientation;
     collapsed: boolean;
     rounded: boolean;
-    size: TuiSizeL;
+    size: TuiSizeL | TuiSizeS;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiGroup, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiGroup, "[tuiGroup]:not(ng-container)", never, { "orientation": { "alias": "orientation"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
 }
+export declare function tuiGroupSize(signal: Signal<TuiSizeL | TuiSizeS>): Signal<TuiSizeL | TuiSizeS>;

package/components/notification/index.d.ts

@@ -1,2 +1,2 @@
-export * from './notification.component';
+export * from './notification.directive';
 export * from './notification.options';

package/components/notification/notification.directive.d.ts

@@ -0,0 +1,19 @@
+import type { OnChanges, OnInit } from '@angular/core';
+import type { TuiStringHandler } from '@taiga-ui/cdk/types';
+import { TuiIcons } from '@taiga-ui/core/directives/icons';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/icons";
+import * as i2 from "@taiga-ui/core/directives/appearance";
+export declare class TuiNotification implements OnChanges, OnInit {
+    private readonly options;
+    protected readonly nothing: undefined;
+    protected readonly icons: TuiIcons;
+    appearance: string;
+    icon: TuiStringHandler<string> | string;
+    size: "m" | "l" | "s";
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    private refresh;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNotification, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNotification, "tui-notification,a[tuiNotification],button[tuiNotification]", never, { "appearance": { "alias": "appearance"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithIcons; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithAppearance; inputs: {}; outputs: {}; }]>;
+}

package/components/notification/notification.options.d.ts

@@ -1,11 +1,9 @@
 import type { Provider } from '@angular/core';
-import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiStringHandler } from '@taiga-ui/cdk/types';
+import type { TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
-import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
-export type TuiNotificationStatus = 'error' | 'info' | 'neutral' | 'success' | 'warning';
-export interface TuiNotificationOptions {
-    readonly status: TuiNotificationStatus;
-    readonly icon: PolymorpheusContent<TuiContext<TuiNotificationStatus>>;
+export interface TuiNotificationOptions extends TuiAppearanceOptions {
+    readonly icon: TuiStringHandler<string> | string;
     readonly size: TuiSizeL | TuiSizeS;
 }
 /** Default values for the notification options. */

package/components/scrollbar/index.d.ts

@@ -4,4 +4,5 @@ export * from './scroll-ref.directive';
 export * from './scrollable.directive';
 export * from './scrollbar.component';
 export * from './scrollbar.directive';
+export * from './scrollbar.options';
 export * from './scrollbar.service';

package/components/scrollbar/scrollbar.component.d.ts

@@ -11,6 +11,7 @@ export declare const TUI_SCROLL_INTO_VIEW = "tui-scroll-into-view";
 export declare const TUI_SCROLLABLE = "tui-scrollable";
 export declare class TuiScrollbar {
     private readonly el;
+    protected readonly options: import("./scrollbar.options").TuiScrollbarOptions;
     protected readonly isIOS: boolean;
     protected readonly browserScrollRef: ElementRef<HTMLElement>;
     hidden: boolean;

package/components/scrollbar/scrollbar.options.d.ts

@@ -0,0 +1,7 @@
+import type { Provider } from '@angular/core';
+export interface TuiScrollbarOptions {
+    mode: 'always' | 'hover';
+}
+export declare const TUI_DEFAULT_SCROLLBAR_OPTIONS: TuiScrollbarOptions;
+export declare const TUI_SCROLLBAR_OPTIONS: import("@angular/core").InjectionToken<TuiScrollbarOptions>;
+export declare function tuiScrollbarOptionsProvider(options: Partial<TuiScrollbarOptions>): Provider;

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

@@ -2,7 +2,7 @@ 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<[string, string]>;
+    protected readonly spinTexts$: import("rxjs").Observable<[previous: string, next: string]>;
     focusable: boolean;
     disabled: boolean;
     leftDisabled: boolean;

package/components/textfield/index.d.ts

@@ -2,4 +2,5 @@ export * from './textfield';
 export * from './textfield.component';
 export * from './textfield.directive';
 export * from './textfield.options';
+export * from './textfield-dropdown.directive';
 export * from './select.directive';

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

@@ -0,0 +1,12 @@
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class TuiTextfieldDropdownDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldDropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldDropdownDirective, "ng-template[tuiTextfieldDropdown]", never, {}, {}, never, never, true, never>;
+}
+export declare class TuiWithTextfieldDropdown {
+    private readonly dropdown;
+    protected set template(template: PolymorpheusContent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiWithTextfieldDropdown, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiWithTextfieldDropdown, never, never, {}, {}, ["template"], never, true, never>;
+}

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

@@ -7,31 +7,27 @@ import { TuiTextfieldDirective } from './textfield.directive';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/native-validator";
 import * as i2 from "@taiga-ui/core/directives/dropdown";
-import * as i3 from "@taiga-ui/core/components/data-list";
+import * as i3 from "./textfield-dropdown.directive";
 import * as i4 from "@taiga-ui/core/directives/icons";
-export interface TuiTextfieldContext<T> extends TuiContext<T> {
-    readonly active: boolean;
-}
 export declare class TuiTextfieldComponent<T> implements TuiDataListHost<T> {
-    private readonly el?;
-    private readonly dropdown;
+    private readonly open;
+    private readonly focusedIn;
     protected readonly directive?: TuiTextfieldDirective;
     protected readonly label?: ElementRef<HTMLElement>;
+    protected readonly control?: NgControl;
     protected side: number;
-    protected readonly change$: import("rxjs").Subject<void> | undefined;
     protected readonly options: import("./textfield.options").TuiTextfieldOptions;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    protected readonly control: NgControl | null;
+    readonly el?: ElementRef<HTMLInputElement>;
     filler: string;
     stringify: TuiStringHandler<T>;
-    content: PolymorpheusContent<TuiTextfieldContext<T>>;
-    get input(): HTMLInputElement;
+    content: PolymorpheusContent<TuiContext<T>>;
+    readonly focused: import("@angular/core").Signal<boolean>;
     get id(): string;
-    get focused(): boolean;
     handleOption(option: T): void;
     protected get computedFiller(): string;
     protected get showFiller(): boolean;
     protected get hasLabel(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldComponent<any>, "tui-textfield", never, { "filler": { "alias": "filler"; "required": false; }; "stringify": { "alias": "stringify"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, ["el", "directive", "label"], ["input", "select", "label", "*", "tui-icon"], true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithDataList; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownOpen; inputs: { "tuiDropdownOpen": "open"; }; outputs: { "tuiDropdownOpenChange": "openChange"; }; }, { directive: typeof i4.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldComponent<any>, "tui-textfield", never, { "filler": { "alias": "filler"; "required": false; }; "stringify": { "alias": "stringify"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, ["directive", "label", "control", "el"], ["input", "select", "label", "*", "tui-icon"], true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithTextfieldDropdown; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithIcons; inputs: {}; outputs: {}; }]>;
 }

package/components/textfield/textfield.d.ts

@@ -3,4 +3,5 @@ import { TuiSelect } from './select.directive';
 import { TuiTextfieldComponent } from './textfield.component';
 import { TuiTextfieldDirective } from './textfield.directive';
 import { TuiTextfieldOptionsDirective } from './textfield.options';
-export declare const TuiTextfield: readonly [typeof TuiLabel, typeof TuiSelect, typeof TuiTextfieldComponent, typeof TuiTextfieldDirective, typeof TuiTextfieldOptionsDirective];
+import { TuiTextfieldDropdownDirective } from './textfield-dropdown.directive';
+export declare const TuiTextfield: readonly [typeof TuiLabel, typeof TuiSelect, typeof TuiTextfieldComponent, typeof TuiTextfieldDirective, typeof TuiTextfieldOptionsDirective, typeof TuiTextfieldDropdownDirective];

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

@@ -1,24 +1,24 @@
-import type { DoCheck } from '@angular/core';
 import type { TuiInteractiveState } from '@taiga-ui/core/types';
 import { TuiTextfieldComponent } from './textfield.component';
 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 implements DoCheck {
-    private readonly appearance;
-    private readonly options;
+export declare class TuiTextfieldBase {
+    private readonly focused;
+    protected readonly a: import("@angular/core").WritableSignal<string>;
+    protected readonly s: import("@angular/core").WritableSignal<TuiInteractiveState | null>;
+    protected readonly f: import("@angular/core").Signal<boolean | null>;
     protected readonly textfield: TuiTextfieldComponent<any>;
     protected readonly id: string;
     protected readonly el: HTMLInputElement;
     readOnly: boolean;
     invalid: boolean | null;
-    focused: boolean | null;
-    state: TuiInteractiveState | null;
+    set focusedSetter(focused: boolean | null);
+    set stateSetter(state: TuiInteractiveState | null);
     get mode(): string | null;
-    ngDoCheck(): void;
     setValue(value: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldBase, never, never, { "readOnly": { "alias": "readOnly"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "focused": { "alias": "focused"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTextfieldBase, never, never, { "readOnly": { "alias": "readOnly"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "focusedSetter": { "alias": "focused"; "required": false; }; "stateSetter": { "alias": "state"; "required": false; }; }, {}, never, never, false, never>;
 }
 export declare class TuiTextfieldDirective extends TuiTextfieldBase {
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldDirective, never>;

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

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

package/directives/appearance/appearance.bindings.d.ts

@@ -0,0 +1,12 @@
+import type { Signal, WritableSignal } from '@angular/core';
+import type { TuiInteractiveState } from '@taiga-ui/core/types';
+type A = string;
+type S = TuiInteractiveState | null;
+type F = boolean | null;
+export declare function tuiAppearance(value: A | WritableSignal<A>): WritableSignal<A>;
+export declare function tuiAppearance(value: Signal<A>): Signal<A>;
+export declare function tuiAppearanceState(value: S | WritableSignal<S>): WritableSignal<S>;
+export declare function tuiAppearanceState(value: Signal<S>): Signal<S>;
+export declare function tuiAppearanceFocus(value: F | WritableSignal<F>): WritableSignal<F>;
+export declare function tuiAppearanceFocus(value: Signal<F>): Signal<F>;
+export {};

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

@@ -1,6 +1,7 @@
 import type { TuiInteractiveState } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiAppearance {
+    protected readonly nothing: undefined;
     tuiAppearance: string;
     tuiAppearanceState: TuiInteractiveState | null;
     tuiAppearanceFocus: boolean | null;

package/directives/appearance/index.d.ts

@@ -1,3 +1,4 @@
+export * from './appearance.bindings';
 export * from './appearance.directive';
 export * from './appearance.options';
 export * from './with-appearance';

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

@@ -2,13 +2,20 @@ import { TuiActiveZone } from '@taiga-ui/cdk/directives/active-zone';
 import { TuiRectAccessor } from '@taiga-ui/core/classes';
 import * as i0 from "@angular/core";
 export declare class TuiDropdownContext extends TuiRectAccessor {
+    private readonly isIOS;
+    private readonly isTouch;
     private readonly driver;
     private currentRect;
+    private longTapTimeout;
+    protected readonly userSelect: import("@angular/core").Signal<"none" | null>;
     protected readonly activeZone: TuiActiveZone;
     readonly type = "dropdown";
     getClientRect(): DOMRect;
     protected onContextMenu(x: number, y: number): void;
     protected closeDropdown(): void;
+    protected onTouchStart(x: number, y: number): void;
+    protected onTouchMove(x: number, y: number): void;
+    protected onTouchEnd(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownContext, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownContext, "[tuiDropdownContext]", never, {}, {}, never, never, true, never>;
 }

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

@@ -2,7 +2,7 @@ import type { OnChanges } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiDropdownManual implements OnChanges {
     private readonly driver;
-    tuiDropdownManual: boolean;
+    tuiDropdownManual: boolean | '';
     ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownManual, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownManual, "[tuiDropdownManual]", never, { "tuiDropdownManual": { "alias": "tuiDropdownManual"; "required": false; }; }, {}, never, never, true, never>;

package/directives/dropdown/dropdown-open-legacy.directive.d.ts

@@ -0,0 +1,11 @@
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated TODO: remove in v.5 when legacy controls are dropped
+ */
+export declare class TuiDropdownOpenLegacy {
+    readonly tuiDropdownOpenChange: BehaviorSubject<boolean>;
+    set tuiDropdownOpen(open: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownOpenLegacy, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownOpenLegacy, "[tuiDropdownOpen]:not([tuiDropdown]),[tuiDropdownOpenChange]:not([tuiDropdown])", never, { "tuiDropdownOpen": { "alias": "tuiDropdownOpen"; "required": false; }; }, { "tuiDropdownOpenChange": "tuiDropdownOpenChange"; }, never, never, true, never>;
+}

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

@@ -9,13 +9,12 @@ export declare class TuiDropdownOpen implements OnChanges {
     private readonly directive;
     private readonly el;
     private readonly obscured;
+    private readonly dropdown;
     protected readonly sub: import("rxjs").Subscription;
     tuiDropdownEnabled: boolean;
     tuiDropdownOpen: boolean | '';
     readonly tuiDropdownOpenChange: EventEmitter<boolean>;
     readonly driver: TuiDropdownDriver;
-    get dropdown(): HTMLElement | undefined;
-    get focused(): boolean;
     ngOnChanges(): void;
     toggle(open: boolean): void;
     protected onClick(target: HTMLElement): void;
@@ -24,9 +23,10 @@ export declare class TuiDropdownOpen implements OnChanges {
     protected onKeydown({ key, target, defaultPrevented }: KeyboardEvent): void;
     private get host();
     private get editable();
+    private get focused();
     private update;
     private drive;
     private focusDropdown;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownOpen, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownOpen, "[tuiDropdownOpen],[tuiDropdownOpenChange]", never, { "tuiDropdownEnabled": { "alias": "tuiDropdownEnabled"; "required": false; }; "tuiDropdownOpen": { "alias": "tuiDropdownOpen"; "required": false; }; }, { "tuiDropdownOpenChange": "tuiDropdownOpenChange"; }, ["dropdownHost"], never, true, [{ directive: typeof i1.TuiObscured; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiActiveZone; inputs: { "tuiActiveZoneParent": "tuiActiveZoneParent"; }; outputs: { "tuiActiveZoneChange": "tuiActiveZoneChange"; }; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownOpen, "[tuiDropdown][tuiDropdownOpen],[tuiDropdown][tuiDropdownOpenChange]", never, { "tuiDropdownEnabled": { "alias": "tuiDropdownEnabled"; "required": false; }; "tuiDropdownOpen": { "alias": "tuiDropdownOpen"; "required": false; }; }, { "tuiDropdownOpenChange": "tuiDropdownOpenChange"; }, ["dropdownHost"], never, true, [{ directive: typeof i1.TuiObscured; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiActiveZone; inputs: { "tuiActiveZoneParent": "tuiActiveZoneParent"; }; outputs: { "tuiActiveZoneChange": "tuiActiveZoneChange"; }; }]>;
 }

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

@@ -6,7 +6,7 @@ export declare class TuiDropdownPosition extends TuiPositionAccessor {
     private readonly viewport;
     private previous?;
     readonly type = "dropdown";
-    readonly accessor: TuiRectAccessor;
+    readonly accessor: TuiRectAccessor | null;
     getPosition({ width, height }: DOMRect): TuiPoint;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownPosition, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDropdownPosition, "[tuiDropdownPosition]", never, {}, {}, never, never, true, never>;

package/directives/dropdown/dropdown.bindings.d.ts

@@ -0,0 +1,7 @@
+import type { Signal, WritableSignal } from '@angular/core';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+type C = PolymorpheusContent;
+export declare function tuiDropdown(value: C | WritableSignal<C>): WritableSignal<C>;
+export declare function tuiDropdown(value: Signal<C>): Signal<C>;
+export declare function tuiDropdownOpen(): WritableSignal<boolean>;
+export {};

package/directives/dropdown/dropdown.component.d.ts

@@ -1,4 +1,3 @@
-import type { OnInit } from '@angular/core';
 import { TuiDropdownDirective } from './dropdown.directive';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/active-zone";
@@ -7,7 +6,7 @@ import * as i1 from "@taiga-ui/cdk/directives/active-zone";
  * This component is used to show template in a portal
  * using default style of white rounded box with a shadow
  */
-export declare class TuiDropdownComponent implements OnInit {
+export declare class TuiDropdownComponent {
     private readonly el;
     private readonly accessor;
     private readonly win;
@@ -18,10 +17,8 @@ export declare class TuiDropdownComponent implements OnInit {
     protected readonly context: Record<any, any> | null;
     protected readonly theme: string | null | undefined;
     protected readonly sub: import("rxjs").Subscription;
-    ngOnInit(): void;
     protected readonly close: () => void;
-    private update;
-    private updateWidth;
+    private getStyles;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDropdownComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiDropdownComponent, "tui-dropdown", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiActiveZone; inputs: {}; outputs: {}; }]>;
 }

package/directives/dropdown/dropdown.d.ts

@@ -5,9 +5,10 @@ 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 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 TuiDropdownPortal, typeof TuiDropdownManual, typeof TuiDropdownHover, typeof TuiDropdownContext, typeof TuiDropdownPosition, typeof TuiDropdownPositionSided, typeof TuiDropdownSelection];

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

@@ -15,7 +15,7 @@ export declare class TuiDropdownDirective implements AfterViewChecked, OnDestroy
     readonly el: HTMLElement;
     readonly type = "dropdown";
     readonly component: PolymorpheusComponent<any>;
-    dropdownBoxRef: ComponentRef<unknown> | null;
+    ref: import("@angular/core").WritableSignal<ComponentRef<unknown> | null>;
     content: PolymorpheusContent<TuiContext<() => void>>;
     set tuiDropdown(content: PolymorpheusContent<TuiContext<() => void>>);
     get position(): 'absolute' | 'fixed';

package/directives/dropdown/index.d.ts

@@ -1,4 +1,5 @@
 export * from './dropdown';
+export * from './dropdown.bindings';
 export * from './dropdown.component';
 export * from './dropdown.directive';
 export * from './dropdown.driver';
@@ -9,9 +10,11 @@ export * from './dropdown-hover.directive';
 export * from './dropdown-hover.options';
 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/dropdown/with-dropdown-open.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dropdown-open.directive";
+export declare class TuiWithDropdownOpen {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiWithDropdownOpen, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiWithDropdownOpen, never, never, {}, {}, never, never, true, [{ directive: typeof i1.TuiDropdownOpen; inputs: { "tuiDropdownOpen": "open"; }; outputs: { "tuiDropdownOpenChange": "openChange"; }; }]>;
+}