@taiga-ui/core 4.52.0-canary.a59c4d0 → 4.52.0-canary.bf9131e

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

@@ -2,13 +2,13 @@ import { type TuiPortalContext } from '@taiga-ui/cdk/portals';
 import { type TuiAlertOptions } from './alert.interfaces';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
+import * as i2 from "@taiga-ui/core/directives";
 export declare class TuiAlertComponent<O, I> {
     private readonly el;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    protected readonly close: import("@angular/core").Signal<string | undefined>;
-    protected readonly position: string;
+    protected readonly close: import("@angular/core").Signal<string>;
     protected readonly item: TuiPortalContext<TuiAlertOptions<I>, O>;
     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, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAlertComponent<any, any>, "tui-alert", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiNotificationDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,14 +1,13 @@
 import { type TuiPopoverContext } from '@taiga-ui/cdk/services';
 import { type TuiHandler } from '@taiga-ui/cdk/types';
 import { type TuiNotificationOptions } from '@taiga-ui/core/components/notification';
+import { type TuiPositionOptions } from '@taiga-ui/core/directives';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
-export interface TuiAlertOptions<I = undefined> extends Omit<TuiNotificationOptions, 'size'> {
+export interface TuiAlertOptions<I = undefined> extends Omit<TuiNotificationOptions, 'size'>, TuiPositionOptions {
     readonly autoClose: TuiHandler<string, number> | number;
     readonly data: I;
     readonly closable: boolean;
     readonly label: PolymorpheusContent<TuiAlertOptions<I>>;
-    readonly position: 'bottom' | 'top';
-    readonly orientation: 'center' | 'end' | 'start';
 }
 export interface TuiAlertContext<O = void, I = undefined> extends TuiPopoverContext<O>, TuiAlertOptions<I> {
 }

package/components/alert/alert.service.d.ts

@@ -1,10 +1,11 @@
-import { TuiPortal } from '@taiga-ui/cdk/portals';
+import { TuiNotificationService } from '@taiga-ui/core/directives/notification';
 import { TuiAlertComponent } from './alert.component';
 import { type TuiAlertOptions } from './alert.interfaces';
 import * as i0 from "@angular/core";
-export declare class TuiAlertService extends TuiPortal<TuiAlertOptions<any>> {
+export declare class TuiAlertService extends TuiNotificationService<TuiAlertOptions<any>> {
     protected readonly options: TuiAlertOptions<undefined>;
     protected readonly component: typeof TuiAlertComponent;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAlertService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TuiAlertService>;
 }

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

@@ -1,12 +1,6 @@
 import { type FactoryProvider, InjectionToken } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
 import { type TuiAlertOptions } from './alert.interfaces';
+export declare const TUI_ALERT_CONCURRENCY: InjectionToken<number>;
 export declare const TUI_ALERT_DEFAULT_OPTIONS: Omit<TuiAlertOptions, 'appearance' | 'icon'>;
 export declare const TUI_ALERT_OPTIONS: InjectionToken<TuiAlertOptions<undefined>>;
-export declare const TUI_ALERT_POSITION: InjectionToken<string>;
-export declare const TUI_ALERTS: InjectionToken<BehaviorSubject<readonly any[]>>;
-/**
- * Grouping alerts by their component
- */
-export declare const TUI_ALERTS_GROUPED: InjectionToken<import("rxjs").Observable<(readonly any[])[]>>;
 export declare function tuiAlertOptionsProvider(options: Partial<TuiAlertOptions>): FactoryProvider;

package/components/alert/index.d.ts

@@ -3,4 +3,3 @@ export * from './alert.directive';
 export type * from './alert.interfaces';
 export * from './alert.service';
 export * from './alert.tokens';
-export * from './alerts.component';

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

@@ -13,7 +13,7 @@ export declare class TuiDataListComponent<T> implements TuiDataListAccessor<T>,
     private readonly el;
     private readonly cdr;
     private readonly contentReady$;
-    protected readonly fallback: import("@angular/core").Signal<string | undefined>;
+    protected readonly fallback: import("@angular/core").Signal<string>;
     protected readonly empty: import("@angular/core").WritableSignal<boolean>;
     emptyContent: PolymorpheusContent;
     size: "m" | "l" | "s";

package/components/dialog/dialog.component.d.ts

@@ -5,7 +5,7 @@ import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
 export declare class TuiDialogComponent<O, I> {
     protected readonly close$: Subject<void>;
-    protected readonly close: import("@angular/core").Signal<string | undefined>;
+    protected readonly close: import("@angular/core").Signal<string>;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     protected readonly context: TuiPopover<TuiDialogOptions<I>, O>;
     protected readonly primitive: boolean;

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

@@ -1,7 +1,8 @@
-import { TuiPopoverDirective } from '@taiga-ui/cdk/directives/popover';
 import { type TuiDialogOptions } from './dialog.options';
 import * as i0 from "@angular/core";
-export declare class TuiDialog<T> extends TuiPopoverDirective<TuiDialogOptions<T>> {
+import * as i1 from "@taiga-ui/cdk/portals";
+export declare class TuiDialog<T> {
+    readonly tuiDialogOptions: import("@angular/core").InputSignal<Partial<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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiDialog<any>, "ng-template[tuiDialog]", never, { "tuiDialogOptions": { "alias": "tuiDialogOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiPortalDirective; inputs: { "options": "tuiDialogOptions"; "open": "tuiDialog"; }; outputs: { "openChange": "tuiDialogChange"; }; }]>;
 }

package/components/dialog/dialog.service.d.ts

@@ -1,7 +1,10 @@
-import { TuiPopoverService } from '@taiga-ui/cdk/services';
+import { TuiModalService } from '@taiga-ui/core/components/modal';
+import { TuiDialogComponent } from './dialog.component';
 import { type TuiDialogOptions } from './dialog.options';
 import * as i0 from "@angular/core";
-export declare class TuiDialogService extends TuiPopoverService<TuiDialogOptions<any>> {
+export declare class TuiDialogService extends TuiModalService<TuiDialogOptions<any>> {
+    protected readonly options: TuiDialogOptions<void>;
+    protected readonly content: typeof TuiDialogComponent;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDialogService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TuiDialogService>;
 }

package/components/error/error.component.d.ts

@@ -1,7 +1,7 @@
 import { TuiValidationError } from '@taiga-ui/cdk/classes';
 import * as i0 from "@angular/core";
 export declare class TuiErrorComponent {
-    protected readonly default: import("@angular/core").Signal<string | undefined>;
+    protected readonly default: import("@angular/core").Signal<string>;
     protected readonly content: import("@angular/core").Signal<TuiValidationError<Record<string, unknown>> | null>;
     readonly error: import("@angular/core").InputSignal<string | TuiValidationError<Record<string, unknown>> | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiErrorComponent, never>;

package/components/index.d.ts

@@ -11,6 +11,7 @@ export * from '@taiga-ui/core/components/icon';
 export * from '@taiga-ui/core/components/label';
 export * from '@taiga-ui/core/components/link';
 export * from '@taiga-ui/core/components/loader';
+export * from '@taiga-ui/core/components/modal';
 export * from '@taiga-ui/core/components/notification';
 export * from '@taiga-ui/core/components/root';
 export * from '@taiga-ui/core/components/scrollbar';

package/components/loader/loader.component.d.ts

@@ -4,12 +4,12 @@ export declare class TuiLoader {
     private readonly isIOS;
     private readonly options;
     protected readonly isApple: boolean;
-    size: "m" | "s" | "xs" | "l" | "xl" | "xxl";
-    inheritColor: boolean;
-    overlay: boolean;
-    textContent: PolymorpheusContent;
-    loading: boolean;
-    protected get isHorizontal(): boolean;
+    protected readonly isHorizontal: import("@angular/core").Signal<boolean>;
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "xs" | "l" | "xl" | "xxl">;
+    readonly inheritColor: import("@angular/core").InputSignal<boolean>;
+    readonly overlay: import("@angular/core").InputSignal<boolean>;
+    readonly textContent: import("@angular/core").InputSignal<PolymorpheusContent>;
+    readonly loading: import("@angular/core").InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiLoader, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLoader, "tui-loader", never, { "size": { "alias": "size"; "required": false; }; "inheritColor": { "alias": "inheritColor"; "required": false; }; "overlay": { "alias": "overlay"; "required": false; }; "textContent": { "alias": "textContent"; "required": false; }; "loading": { "alias": "showLoader"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLoader, "tui-loader", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "inheritColor": { "alias": "inheritColor"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "textContent": { "alias": "textContent"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/modal/index.d.ts

@@ -0,0 +1,2 @@
+export * from './modal.component';
+export * from './modal.service';

package/components/modal/modal.component.d.ts

@@ -0,0 +1,17 @@
+import { type OnDestroy, type OnInit } from '@angular/core';
+import { type TuiPortalContext } from '@taiga-ui/cdk/portals';
+import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/cdk/directives/active-zone";
+import * as i2 from "@taiga-ui/cdk/directives/focus-trap";
+import * as i3 from "@taiga-ui/core/components/scrollbar";
+export declare class TuiModal<T> implements OnDestroy, OnInit {
+    private readonly current;
+    private readonly parent;
+    readonly context: TuiPortalContext<T>;
+    readonly component: import("@angular/core").WritableSignal<PolymorpheusContent<TuiPortalContext<T>>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiModal<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiModal<any>, "tui-modal", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiActiveZone; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiFocusTrap; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiScrollRef; inputs: {}; outputs: {}; }]>;
+}

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 { TuiModal } 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 TuiModal;
+    constructor();
+    protected add(component: PolymorpheusComponent<TuiModal<T>>): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiModalService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiModalService<any, any>>;
+}

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

@@ -27,7 +27,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;

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

@@ -10,7 +10,7 @@ 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 a: import("@angular/core").Signal<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>;

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/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/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-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

@@ -6,23 +6,24 @@ import { TuiHintPointer } from './hint-pointer.directive';
 import * as i0 from "@angular/core";
 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 TuiHintComponent<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 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").WritableSignal<string>;
+    protected readonly appearance: import("@angular/core").Signal<string>;
     constructor();
     protected onClick(target: HTMLElement): void;
     private apply;
     private update;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiHintComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiHintComponent<any>, "tui-hint", never, {}, {}, never, ["*"], true, [{ directive: typeof i1.TuiAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.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: "" | ("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: 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';

package/directives/index.d.ts

@@ -5,6 +5,7 @@ export * from '@taiga-ui/core/directives/group';
 export * from '@taiga-ui/core/directives/hint';
 export * from '@taiga-ui/core/directives/icons';
 export * from '@taiga-ui/core/directives/items-handlers';
+export * from '@taiga-ui/core/directives/notification';
 export * from '@taiga-ui/core/directives/number-format';
 export * from '@taiga-ui/core/directives/popup';
 export * from '@taiga-ui/core/directives/title';

package/directives/notification/index.d.ts

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

package/directives/notification/notification.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 TuiNotificationDirective {
+    protected readonly nothing: undefined;
+    protected readonly context: TuiPositionOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNotificationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNotificationDirective, never, never, {}, {}, never, never, true, never>;
+}

package/directives/notification/notification.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 TuiNotificationService<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<TuiNotificationService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiNotificationService<any, any>>;
+}