@taiga-ui/kit 4.65.0 → 5.0.0-rc.0

package/components/tiles/tile.component.d.ts

@@ -1,20 +1,17 @@
 import { type AfterViewInit, type OnDestroy } from '@angular/core';
+import { TuiTilesComponent } from './tiles.component';
 import * as i0 from "@angular/core";
 export declare class TuiTile implements OnDestroy, AfterViewInit {
-    private readonly wrapper?;
+    private readonly wrapper;
     private readonly service;
-    private readonly tiles;
-    protected dragged: import("@angular/core").WritableSignal<boolean>;
-    width: number;
-    height: number;
+    protected readonly tiles: TuiTilesComponent;
+    protected readonly dragged: import("@angular/core").WritableSignal<boolean>;
+    readonly width: import("@angular/core").InputSignal<number>;
+    readonly height: import("@angular/core").InputSignal<number>;
     readonly element: HTMLElement;
     onDrag(offset: readonly [number, number]): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    protected get column(): string;
-    protected get row(): string;
-    protected onEnter(): void;
-    protected onTransitionEnd(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTile, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTile, "tui-tile", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTile, "tui-tile", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/tiles/tile.service.d.ts

@@ -7,7 +7,7 @@ export declare class TuiTileService implements OnDestroy {
     private readonly sub;
     private readonly offset$;
     private readonly position$;
-    init(element: HTMLElement): void;
+    init(element?: HTMLElement): void;
     setOffset(offset: readonly [number, number]): void;
     ngOnDestroy(): void;
     private getRect;

package/components/tiles/tiles.component.d.ts

@@ -1,18 +1,15 @@
-import { BehaviorSubject } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiTilesComponent {
     private readonly el$;
     private readonly handler;
-    debounce: number;
-    readonly orderChange: import("rxjs").Observable<Map<number, number>>;
+    protected readonly sub: import("rxjs").Subscription;
+    readonly debounce: import("@angular/core").InputSignal<number>;
+    readonly order: import("@angular/core").ModelSignal<Map<number, number>>;
     readonly element: import("@angular/core").WritableSignal<Element | null>;
     readonly el: HTMLElement;
-    readonly order$: BehaviorSubject<Map<number, number>>;
-    set order(map: Map<number, number>);
-    get order(): Map<number, number>;
     rearrange(element?: Element): void;
     private filter;
     private reorder;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTilesComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTilesComponent, "tui-tiles", never, { "debounce": { "alias": "debounce"; "required": false; }; "order": { "alias": "order"; "required": false; }; }, { "orderChange": "orderChange"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTilesComponent, "tui-tiles", never, { "debounce": { "alias": "debounce"; "required": false; "isSignal": true; }; "order": { "alias": "order"; "required": false; "isSignal": true; }; }, { "order": "orderChange"; }, never, ["*"], true, never>;
 }

package/components/toast/toast.component.d.ts

@@ -1,17 +1,18 @@
 import { type AfterViewInit } from '@angular/core';
-import { type TuiPopover } from '@taiga-ui/cdk/services';
+import { type TuiPortalContext } from '@taiga-ui/cdk/portals';
 import { type TuiToastOptions } from './toast.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
+import * as i2 from "@taiga-ui/core/portals/alert";
 export declare class TuiToastComponent<O, I> implements AfterViewInit {
-    private readonly button?;
+    private readonly close;
     private readonly el;
     protected readonly isMobile: boolean;
-    protected readonly context: TuiPopover<TuiToastOptions<I>, O>;
+    protected readonly context: TuiPortalContext<TuiToastOptions<I>, O>;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     protected readonly $: import("rxjs").Subscription;
     ngAfterViewInit(): void;
     protected onSwipe(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiToastComponent<any, any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiToastComponent<any, any>, "tui-toast", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiToastComponent<any, any>, "tui-toast", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiAlertDirective; inputs: {}; outputs: {}; }]>;
 }

package/components/toast/toast.options.d.ts

@@ -1,8 +1,10 @@
-export interface TuiToastOptions<I> {
-    autoClose: number;
-    closable: boolean;
-    appearance: string;
-    data?: I;
+import { InjectionToken } from '@angular/core';
+import { type TuiPositionOptions } from '@taiga-ui/core/portals/alert';
+export interface TuiToastOptions<I> extends TuiPositionOptions {
+    readonly autoClose: number;
+    readonly closable: boolean;
+    readonly appearance: string;
+    readonly data?: I;
 }
-export declare const TUI_TOAST_DEFAULT_OPTIONS: TuiToastOptions<void>;
-export declare const TUI_TOAST_OPTIONS: import("@angular/core").InjectionToken<TuiToastOptions<void>>, tuiToastOptionsProvider: (item: Partial<TuiToastOptions<void>> | import("@angular/core").ProviderToken<Partial<TuiToastOptions<void>>> | (() => Partial<TuiToastOptions<void>>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_TOAST_CONCURRENCY: InjectionToken<1 | 2>;
+export declare const TUI_TOAST_OPTIONS: InjectionToken<TuiToastOptions<any>>, tuiToastOptionsProvider: (item: Partial<TuiToastOptions<any>> | (() => Partial<TuiToastOptions<any>>)) => import("@angular/core").FactoryProvider;

package/components/toast/toast.service.d.ts

@@ -1,16 +1,17 @@
-import { TuiPopoverDirective } from '@taiga-ui/cdk/directives/popover';
-import { TuiPopoverService } from '@taiga-ui/cdk/services';
+import { TuiAlertService } from '@taiga-ui/core/portals/alert';
+import { TuiToastComponent } from './toast.component';
 import { type TuiToastOptions } from './toast.options';
 import * as i0 from "@angular/core";
-export declare const TUI_TOASTS_CONCURRENCY: import("@angular/core").InjectionToken<number>;
-export declare class TuiToastService extends TuiPopoverService<TuiToastOptions<any>> {
-    private readonly concurrency;
-    private readonly alerts;
-    protected readonly sub: import("rxjs").Subscription;
+import * as i1 from "@taiga-ui/cdk/portals";
+export declare class TuiToastService extends TuiAlertService<TuiToastOptions<any>> {
+    protected readonly options: TuiToastOptions<any>;
+    protected readonly component: typeof TuiToastComponent;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiToastService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TuiToastService>;
 }
-export declare class TuiToastTemplate<T> extends TuiPopoverDirective<TuiToastOptions<T>> {
+export declare class TuiToastTemplate<T> {
+    readonly tuiToastOptions: import("@angular/core").InputSignal<Partial<TuiToastOptions<T>>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiToastTemplate<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiToastTemplate<any>, "ng-template[tuiToast]", never, { "options": { "alias": "tuiToastOptions"; "required": false; }; "open": { "alias": "tuiToast"; "required": false; }; }, { "openChange": "tuiToastChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiToastTemplate<any>, "ng-template[tuiToast]", never, { "tuiToastOptions": { "alias": "tuiToastOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiPortalDirective; inputs: { "options": "tuiToastOptions"; "open": "tuiToast"; }; outputs: { "openChange": "tuiToastChange"; }; }]>;
 }

package/components/tree/components/tree/tree.component.d.ts

@@ -6,16 +6,16 @@ import { TuiTreeItem } from '../tree-item/tree-item.component';
 import * as i0 from "@angular/core";
 export declare class TuiTreeComponent<T> implements DoCheck {
     private readonly check$;
-    protected readonly item?: TuiTreeItem;
-    protected readonly child?: TuiTreeComponent<T>;
-    protected readonly children$: import("rxjs").Observable<readonly T[]>;
+    protected readonly item: import("@angular/core").Signal<TuiTreeItem | undefined>;
+    protected readonly child: import("@angular/core").Signal<TuiTreeComponent<any> | undefined>;
+    protected readonly children: import("@angular/core").Signal<readonly T[] | readonly []>;
     protected readonly directive: TuiTreeChildren<T> | null;
-    value: T;
-    trackBy: TrackByFunction<T>;
-    content: PolymorpheusContent<TuiTreeContext<T>>;
+    readonly value: import("@angular/core").InputSignal<T>;
+    readonly trackBy: import("@angular/core").InputSignal<TrackByFunction<T>>;
+    readonly content: import("@angular/core").InputSignal<PolymorpheusContent<TuiTreeContext<T>>>;
     ngDoCheck(): void;
     protected checkChanges(): void;
     private get handler();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeComponent<any>, "tui-tree", never, { "value": { "alias": "value"; "required": true; }; "trackBy": { "alias": "trackBy"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeComponent<any>, "tui-tree", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/tree/components/tree-item/tree-item.component.d.ts

@@ -5,12 +5,12 @@ import * as i0 from "@angular/core";
 export declare class TuiTreeItem implements DoCheck {
     private readonly nested;
     private readonly el;
-    private readonly controller;
     private readonly change$;
+    private readonly controller;
     protected readonly level: number;
     protected readonly content: PolymorpheusContent<TuiTreeItemContext>;
-    protected readonly expanded: import("@angular/core").Signal<boolean>;
     protected readonly attached: import("@angular/core").Signal<boolean>;
+    readonly expanded: import("@angular/core").Signal<boolean>;
     get isExpandable(): boolean;
     get isExpanded(): boolean;
     ngDoCheck(): void;

package/components/tree/components/tree-item-content/tree-item-content.component.d.ts

@@ -1,17 +1,19 @@
-import { type DoCheck } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { PolymorpheusComponent, type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import { type TuiTreeItemContext } from '../../misc/tree.interfaces';
 import * as i0 from "@angular/core";
-export declare class TuiTreeItemContent implements DoCheck {
+export declare class TuiTreeItemContent {
     private readonly controller;
-    private readonly change$;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    protected readonly more: import("@angular/core").Signal<string | undefined>;
+    protected readonly more: import("@angular/core").Signal<string>;
     protected readonly context: TuiTreeItemContext;
-    protected readonly expanded: import("@angular/core").Signal<boolean>;
-    ngDoCheck(): void;
     protected get isExpandable(): boolean;
-    protected get isExpanded(): boolean;
     protected onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeItemContent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeItemContent, "ng-component", never, {}, {}, never, never, true, never>;
 }
+export declare const TUI_TREE_ITEM_CONTENT: PolymorpheusComponent<TuiTreeItemContent>;
+/**
+ * Content for a tree item
+ */
+export declare const TUI_TREE_CONTENT: InjectionToken<PolymorpheusContent<TuiTreeItemContext>>;

package/components/tree/directives/tree-children.directive.d.ts

@@ -1,8 +1,8 @@
 import { type TuiHandler } from '@taiga-ui/cdk/types';
 import * as i0 from "@angular/core";
 export declare class TuiTreeChildren<T> {
-    childrenHandler: TuiHandler<T, readonly T[]>;
+    readonly childrenHandler: import("@angular/core").InputSignal<TuiHandler<T, readonly T[]>>;
     static defaultHandler<G>(item: G): readonly G[];
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeChildren<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeChildren<any>, "tui-tree[childrenHandler]", never, { "childrenHandler": { "alias": "childrenHandler"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeChildren<any>, "tui-tree[childrenHandler]", never, { "childrenHandler": { "alias": "childrenHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/tree/directives/tree-controller.directive.d.ts

@@ -1,16 +1,15 @@
-import { EventEmitter } from '@angular/core';
 import { type TuiTreeItem } from '../components/tree-item/tree-item.component';
 import { type TuiTreeAccessor, type TuiTreeController } from '../misc/tree.interfaces';
 import * as i0 from "@angular/core";
 export declare class TuiTreeControllerDirective<T> implements TuiTreeController, TuiTreeAccessor<T> {
     protected readonly items: Map<TuiTreeItem, T>;
-    fallback: boolean;
-    map: Map<T, boolean>;
-    readonly toggled: EventEmitter<T>;
+    readonly fallback: import("@angular/core").InputSignal<boolean>;
+    readonly map: import("@angular/core").InputSignal<Map<T, boolean>>;
+    readonly toggled: import("@angular/core").OutputEmitterRef<T>;
     register(item: TuiTreeItem, value: T): void;
     unregister(item: TuiTreeItem): void;
     isExpanded(item: TuiTreeItem): boolean;
     toggle(item: TuiTreeItem): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeControllerDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeControllerDirective<any>, "[tuiTreeController][map]", ["tuiTreeController"], { "fallback": { "alias": "tuiTreeController"; "required": false; }; "map": { "alias": "map"; "required": false; }; }, { "toggled": "toggled"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeControllerDirective<any>, "[tuiTreeController][map]", ["tuiTreeController"], { "fallback": { "alias": "tuiTreeController"; "required": false; "isSignal": true; }; "map": { "alias": "map"; "required": false; "isSignal": true; }; }, { "toggled": "toggled"; }, never, never, true, never>;
 }

package/components/tree/directives/tree-item-controller.directive.d.ts

@@ -3,9 +3,9 @@ import { type TuiTreeController } from '../misc/tree.interfaces';
 import * as i0 from "@angular/core";
 export declare class TuiTreeItemController implements TuiTreeController {
     private readonly map;
-    fallback: boolean;
+    readonly fallback: import("@angular/core").InputSignal<boolean>;
     isExpanded(item: TuiTreeItem): boolean;
     toggle(item: TuiTreeItem): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeItemController, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeItemController, "[tuiTreeController]:not([map])", ["tuiTreeController"], { "fallback": { "alias": "tuiTreeController"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeItemController, "[tuiTreeController]:not([map])", ["tuiTreeController"], { "fallback": { "alias": "tuiTreeController"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/tree/directives/tree-node.directive.d.ts

@@ -1,10 +1,11 @@
-import { type OnDestroy } from '@angular/core';
+import { type OnChanges, type OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class TuiTreeNode<T> implements OnDestroy {
+export declare class TuiTreeNode<T> implements OnChanges, OnDestroy {
     private readonly component;
     private readonly directive;
-    set value(value: T);
+    readonly value: import("@angular/core").InputSignal<T>;
+    ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeNode<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeNode<any>, "tui-tree-item[tuiTreeNode]", never, { "value": { "alias": "tuiTreeNode"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeNode<any>, "tui-tree-item[tuiTreeNode]", never, { "value": { "alias": "tuiTreeNode"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/tree/misc/tree.constants.d.ts

@@ -1,5 +1,2 @@
-import { PolymorpheusComponent } from '@taiga-ui/polymorpheus';
-import { TuiTreeItemContent } from '../components/tree-item-content/tree-item-content.component';
 import { type TuiTreeController } from './tree.interfaces';
-export declare const TUI_TREE_ITEM_CONTENT: PolymorpheusComponent<TuiTreeItemContent>;
 export declare const TUI_DEFAULT_TREE_CONTROLLER: TuiTreeController;

package/components/tree/misc/tree.tokens.d.ts

@@ -1,6 +1,5 @@
 import { InjectionToken } from '@angular/core';
-import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
-import { type TuiTreeAccessor, type TuiTreeItemContext, type TuiTreeLoader } from './tree.interfaces';
+import { type TuiTreeAccessor, type TuiTreeLoader } from './tree.interfaces';
 /**
  * Controller for tracking value - TuiTreeItemComponent pairs
  */
@@ -25,10 +24,6 @@ export declare const TUI_TREE_START: InjectionToken<unknown>;
  * A service to load tree progressively
  */
 export declare const TUI_TREE_LOADER: InjectionToken<TuiTreeLoader<unknown>>;
-/**
- * Content for a tree item
- */
-export declare const TUI_TREE_CONTENT: InjectionToken<PolymorpheusContent<TuiTreeItemContext>>;
 /**
  * Nesting level of current TreeView node
  */

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

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/appearance";
+export declare class TuiAppearanceProxy {
+    private readonly a;
+    protected readonly f: import("@angular/core").Signal<boolean | null>;
+    protected readonly m: import("@angular/core").Signal<string | readonly string[] | null>;
+    protected readonly s: import("@angular/core").Signal<import("@taiga-ui/core/types").TuiInteractiveState | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAppearanceProxy, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAppearanceProxy, never, never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAppearance; inputs: {}; outputs: {}; }]>;
+}

package/directives/appearance-proxy/index.d.ts

@@ -0,0 +1 @@
+export * from './appearance-proxy.directive';

package/directives/button-select/button-select.directive.d.ts

@@ -1,14 +1,13 @@
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { type TuiDataListHost } from '@taiga-ui/core/components/data-list';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/directives/dropdown";
+import * as i1 from "@taiga-ui/core/portals/dropdown";
 import * as i2 from "@taiga-ui/cdk/directives/native-validator";
-import * as i3 from "@taiga-ui/core/components/textfield";
 export declare class TuiButtonSelect<T> extends TuiControl<T | T[]> implements TuiDataListHost<T> {
     private readonly open;
     private readonly handlers;
     readonly size = "s";
     handleOption(option: T): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiButtonSelect<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiButtonSelect<any>, "button[tuiButtonSelect]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithTextfieldDropdown; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiButtonSelect<any>, "button[tuiButtonSelect]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiWithDropdownOpen; inputs: {}; outputs: {}; }]>;
 }

package/directives/chevron/chevron.directive.d.ts

@@ -6,8 +6,7 @@ export declare class TuiChevron {
     private readonly dropdown;
     protected readonly nothing: undefined;
     protected readonly toggle: import("@angular/core").EffectRef;
-    readonly chevron: import("@angular/core").WritableSignal<boolean | "">;
-    set tuiChevron(chevron: boolean | '');
+    readonly rotated: import("@angular/core").InputSignal<boolean | "">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiChevron, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiChevron, "[tuiChevron]", never, { "tuiChevron": { "alias": "tuiChevron"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiChevron, "[tuiChevron]", never, { "rotated": { "alias": "tuiChevron"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/data-list-dropdown-manager/data-list-dropdown-manager.directive.d.ts

@@ -1,14 +1,14 @@
 import { type AfterViewInit } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiDataListDropdownManager implements AfterViewInit {
+    private readonly destroyRef;
     private readonly dropdowns;
     private readonly els;
-    private readonly destroyRef;
+    private readonly elements$;
+    private readonly right$;
+    private readonly immediate$;
+    private readonly debounce$;
     ngAfterViewInit(): void;
-    private get elements$();
-    private get right$();
-    private get immediate$();
-    private get debounce$();
     private notInDropdown;
     private tryToFocus;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDataListDropdownManager, never>;

package/directives/fade/fade.directive.d.ts

@@ -1,13 +1,13 @@
 import { type TuiOrientation } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/cdk/directives/transitioned";
 export declare class TuiFade {
-    lineHeight: string | null;
-    size: string;
-    offset: string;
-    orientation: TuiOrientation | '';
+    protected readonly nothing: undefined;
+    readonly lineHeight: import("@angular/core").InputSignal<string | null>;
+    readonly size: import("@angular/core").InputSignal<string>;
+    readonly offset: import("@angular/core").InputSignal<string>;
+    readonly orientation: import("@angular/core").InputSignal<"" | TuiOrientation>;
     constructor();
     private isEnd;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFade, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiFade, "[tuiFade]", never, { "lineHeight": { "alias": "tuiFadeHeight"; "required": false; }; "size": { "alias": "tuiFadeSize"; "required": false; }; "offset": { "alias": "tuiFadeOffset"; "required": false; }; "orientation": { "alias": "tuiFade"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiTransitioned; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiFade, "[tuiFade]", never, { "lineHeight": { "alias": "tuiFadeHeight"; "required": false; "isSignal": true; }; "size": { "alias": "tuiFadeSize"; "required": false; "isSignal": true; }; "offset": { "alias": "tuiFadeOffset"; "required": false; "isSignal": true; }; "orientation": { "alias": "tuiFade"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/fluid-typography/fluid-typography.directive.d.ts

@@ -1,12 +1,9 @@
-import { type OnChanges } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class TuiFluidTypography implements OnChanges {
-    private readonly changes$;
+export declare class TuiFluidTypography {
     private readonly el;
     private readonly options;
+    readonly tuiFluidTypography: import("@angular/core").InputSignal<"" | readonly [min: number, max: number]>;
     protected readonly sub: import("rxjs").Subscription;
-    tuiFluidTypography: readonly [min: number, max: number] | '';
-    ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFluidTypography, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiFluidTypography, "[tuiFluidTypography]", never, { "tuiFluidTypography": { "alias": "tuiFluidTypography"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiFluidTypography, "[tuiFluidTypography]", never, { "tuiFluidTypography": { "alias": "tuiFluidTypography"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/fluid-typography/fluid-typography.options.d.ts

@@ -1,8 +1,6 @@
-import { InjectionToken, type Provider } from '@angular/core';
 export interface TuiFluidTypographyOptions {
     readonly min: number;
     readonly max: number;
 }
 export declare const TUI_FLUID_TYPOGRAPHY_DEFAULT_OPTIONS: TuiFluidTypographyOptions;
-export declare const TUI_FLUID_TYPOGRAPHY_OPTIONS: InjectionToken<TuiFluidTypographyOptions>;
-export declare function tuiFluidTypographyOptionsProvider(options: Partial<TuiFluidTypographyOptions>): Provider;
+export declare const TUI_FLUID_TYPOGRAPHY_OPTIONS: import("@angular/core").InjectionToken<TuiFluidTypographyOptions>, tuiFluidTypographyOptionsProvider: (item: Partial<TuiFluidTypographyOptions> | (() => Partial<TuiFluidTypographyOptions>)) => import("@angular/core").FactoryProvider;

package/directives/highlight/highlight.directive.d.ts

@@ -4,19 +4,17 @@ export declare const TUI_HIGHLIGHT_OPTIONS: import("@angular/core").InjectionTok
     highlightColor: string;
 }>, tuiHighlightOptionsProvider: (item: Partial<{
     highlightColor: string;
-}> | import("@angular/core").ProviderToken<Partial<{
-    highlightColor: string;
-}>> | (() => Partial<{
+}> | (() => Partial<{
     highlightColor: string;
 }>)) => import("@angular/core").FactoryProvider;
 export declare class TuiHighlight implements OnChanges {
     private readonly el;
-    private readonly renderer;
+    private readonly options;
     private readonly doc;
     private readonly highlight;
     private readonly treeWalker;
-    tuiHighlight: string;
-    tuiHighlightColor: string;
+    readonly tuiHighlight: import("@angular/core").InputSignal<string>;
+    readonly tuiHighlightColor: import("@angular/core").InputSignal<string>;
     constructor();
     ngOnChanges(): void;
     protected get match(): boolean;
@@ -24,5 +22,5 @@ export declare class TuiHighlight implements OnChanges {
     private indexOf;
     private setUpHighlight;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiHighlight, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHighlight, "[tuiHighlight]", never, { "tuiHighlight": { "alias": "tuiHighlight"; "required": false; }; "tuiHighlightColor": { "alias": "tuiHighlightColor"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiHighlight, "[tuiHighlight]", never, { "tuiHighlight": { "alias": "tuiHighlight"; "required": false; "isSignal": true; }; "tuiHighlightColor": { "alias": "tuiHighlightColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/index.d.ts

@@ -1,15 +1,12 @@
-export * from '@taiga-ui/kit/directives/button-close';
+export * from '@taiga-ui/kit/directives/appearance-proxy';
 export * from '@taiga-ui/kit/directives/button-group';
 export * from '@taiga-ui/kit/directives/button-select';
 export * from '@taiga-ui/kit/directives/chevron';
 export * from '@taiga-ui/kit/directives/connected';
-export * from '@taiga-ui/kit/directives/copy';
 export * from '@taiga-ui/kit/directives/data-list-dropdown-manager';
 export * from '@taiga-ui/kit/directives/fade';
 export * from '@taiga-ui/kit/directives/fluid-typography';
 export * from '@taiga-ui/kit/directives/highlight';
-export * from '@taiga-ui/kit/directives/icon-badge';
-export * from '@taiga-ui/kit/directives/lazy-loading';
 export * from '@taiga-ui/kit/directives/password';
 export * from '@taiga-ui/kit/directives/present';
 export * from '@taiga-ui/kit/directives/sensitive';

package/directives/password/password.directive.d.ts

@@ -1,7 +1,7 @@
 import { TuiTextfieldComponent } from '@taiga-ui/core/components/textfield';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/appearance";
-import * as i2 from "@taiga-ui/core/directives/hint";
+import * as i2 from "@taiga-ui/core/portals/hint";
 export declare class TuiPassword {
     private readonly options;
     private readonly texts;

package/directives/password/password.options.d.ts

@@ -6,4 +6,4 @@ export interface TuiPasswordOptions {
         show: TuiStringHandler<TuiSizeL | TuiSizeS> | string;
     }>;
 }
-export declare const TUI_PASSWORD_OPTIONS: import("@angular/core").InjectionToken<TuiPasswordOptions>, tuiPasswordOptionsProvider: (item: Partial<TuiPasswordOptions> | import("@angular/core").ProviderToken<Partial<TuiPasswordOptions>> | (() => Partial<TuiPasswordOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_PASSWORD_OPTIONS: import("@angular/core").InjectionToken<TuiPasswordOptions>, tuiPasswordOptionsProvider: (item: Partial<TuiPasswordOptions> | (() => Partial<TuiPasswordOptions>)) => import("@angular/core").FactoryProvider;

package/directives/present/present.directive.d.ts

@@ -1,10 +1,8 @@
 import { type OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiPresent implements OnDestroy {
-    private readonly visibility$;
-    readonly tuiPresentChange: import("rxjs").Observable<boolean>;
+    readonly tuiPresent: import("@angular/core").OutputEmitterRef<boolean>;
     ngOnDestroy(): void;
-    protected onAnimation(visibility: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiPresent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiPresent, "[tuiPresentChange]", never, {}, { "tuiPresentChange": "tuiPresentChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiPresent, "[tuiPresent]", never, {}, { "tuiPresent": "tuiPresent"; }, never, never, true, never>;
 }

package/directives/sensitive/sensitive.directive.d.ts

@@ -3,7 +3,7 @@ export declare class TuiSensitive {
     protected readonly nothing: undefined;
     protected readonly offset: number;
     protected readonly height: import("@angular/core").Signal<number | undefined>;
-    tuiSensitive: boolean | null;
+    readonly tuiSensitive: import("@angular/core").InputSignal<boolean | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSensitive, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSensitive, "[tuiSensitive]", never, { "tuiSensitive": { "alias": "tuiSensitive"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSensitive, "[tuiSensitive]", never, { "tuiSensitive": { "alias": "tuiSensitive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/shimmer/shimmer.directive.d.ts

@@ -4,10 +4,10 @@ export declare class TuiShimmer implements OnChanges {
     private readonly isBrowser;
     private readonly el;
     private animation?;
-    protected disabled: boolean;
     protected readonly nothing: undefined;
-    shimmer: boolean;
+    protected disabled: boolean;
+    readonly tuiShimmer: import("@angular/core").InputSignal<boolean>;
     ngOnChanges(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiShimmer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiShimmer, "[tuiShimmer]", never, { "shimmer": { "alias": "tuiShimmer"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiShimmer, "[tuiShimmer]", never, { "tuiShimmer": { "alias": "tuiShimmer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/skeleton/skeleton.directive.d.ts

@@ -5,9 +5,9 @@ export declare class TuiSkeleton implements OnChanges {
     private readonly el;
     private readonly duration;
     protected readonly nothing: undefined;
-    tuiSkeleton: boolean | number | string;
+    protected readonly placeholder: import("@angular/core").Signal<string | null>;
+    readonly tuiSkeleton: import("@angular/core").InputSignal<string | number | boolean>;
     ngOnChanges({ tuiSkeleton }: SimpleChanges): void;
-    protected getPlaceholder(value: boolean | number | string): string | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSkeleton, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSkeleton, "[tuiSkeleton]", never, { "tuiSkeleton": { "alias": "tuiSkeleton"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSkeleton, "[tuiSkeleton]", never, { "tuiSkeleton": { "alias": "tuiSkeleton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/tooltip/tooltip.directive.d.ts

@@ -2,7 +2,7 @@ import { type DoCheck, type Signal } from '@angular/core';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/appearance";
-import * as i2 from "@taiga-ui/core/directives/hint";
+import * as i2 from "@taiga-ui/core/portals/hint";
 export declare class TuiTooltip implements DoCheck {
     private readonly textfield;
     private readonly isMobile;
@@ -10,9 +10,9 @@ export declare class TuiTooltip implements DoCheck {
     private readonly driver;
     protected readonly nothing: undefined;
     protected readonly state: Signal<unknown>;
-    size: TuiSizeS;
+    readonly size: import("@angular/core").InputSignal<TuiSizeS>;
     ngDoCheck(): void;
     protected onClick(event: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTooltip, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTooltip, "tui-icon[tuiTooltip]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiHintDescribe; inputs: { "tuiHintDescribe": "tuiTooltipDescribe"; }; outputs: {}; }, { directive: typeof i2.TuiHintDirective; inputs: { "tuiHint": "tuiTooltip"; "tuiHintAppearance": "tuiHintAppearance"; "tuiHintContext": "tuiHintContext"; }; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTooltip, "tui-icon[tuiTooltip]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiHintDescribe; inputs: { "tuiHintDescribe": "tuiTooltipDescribe"; }; outputs: {}; }, { directive: typeof i2.TuiHintDirective; inputs: { "tuiHint": "tuiTooltip"; "tuiHintAppearance": "tuiHintAppearance"; "tuiHintContext": "tuiHintContext"; }; outputs: {}; }]>;
 }

package/directives/tooltip/tooltip.options.d.ts

@@ -4,10 +4,7 @@ export declare const TUI_TOOLTIP_OPTIONS: import("@angular/core").InjectionToken
 }>, tuiTooltipOptionsProvider: (item: Partial<{
     icon: string;
     appearance: string;
-}> | import("@angular/core").ProviderToken<Partial<{
-    icon: string;
-    appearance: string;
-}>> | (() => Partial<{
+}> | (() => Partial<{
     icon: string;
     appearance: string;
 }>)) => import("@angular/core").FactoryProvider;

package/directives/unfinished-validator/unfinished-validator.directive.d.ts

@@ -5,8 +5,8 @@ export declare class TuiUnfinishedValidator implements Validator {
     private readonly error;
     private readonly fallback;
     private readonly message;
-    tuiUnfinishedValidator: string;
+    readonly tuiUnfinishedValidator: import("@angular/core").InputSignal<string>;
     readonly validate: import("@angular/forms").ValidatorFn;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiUnfinishedValidator, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiUnfinishedValidator, "input[tuiUnfinishedValidator]", never, { "tuiUnfinishedValidator": { "alias": "tuiUnfinishedValidator"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiUnfinishedValidator, "input[tuiUnfinishedValidator]", never, { "tuiUnfinishedValidator": { "alias": "tuiUnfinishedValidator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }