@taiga-ui/core 4.52.0-canary.56739a2 → 4.52.0-canary.58fe47a

package/components/modal/modal.service.d.ts

@@ -0,0 +1,13 @@
+import { type Type } from '@angular/core';
+import { TuiPortal } from '@taiga-ui/cdk/portals';
+import { PolymorpheusComponent } from '@taiga-ui/polymorpheus';
+import { TuiModalComponent } from './modal.component';
+import * as i0 from "@angular/core";
+export declare abstract class TuiModalService<T, K = void> extends TuiPortal<T, K> {
+    protected abstract readonly content: Type<unknown>;
+    protected readonly component: typeof TuiModalComponent;
+    constructor();
+    protected add(component: PolymorpheusComponent<TuiModalComponent<T>>): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiModalService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiModalService<any, any>>;
+}

package/components/notification/index.d.ts

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

package/components/notification/notification.component.d.ts

@@ -0,0 +1,14 @@
+import { type TuiPortalContext } from '@taiga-ui/cdk/portals';
+import { type TuiNotificationOptions } from './notification.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/cdk/directives/animated";
+import * as i2 from "@taiga-ui/core/directives/alert";
+export declare class TuiNotificationComponent<O, I> {
+    private readonly el;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly close: import("@angular/core").Signal<string>;
+    protected readonly item: TuiPortalContext<TuiNotificationOptions<I>, O>;
+    protected readonly sub: import("rxjs").Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNotificationComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiNotificationComponent<any, any>, "tui-notification-alert", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiAlertDirective; inputs: {}; outputs: {}; }]>;
+}

package/components/notification/notification.d.ts

@@ -0,0 +1,3 @@
+import { TuiNotificationDirective } from './notification.directive';
+import { TuiNotificationTemplate } from './notification.service';
+export declare const TuiNotification: readonly [typeof TuiNotificationDirective, typeof TuiNotificationTemplate];

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

