@taiga-ui/kit 4.52.0-canary.abf3e8c → 4.52.0-canary.ae38a1e

package/components/push/push.component.d.ts

@@ -1,15 +1,14 @@
-import { EventEmitter } from '@angular/core';
 import { tuiIsString } from '@taiga-ui/cdk/utils/miscellaneous';
 import * as i0 from "@angular/core";
 export declare class TuiPushComponent {
     protected readonly isString: typeof tuiIsString;
     protected readonly closeWord: import("@angular/core").Signal<string>;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    heading: string;
-    type: string;
-    lines: number;
-    timestamp: number | string;
-    readonly close: EventEmitter<void>;
+    readonly heading: import("@angular/core").InputSignal<string>;
+    readonly type: import("@angular/core").InputSignal<string>;
+    readonly lines: import("@angular/core").InputSignal<number>;
+    readonly timestamp: import("@angular/core").InputSignal<string | number>;
+    readonly close: import("@angular/core").OutputEmitterRef<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiPushComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiPushComponent, "tui-push", never, { "heading": { "alias": "heading"; "required": false; }; "type": { "alias": "type"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "timestamp": { "alias": "timestamp"; "required": false; }; }, { "close": "close"; }, never, ["img", "tui-icon", "*", "[tuiButton]", "[tuiLink]"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiPushComponent, "tui-push", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "timestamp": { "alias": "timestamp"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["img", "tui-icon", "*", "[tuiButton]", "[tuiLink]"], true, never>;
 }

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

@@ -1,23 +1,23 @@
 import { type ValidatorFn } from '@angular/forms';
 import { TuiControl } from '@taiga-ui/cdk/classes';
-import { type TuiBooleanHandler, type TuiContext, type TuiIdentityMatcher } from '@taiga-ui/cdk/types';
+import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/items-handlers";
 export declare class TuiRadioList<T> extends TuiControl<T> {
     private readonly controls;
     private readonly id;
-    protected validator: import("@angular/core").Signal<ValidatorFn>;
-    items: readonly T[];
-    size: TuiSizeS;
-    identityMatcher: TuiIdentityMatcher<T>;
-    disabledItemHandler: TuiBooleanHandler<T>;
-    itemContent: PolymorpheusContent<TuiContext<T> & {
+    protected readonly handlers: import("@taiga-ui/core/directives/items-handlers").TuiItemsHandlers<unknown>;
+    protected readonly validator: import("@angular/core").Signal<ValidatorFn>;
+    readonly items: import("@angular/core").InputSignal<readonly T[] | undefined>;
+    readonly size: import("@angular/core").InputSignal<TuiSizeS>;
+    readonly itemContent: import("@angular/core").InputSignal<PolymorpheusContent<TuiContext<T> & {
         active: boolean;
-    }>;
+    }>>;
     protected get name(): string;
     protected onFocusOut(): void;
     protected itemIsActive(item: T): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiRadioList<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRadioList<any>, "tui-radio-list", never, { "items": { "alias": "items"; "required": false; }; "size": { "alias": "size"; "required": false; }; "identityMatcher": { "alias": "identityMatcher"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "itemContent": { "alias": "itemContent"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRadioList<any>, "tui-radio-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "itemContent": { "alias": "itemContent"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithItemsHandlers; inputs: {}; outputs: {}; }]>;
 }

package/components/range/range.component.d.ts

@@ -12,23 +12,22 @@ export declare class TuiRange extends TuiControl<[number, number]> {
     readonly step: import("@angular/core").InputSignal<number>;
     readonly size: import("@angular/core").InputSignal<TuiSizeS>;
     readonly segments: import("@angular/core").InputSignal<number>;
-    readonly keySteps: import("@angular/core").InputSignal<[[0, number], ...[number, number][], [100, number]] | null>;
+    readonly keySteps: import("@angular/core").InputSignal<[[0, number], ...[number, number][], [100, number]] | undefined>;
     readonly focusable: import("@angular/core").InputSignal<boolean>;
     readonly margin: import("@angular/core").InputSignal<number>;
     readonly limit: import("@angular/core").InputSignal<number>;
-    readonly slidersRefs: import("@angular/core").Signal<readonly ElementRef<HTMLInputElement>[]>;
     readonly start: import("@angular/core").Signal<number>;
     readonly end: import("@angular/core").Signal<number>;
+    readonly sliders: import("@angular/core").Signal<readonly ElementRef<HTMLInputElement>[]>;
+    protected readonly segmentWidthRatio: import("@angular/core").Signal<number>;
     protected readonly fractionStep: import("@angular/core").Signal<number>;
     protected readonly computedKeySteps: import("@angular/core").Signal<[[0, number], ...[number, number][], [100, number]]>;
-    protected readonly segmentWidthRatio: import("@angular/core").Signal<number>;
     processValue(value: number, end: boolean): void;
     takeStep(coefficients: readonly [number, number]): readonly [number, number];
     toValue(fraction: number): number;
     protected get rtl(): boolean;
     protected changeByStep(coefficient: number, target: HTMLElement): void;
     protected toPercent(value: number): number;
-    private computePureKeySteps;
     private updateStart;
     private updateEnd;
     private checkDistance;

package/components/select/select.d.ts

@@ -1,6 +1,6 @@
 import { TuiLabel } from '@taiga-ui/core/components/label';
 import { TuiTextfieldComponent, TuiTextfieldOptionsDirective } from '@taiga-ui/core/components/textfield';
-import { TuiDropdownContent } from '@taiga-ui/core/portals';
+import { TuiDropdownContent } from '@taiga-ui/core/portals/dropdown';
 import { TuiNativeSelect } from './native-select/native-select.component';
 import { TuiSelectDirective } from './select.directive';
 export declare const TuiSelect: readonly [typeof TuiSelectDirective, typeof TuiNativeSelect, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

package/components/slider/helpers/slider-key-steps.directive.d.ts

@@ -1,28 +1,31 @@
+import { type OnInit } from '@angular/core';
 import { TuiControl, type TuiValueTransformer } from '@taiga-ui/cdk/classes';
 import { TuiSliderComponent } from '../slider.component';
 import { type TuiKeySteps } from './key-steps';
 import * as i0 from "@angular/core";
-export declare class TuiSliderKeyStepsBase {
+export declare class TuiSliderKeyStepsBase implements OnInit {
     private readonly injector;
     private readonly control;
     protected readonly min: import("@angular/core").WritableSignal<number | undefined>;
     protected readonly max: import("@angular/core").WritableSignal<number | undefined>;
-    step: import("@angular/core").InputSignal<number>;
-    transformer: import("@angular/core").WritableSignal<TuiValueTransformer<number, number> | null>;
+    protected readonly sync: import("@angular/core").EffectRef;
+    slider: TuiSliderComponent;
+    readonly step: import("@angular/core").InputSignal<number>;
+    readonly keySteps: import("@angular/core").InputSignal<[[0, number], ...[number, number][], [100, number]] | undefined>;
+    readonly transformer: import("@angular/core").WritableSignal<TuiValueTransformer<number, number> | undefined>;
     controlValue: import("@angular/core").Signal<number | undefined>;
     readonly totalSteps: import("@angular/core").Signal<number>;
-    get slider(): TuiSliderComponent;
-    set keySteps(steps: TuiKeySteps | null);
+    ngOnInit(): void;
     takeStep(coefficient: number): number;
     toSliderValue(fraction: number): number;
     setControlValue(controlValue: number): void;
     getControlValue(): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderKeyStepsBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderKeyStepsBase, "input[tuiSlider][keySteps]", never, { "step": { "alias": "step"; "required": false; "isSignal": true; }; "keySteps": { "alias": "keySteps"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderKeyStepsBase, "input[tuiSlider][keySteps]", never, { "step": { "alias": "step"; "required": false; "isSignal": true; }; "keySteps": { "alias": "keySteps"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 export declare class TuiSliderKeySteps extends TuiControl<number> {
     protected readonly base: TuiSliderKeyStepsBase;
-    set keySteps(steps: TuiKeySteps | null);
+    set keySteps(steps: TuiKeySteps | null | undefined);
     protected setValue(sliderValue: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderKeySteps, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderKeySteps, "input[tuiSlider][keySteps][ngModel],input[tuiSlider][keySteps][formControl],input[tuiSlider][keySteps][formControlName]", never, { "keySteps": { "alias": "keySteps"; "required": false; }; }, {}, never, never, true, never>;

package/components/slider/helpers/slider-readonly.directive.d.ts

@@ -1,4 +1,3 @@
-import { type BooleanInput } from '@angular/cdk/coercion';
 import * as i0 from "@angular/core";
 /**
  * Native <input type='range' readonly> doesn't work.
@@ -7,11 +6,10 @@ import * as i0 from "@angular/core";
 export declare class TuiSliderReadonly {
     private readonly el;
     private readonly doc;
-    readonly: BooleanInput;
+    readonly readonly: import("@angular/core").InputSignalWithTransform<boolean, any>;
     constructor();
     protected preventEvent(event: Event): void;
     protected preventKeyboardInteraction(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderReadonly, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderReadonly, "input[tuiSlider][readonly]", never, { "readonly": { "alias": "readonly"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_readonly: any;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderReadonly, "input[tuiSlider][readonly]", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/slider/helpers/slider-thumb-label.component.d.ts

@@ -1,13 +1,11 @@
 import { type AfterContentInit } from '@angular/core';
 import { NgControl } from '@angular/forms';
-import { type TuiSizeS } from '@taiga-ui/core/types';
 import { TuiSliderComponent } from '../slider.component';
 import * as i0 from "@angular/core";
 export declare class TuiSliderThumbLabel implements AfterContentInit {
-    protected readonly slider?: TuiSliderComponent;
-    protected readonly control?: NgControl;
+    protected readonly slider: import("@angular/core").Signal<TuiSliderComponent | undefined>;
+    protected readonly control: import("@angular/core").Signal<NgControl | undefined>;
     ngAfterContentInit(): void;
-    protected get size(): TuiSizeS;
     protected get ratio(): number;
     protected get ghostStart(): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderThumbLabel, never>;

package/components/slider/slider.component.d.ts

@@ -1,16 +1,14 @@
-import { type TuiSizeS } from '@taiga-ui/core/types';
 import { TuiSliderKeyStepsBase } from './helpers/slider-key-steps.directive';
 import * as i0 from "@angular/core";
 export declare class TuiSliderComponent {
     private readonly control;
     protected readonly options: import("./slider.options").TuiSliderOptions;
-    protected readonly segments: import("@angular/core").WritableSignal<number[]>;
     protected readonly ticksGradient: import("@angular/core").Signal<string>;
-    size: TuiSizeS;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeS>;
+    readonly segments: import("@angular/core").InputSignalWithTransform<readonly number[], number | readonly number[]>;
     readonly el: HTMLInputElement;
     readonly keySteps: TuiSliderKeyStepsBase | null;
     constructor();
-    set segmentsSetter(segments: number[]);
     get valueRatio(): number;
     get min(): number;
     set min(x: number);
@@ -20,8 +18,7 @@ export declare class TuiSliderComponent {
     set step(x: number);
     get value(): number;
     set value(newValue: number);
-    protected getTicksGradient(segments: number[]): string;
+    protected getTicksGradient(segments: readonly number[]): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSliderComponent, "input[type=range][tuiSlider]", never, { "size": { "alias": "size"; "required": false; }; "segmentsSetter": { "alias": "segments"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_segmentsSetter: number[] | number;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSliderComponent, "input[type=range][tuiSlider]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "segments": { "alias": "segments"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/stepper/step.component.d.ts

@@ -1,15 +1,22 @@
 import { TuiStepperComponent } from './stepper.component';
 import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/components/cell";
+import * as i2 from "@taiga-ui/core/directives/appearance";
 export declare class TuiStep {
     private readonly el;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly appearance: import("@angular/core").Signal<string>;
+    protected readonly size: import("@angular/core").Signal<"" | "m" | "l" | "s"> | import("@angular/core").WritableSignal<""> | import("@angular/core").WritableSignal<"m"> | import("@angular/core").WritableSignal<"l"> | import("@angular/core").WritableSignal<"s">;
     protected readonly stepper: TuiStepperComponent;
     protected readonly $: import("rxjs").Subscription;
     readonly stepState: import("@angular/core").InputSignal<"error" | "normal" | "pass">;
     readonly icon: import("@angular/core").InputSignal<string>;
-    protected get isActive(): boolean;
+    protected readonly isActive: import("@angular/core").Signal<boolean>;
+    protected avatarAppearance: import("@angular/core").Signal<"primary" | "negative" | "secondary">;
+    protected readonly avatarContent: import("@angular/core").Signal<string>;
+    protected readonly avatarIcon: import("@angular/core").Signal<string>;
     protected get index(): number;
     protected activate(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiStep, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiStep, "button[tuiStep], a[tuiStep]:not([routerLink]), a[tuiStep][routerLink][routerLinkActive]", never, { "stepState": { "alias": "stepState"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiStep, "button[tuiStep], a[tuiStep]:not([routerLink]), a[tuiStep][routerLink][routerLinkActive]", never, { "stepState": { "alias": "stepState"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.TuiCell; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithAppearance; inputs: {}; outputs: {}; }]>;
 }

package/components/stepper/stepper.component.d.ts

@@ -1,11 +1,9 @@
-import { ElementRef, type OnChanges } from '@angular/core';
+import { type OnChanges } from '@angular/core';
 import { type TuiOrientation } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiStepperComponent implements OnChanges {
-    private readonly cdr;
     private readonly el;
     private readonly steps;
-    protected readonly changes$: import("rxjs").Observable<readonly ElementRef<any>[]>;
     protected readonly $: import("rxjs").Subscription;
     readonly orientation: import("@angular/core").InputSignal<TuiOrientation>;
     readonly activeItemIndex: import("@angular/core").ModelSignal<number>;

package/components/tabs/tabs-horizontal.directive.d.ts

@@ -1,17 +1,16 @@
-import { type AfterViewChecked, type QueryList } from '@angular/core';
+import { type AfterViewChecked } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "./tabs.directive";
 export declare class TuiTabsHorizontal implements AfterViewChecked {
     private readonly el;
     private readonly options;
     private readonly tabs;
-    protected readonly children: QueryList<unknown>;
     protected readonly sub: import("rxjs").Subscription;
-    underline: string | boolean;
+    readonly underline: import("@angular/core").InputSignal<string | boolean>;
+    constructor();
     ngAfterViewChecked(): void;
     protected onKeyDownArrow(current: HTMLElement, step: number): void;
     protected refresh(): void;
-    private scrollTo;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsHorizontal, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsHorizontal, "tui-tabs:not([vertical]), nav[tuiTabs]:not([vertical])", never, { "underline": { "alias": "underline"; "required": false; }; }, {}, ["children"], never, true, [{ directive: typeof i1.TuiTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsHorizontal, "tui-tabs:not([vertical]), nav[tuiTabs]:not([vertical])", never, { "underline": { "alias": "underline"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
 }

package/components/tabs/tabs-vertical.directive.d.ts

@@ -3,8 +3,8 @@ import * as i0 from "@angular/core";
 import * as i1 from "./tabs.directive";
 export declare class TuiTabsVertical {
     private readonly tabs;
-    vertical: TuiHorizontalDirection;
+    readonly vertical: import("@angular/core").InputSignal<TuiHorizontalDirection>;
     protected onKeyDownArrow(current: HTMLElement, step: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsVertical, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsVertical, "tui-tabs[vertical], nav[tuiTabs][vertical]", never, { "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsVertical, "tui-tabs[vertical], nav[tuiTabs][vertical]", never, { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
 }

package/components/tabs/tabs-with-more.component.d.ts

@@ -1,28 +1,26 @@
-import { type AfterViewChecked, type AfterViewInit, EventEmitter, type QueryList, TemplateRef } from '@angular/core';
+import { type AfterViewChecked, type AfterViewInit, TemplateRef } from '@angular/core';
 import { type TuiActiveZone } from '@taiga-ui/cdk/directives/active-zone';
 import { type TuiContext } from '@taiga-ui/cdk/types';
-import { type TuiSizeL } from '@taiga-ui/core/types';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
 export declare class TuiTabsWithMore implements AfterViewChecked, AfterViewInit {
-    private readonly moreButton?;
-    private readonly dir?;
+    private readonly moreButton;
+    private readonly dir;
     private readonly options;
     private readonly refresh$;
     private readonly el;
     private readonly cdr;
     private maxIndex;
-    protected readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
     protected readonly moreWord: import("@angular/core").Signal<string>;
     protected open: boolean;
-    size: TuiSizeL;
-    moreContent: PolymorpheusContent;
-    dropdownContent: PolymorpheusContent<TuiContext<TuiActiveZone>>;
-    underline: string | boolean;
-    itemsLimit: number;
-    readonly activeItemIndexChange: EventEmitter<number>;
-    activeItemIndex: number;
-    set itemIndex(activeItemIndex: number);
+    protected readonly sync: import("@angular/core").EffectRef;
+    readonly activeItemIndex: import("@angular/core").ModelSignal<number>;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeL>;
+    readonly underline: import("@angular/core").InputSignal<string | boolean>;
+    readonly itemsLimit: import("@angular/core").InputSignal<number>;
+    readonly moreContent: import("@angular/core").InputSignal<PolymorpheusContent>;
+    readonly dropdownContent: import("@angular/core").InputSignal<PolymorpheusContent<TuiContext<TuiActiveZone>>>;
     get lastVisibleIndex(): number;
     ngAfterViewInit(): void;
     ngAfterViewChecked(): void;
@@ -32,7 +30,6 @@ export declare class TuiTabsWithMore implements AfterViewChecked, AfterViewInit
     protected get isMoreVisible(): boolean;
     protected get isMoreFocusable(): boolean;
     protected get isMoreActive(): boolean;
-    protected onActiveItemIndexChange(activeItemIndex: number): void;
     protected onClick(index: number): void;
     protected onArrowRight(event: Event): void;
     protected onArrowLeft(): void;
@@ -42,8 +39,7 @@ export declare class TuiTabsWithMore implements AfterViewChecked, AfterViewInit
     private get margin();
     private focusMore;
     private getMaxIndex;
-    private updateActiveItemIndex;
     private refresh;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsWithMore, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTabsWithMore, "tui-tabs-with-more, nav[tuiTabsWithMore]", never, { "size": { "alias": "size"; "required": false; }; "moreContent": { "alias": "moreContent"; "required": false; }; "dropdownContent": { "alias": "dropdownContent"; "required": false; }; "underline": { "alias": "underline"; "required": false; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; }; "itemIndex": { "alias": "activeItemIndex"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, ["items"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTabsWithMore, "tui-tabs-with-more, nav[tuiTabsWithMore]", never, { "activeItemIndex": { "alias": "activeItemIndex"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "underline": { "alias": "underline"; "required": false; "isSignal": true; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; "isSignal": true; }; "moreContent": { "alias": "moreContent"; "required": false; "isSignal": true; }; "dropdownContent": { "alias": "dropdownContent"; "required": false; "isSignal": true; }; }, { "activeItemIndex": "activeItemIndexChange"; }, ["items"], ["*"], true, never>;
 }

package/components/tabs/tabs.directive.d.ts

@@ -1,19 +1,17 @@
-import { type AfterViewChecked, EventEmitter } from '@angular/core';
-import { type TuiSizeL } from '@taiga-ui/core/types';
+import { type AfterViewChecked } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiTabsDirective implements AfterViewChecked {
     private readonly el;
     private readonly injector;
     protected readonly nothing: undefined;
-    size: TuiSizeL;
-    activeItemIndex: number;
-    readonly activeItemIndexChange: EventEmitter<number>;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeL>;
+    readonly activeItemIndex: import("@angular/core").ModelSignal<number>;
     get tabs(): readonly HTMLElement[];
     get activeElement(): HTMLElement | null;
     moveFocus(current: HTMLElement, step: number): void;
     ngAfterViewChecked(): void;
-    protected onActivate(event: Event, element: HTMLElement): void;
+    protected onActivate(element: HTMLElement): void;
     protected markTabAsActive(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsDirective, never, never, { "size": { "alias": "size"; "required": false; }; "activeItemIndex": { "alias": "activeItemIndex"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsDirective, never, never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "activeItemIndex": { "alias": "activeItemIndex"; "required": false; "isSignal": true; }; }, { "activeItemIndex": "activeItemIndexChange"; }, never, never, true, never>;
 }

package/components/textarea/textarea.component.d.ts

@@ -1,21 +1,20 @@
-import { type AfterViewInit, ElementRef } from '@angular/core';
+import { type AfterViewInit } from '@angular/core';
 import { TuiTextfieldComponent } from '@taiga-ui/core/components/textfield';
-import { type TuiTextareaOptions } from './textarea.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/components/input";
 export declare class TuiTextareaComponent implements AfterViewInit {
-    private readonly template?;
+    private readonly template;
     private readonly options;
     private readonly vcr;
-    protected readonly text?: ElementRef<HTMLElement>;
+    private readonly text;
     protected readonly el: HTMLTextAreaElement;
     protected readonly textfield: TuiTextfieldComponent<any>;
     protected readonly isMobile: boolean;
-    min: number;
-    max: number;
-    content: TuiTextareaOptions['content'];
+    readonly min: import("@angular/core").InputSignal<number>;
+    readonly max: import("@angular/core").InputSignal<number>;
+    readonly content: import("@angular/core").InputSignal<import("@taiga-ui/polymorpheus").PolymorpheusContent<import("@taiga-ui/cdk/types").TuiContext<string>>>;
     ngAfterViewInit(): void;
     protected onScroll(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTextareaComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextareaComponent, "textarea[tuiTextarea]", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTextareaComponent, "textarea[tuiTextarea]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }]>;
 }

package/components/textarea/textarea.d.ts

@@ -1,6 +1,6 @@
 import { TuiLabel } from '@taiga-ui/core/components/label';
 import { TuiTextfieldComponent, TuiTextfieldOptionsDirective } from '@taiga-ui/core/components/textfield';
-import { TuiDropdownContent } from '@taiga-ui/core/portals';
+import { TuiDropdownContent } from '@taiga-ui/core/portals/dropdown';
 import { TuiTextareaComponent } from './textarea.component';
 import { TuiTextareaDirective } from './textarea.directive';
 export declare const TuiTextarea: readonly [typeof TuiTextareaComponent, typeof TuiTextareaDirective, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

package/components/tiles/tile-handle.directive.d.ts

@@ -1,10 +1,11 @@
 import * as i0 from "@angular/core";
 export declare class TuiTileHandle {
+    private readonly doc;
     private readonly tile;
     private x;
     private y;
+    protected readonly pointerSub: import("rxjs").Subscription;
     protected onPointer(x?: number, y?: number): void;
-    protected onMove(x: number, y: number): void;
     protected onStart(event: PointerEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTileHandle, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTileHandle, "[tuiTileHandle]", never, {}, {}, never, never, true, never>;

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/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,8 +5,8 @@ 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 attached: import("@angular/core").Signal<boolean>;

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