@@ -1,19 +1,14 @@
-import { type OnChanges, type 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 {
+export declare class TuiNotificationDirective {
     private readonly options;
     protected readonly nothing: undefined;
-    protected readonly icons: TuiIcons;
-    appearance: "info" | "positive" | "negative" | "warning" | "neutral" | "accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "floating" | "glass" | "icon" | "outline-destructive" | "outline-grayscale" | "outline" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield" | (Record<never, never> & 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: {}; }]>;
+    protected readonly icons: import("@angular/core").Signal<string>;
+    readonly appearance: import("@angular/core").InputSignal<"" | ("info" | "positive" | "negative" | "warning" | "neutral" | "accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "floating" | "glass" | "icon" | "outline-destructive" | "outline-grayscale" | "outline" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield" | (Record<never, never> & string))>;
+    readonly size: import("@angular/core").InputSignal<"m" | "l" | "s">;
+    readonly icon: import("@angular/core").InputSignal<string | TuiStringHandler<string>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNotificationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNotificationDirective, "tui-notification,[tuiNotification]:not(ng-template)", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithIcons; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithAppearance; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,13 +1,16 @@
-import { type TuiStringHandler } from '@taiga-ui/cdk/types';
+import { InjectionToken } from '@angular/core';
+import { type TuiNumberHandler, type TuiStringHandler } from '@taiga-ui/cdk/types';
+import { type TuiPositionOptions } from '@taiga-ui/core/directives/alert';
 import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
-export interface TuiNotificationOptions extends TuiAppearanceOptions {
+export interface TuiNotificationOptions<I = undefined> extends TuiAppearanceOptions, TuiPositionOptions {
     readonly icon: TuiStringHandler<string> | string;
     readonly size: TuiSizeL | TuiSizeS;
+    readonly autoClose: TuiNumberHandler<string> | number;
+    readonly closable: boolean;
+    readonly label: string;
+    readonly data: I;
 }
-/** Default values for the notification options. */
 export declare const TUI_NOTIFICATION_DEFAULT_OPTIONS: TuiNotificationOptions;
-/**
- * Default parameters for notification alert component
- */
-export declare const TUI_NOTIFICATION_OPTIONS: import("@angular/core").InjectionToken<TuiNotificationOptions>, tuiNotificationOptionsProvider: (item: Partial<TuiNotificationOptions> | import("@angular/core").ProviderToken<Partial<TuiNotificationOptions>> | (() => Partial<TuiNotificationOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_NOTIFICATION_OPTIONS: InjectionToken<TuiNotificationOptions<undefined>>, tuiNotificationOptionsProvider: (item: Partial<TuiNotificationOptions<undefined>> | (() => Partial<TuiNotificationOptions<undefined>>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_NOTIFICATION_CONCURRENCY: InjectionToken<number>;

package/components/notification/notification.service.d.ts

@@ -0,0 +1,17 @@
+import { TuiAlertService } from '@taiga-ui/core/directives/alert';
+import { TuiNotificationComponent } from './notification.component';
+import { type TuiNotificationOptions } from './notification.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/cdk/portals";
+export declare class TuiNotificationService extends TuiAlertService<TuiNotificationOptions<any>> {
+    protected readonly options: TuiNotificationOptions<undefined>;
+    protected readonly component: typeof TuiNotificationComponent;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiNotificationService>;
+}
+export declare class TuiNotificationTemplate<T> {
+    readonly tuiNotificationOptions: import("@angular/core").InputSignal<Partial<TuiNotificationOptions<T>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNotificationTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNotificationTemplate<any>, "ng-template[tuiNotification]", never, { "tuiNotificationOptions": { "alias": "tuiNotificationOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiPortalDirective; inputs: { "options": "tuiNotificationOptions"; "open": "tuiNotification"; }; outputs: { "openChange": "tuiNotificationChange"; }; }]>;
+}

package/components/root/root.component.d.ts

@@ -5,15 +5,13 @@ import * as i3 from "@taiga-ui/cdk/directives/font-size";
 export declare class TuiRoot {
     private readonly doc;
     private readonly el;
+    private readonly child;
     protected readonly reducedMotion: boolean;
     protected readonly duration: number;
-    protected readonly isChildRoot: boolean;
     protected readonly top: import("@angular/core").WritableSignal<boolean>;
-    protected readonly isMobileRes: import("@angular/core").Signal<boolean>;
-    protected readonly nativeScrollbar: boolean;
+    protected readonly breakpoint: import("@angular/core").Signal<"desktopLarge" | "desktopSmall" | "mobile" | null | undefined>;
     protected readonly scrollbars: boolean;
-    constructor();
-    protected get isTopLayer(): boolean;
+    protected get parent(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiRoot, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRoot, "tui-root", never, {}, {}, never, ["*", "tuiOverContent", "tuiOverDialogs", "tuiOverAlerts", "tuiOverDropdowns", "tuiOverHints"], true, [{ directive: typeof i1.TuiPlatform; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiVisualViewport; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiFontSize; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRoot, "tui-root", never, {}, {}, never, ["*", "tuiOverContent"], true, [{ directive: typeof i1.TuiPlatform; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiVisualViewport; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiFontSize; inputs: {}; outputs: {}; }]>;
 }

package/components/scrollbar/scroll-into-view.directive.d.ts

@@ -5,7 +5,8 @@ import * as i0 from "@angular/core";
 export declare class TuiScrollIntoView {
     private readonly el;
     private readonly destroyRef;
-    set tuiScrollIntoView(scroll: boolean);
+    readonly tuiScrollIntoView: import("@angular/core").InputSignal<boolean | undefined>;
+    protected readonly dispatchEvent: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiScrollIntoView, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiScrollIntoView, "[tuiScrollIntoView]", never, { "tuiScrollIntoView": { "alias": "tuiScrollIntoView"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiScrollIntoView, "[tuiScrollIntoView]", never, { "tuiScrollIntoView": { "alias": "tuiScrollIntoView"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -17,11 +17,11 @@ export declare class TuiScrollbar {
     /**
      * @deprecated: use tuiScrollbarOptionsProvider({ mode: 'hidden' })
      */
-    hidden: boolean;
+    readonly hidden: import("@angular/core").InputSignal<boolean>;
     protected get delegated(): boolean;
     protected get scrollRef(): HTMLElement;
     protected set scrollRef(element: HTMLElement);
     protected scrollIntoView(detail: HTMLElement): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiScrollbar, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiScrollbar, "tui-scrollbar", never, { "hidden": { "alias": "hidden"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiScrollbar, "tui-scrollbar", never, { "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/scrollbar/scrollbar.directive.d.ts

@@ -4,11 +4,11 @@ export declare class TuiScrollbarDirective {
     private readonly style;
     protected readonly scrollSub: import("rxjs").Subscription;
     protected readonly styleSub: import("rxjs").Subscription;
-    tuiScrollbar: 'horizontal' | 'vertical';
+    readonly tuiScrollbar: import("@angular/core").InputSignal<"horizontal" | "vertical">;
     private getScrolled;
     private getCompensation;
     private getThumb;
     private getView;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiScrollbarDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiScrollbarDirective, "[tuiScrollbar]", never, { "tuiScrollbar": { "alias": "tuiScrollbar"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiScrollbarDirective, "[tuiScrollbar]", never, { "tuiScrollbar": { "alias": "tuiScrollbar"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -2,4 +2,4 @@ export interface TuiScrollbarOptions {
     mode: 'always' | 'hidden' | 'hover' | 'native';
 }
 export declare const TUI_DEFAULT_SCROLLBAR_OPTIONS: TuiScrollbarOptions;
-export declare const TUI_SCROLLBAR_OPTIONS: import("@angular/core").InjectionToken<TuiScrollbarOptions>, tuiScrollbarOptionsProvider: (item: Partial<TuiScrollbarOptions> | import("@angular/core").ProviderToken<Partial<TuiScrollbarOptions>> | (() => Partial<TuiScrollbarOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_SCROLLBAR_OPTIONS: import("@angular/core").InjectionToken<TuiScrollbarOptions>, tuiScrollbarOptionsProvider: (item: Partial<TuiScrollbarOptions> | (() => Partial<TuiScrollbarOptions>)) => import("@angular/core").FactoryProvider;

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-item.component.d.ts

@@ -10,8 +10,9 @@ export declare class TuiTextfieldItemComponent<T> {
     protected readonly el: HTMLElement;
     protected readonly handlers: import("@taiga-ui/core/directives/items-handlers").TuiItemsHandlers<unknown>;
     protected readonly context: TuiContext<TuiTextfieldItem<T>>;
-    protected readonly textfield: TuiTextfieldMultiComponent<T>;
-    protected get content(): PolymorpheusContent<TuiContext<TuiTextfieldItem<T>>>;
+    protected readonly textfield: TuiTextfieldMultiComponent<any>;
+    protected readonly content: import("@angular/core").Signal<string | import("@angular/core").TemplateRef<any>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextfieldItemComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldItemComponent<any>, "tui-textfield-item", never, {}, {}, never, never, true, never>;
 }
+export declare const TUI_TEXTFIELD_ITEM: PolymorpheusContent<TuiContext<TuiTextfieldItem<any>>>;

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

@@ -1,26 +1,21 @@
 import { TemplateRef } from '@angular/core';
-import { type TuiContext } from '@taiga-ui/cdk/types';
-import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
-import { TuiTextfieldBaseComponent } from '../textfield.component';
-import { type TuiTextfieldItem } from './textfield-item.component';
+import { TuiControl } from '@taiga-ui/cdk/classes';
+import { TuiTextfieldComponent } from '../textfield.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";
-export declare class TuiTextfieldMultiComponent<T> extends TuiTextfieldBaseComponent<T> {
+import * as i1 from "@taiga-ui/core/directives";
+export declare class TuiTextfieldMultiComponent<T> extends TuiTextfieldComponent<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 component: import("@taiga-ui/polymorpheus").PolymorpheusContent<import("@taiga-ui/cdk/types").TuiContext<import("./textfield-item.component").TuiTextfieldItem<any>>>;
     protected readonly sub: import("rxjs").Subscription;
-    readonly item?: TemplateRef<unknown>;
-    rows: number;
+    readonly cva: import("@angular/core").Signal<TuiControl<any> | undefined>;
+    readonly item: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    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; }; }, {}, ["cva", "item"], ["label", "input", "select", "*", "tui-icon"], true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,6 +1,5 @@
-import { type AfterContentChecked, ElementRef, type QueryList, ViewContainerRef } from '@angular/core';
+import { ElementRef, type Signal, ViewContainerRef } from '@angular/core';
 import { NgControl } from '@angular/forms';
-import { TuiControl } from '@taiga-ui/cdk/classes';
 import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type TuiDataListHost } from '@taiga-ui/core/components/data-list';
 import { TuiDropdownDirective, TuiDropdownOpen } from '@taiga-ui/core/directives/dropdown';
@@ -12,48 +11,37 @@ import * as i1 from "@taiga-ui/core/directives/dropdown";
 import * as i2 from "@taiga-ui/core/directives/icons";
 import * as i3 from "@taiga-ui/core/directives/items-handlers";
 import * as i4 from "@taiga-ui/core/components/data-list";
-import * as i5 from "./textfield-dropdown.directive";
-export declare class TuiTextfieldBaseComponent<T> implements TuiDataListHost<T>, AfterContentChecked {
-    private readonly filler;
+export declare class TuiTextfieldComponent<T> implements TuiDataListHost<T> {
     private readonly autoId;
     private readonly focusedIn;
-    private readonly contentReady$;
-    private readonly inputQuery;
-    protected readonly ghost?: ElementRef<HTMLElement>;
-    protected readonly label?: ElementRef<HTMLElement>;
-    protected readonly auxiliaryQuery: QueryList<object>;
-    protected readonly _input?: ElementRef<HTMLInputElement>;
+    protected readonly ghost: Signal<ElementRef<HTMLElement> | undefined>;
     protected readonly open: import("@angular/core").WritableSignal<boolean>;
     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 computedFiller: import("@angular/core").Signal<string>;
-    protected readonly showFiller: import("@angular/core").Signal<boolean>;
-    readonly vcr?: ViewContainerRef;
-    readonly accessor?: TuiTextfieldAccessor<T>;
-    readonly control?: NgControl;
-    readonly cva?: TuiControl<unknown>;
-    readonly input?: ElementRef<HTMLInputElement>;
-    content: PolymorpheusContent<TuiContext<T>>;
-    readonly focused: import("@angular/core").Signal<boolean>;
+    protected readonly clear: Signal<string>;
+    protected readonly label: Signal<ElementRef<any> | undefined>;
+    protected readonly computedFiller: Signal<string>;
+    protected readonly showFiller: Signal<boolean>;
+    protected readonly accessor: Signal<TuiTextfieldAccessor<T> | undefined>;
+    readonly vcr: Signal<ViewContainerRef | undefined>;
+    readonly control: Signal<NgControl | undefined>;
+    readonly auxiliaries: Signal<readonly null[]>;
+    readonly focused: Signal<boolean>;
     readonly options: import("./textfield.options").TuiTextfieldOptions;
     readonly el: HTMLElement;
+    readonly input: Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly content: import("@angular/core").InputSignal<PolymorpheusContent<TuiContext<T>>>;
+    readonly filler: import("@angular/core").InputSignal<string>;
     readonly value: import("@angular/core").WritableSignal<string>;
-    readonly auxiliaries: import("@angular/core").Signal<readonly object[]>;
-    set fillerSetter(filler: string);
+    constructor();
     get id(): string;
     get size(): TuiSizeL | TuiSizeS;
-    ngAfterContentChecked(): void;
     handleOption(option: T): void;
     protected get hasLabel(): boolean;
     protected onResize({ contentRect }: ResizeObserverEntry): void;
     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, false, 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 i1.TuiWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithItemsHandlers; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithOptionContent; inputs: {}; outputs: {}; }, { directive: typeof i5.TuiWithTextfieldDropdown; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextfieldComponent<any>, "tui-textfield:not([multi])", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "filler": { "alias": "filler"; "required": false; "isSignal": true; }; }, {}, ["label", "accessor", "control", "auxiliaries", "input"], ["input", "select", "textarea", "label", "*", "tui-icon"], true, [{ directive: typeof i1.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiDropdownFixed; 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: {}; }]>;
 }

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,24 @@ 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;
-    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 f: import("@angular/core").Signal<boolean | null>;
+export declare class TuiTextfieldDirective<T> implements TuiTextfieldAccessor<T> {
     protected readonly el: HTMLInputElement;
+    protected readonly control: NgControl | null;
     protected readonly handlers: TuiItemsHandlers<T>;
-    protected readonly textfield: TuiTextfieldComponent<T>;
-    readOnly: boolean;
-    invalid: boolean | null;
+    protected readonly textfield: TuiTextfieldComponent<any>;
+    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>;
+    readonly readOnly: import("@angular/core").InputSignal<boolean>;
+    readonly invalid: import("@angular/core").InputSignal<boolean | null>;
+    readonly focused: import("@angular/core").InputSignal<boolean | null>;
+    readonly state: import("@angular/core").InputSignal<TuiInteractiveState | 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 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>;
-}
-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, { "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, [{ 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/alert/alert.directive.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export interface TuiPositionOptions {
+    readonly block: 'end' | 'start';
+    readonly inline: 'center' | 'end' | 'start';
+}
+export declare class TuiAlertDirective {
+    protected readonly nothing: undefined;
+    protected readonly context: TuiPositionOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlertDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAlertDirective, never, never, {}, {}, never, never, true, never>;
+}

package/directives/alert/alert.service.d.ts

@@ -0,0 +1,12 @@
+import { TuiPortal } from '@taiga-ui/cdk/portals';
+import { type PolymorpheusComponent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare abstract class TuiAlertService<T, K = void> extends TuiPortal<T, K> {
+    private readonly concurrency;
+    private readonly current;
+    private readonly queue;
+    constructor(concurrency: number);
+    protected add(component: PolymorpheusComponent<unknown>): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlertService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiAlertService<any, any>>;
+}

package/directives/alert/index.d.ts

@@ -0,0 +1,2 @@
+export * from './alert.directive';
+export * from './alert.service';

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/date-format/date-format.directive.d.ts

@@ -1,11 +1,7 @@
 import { type TuiDateFormatSettings } from '@taiga-ui/core/tokens';
-import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
-export declare class TuiDateFormat extends Observable<TuiDateFormatSettings> {
-    private readonly settings;
-    private readonly parent;
-    constructor();
-    set tuiDateFormat(format: Partial<TuiDateFormatSettings>);
+export declare class TuiDateFormat {
+    readonly tuiDateFormat: import("@angular/core").InputSignal<Partial<TuiDateFormatSettings>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDateFormat, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDateFormat, "[tuiDateFormat]", never, { "tuiDateFormat": { "alias": "tuiDateFormat"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDateFormat, "[tuiDateFormat]", never, { "tuiDateFormat": { "alias": "tuiDateFormat"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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>;
+}