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

package/components/avatar/avatar-labeled.component.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class TuiAvatarLabeled {
-    label: string;
-    protected split(label: string): readonly string[];
+    readonly label: import("@angular/core").InputSignal<string>;
+    protected readonly words: import("@angular/core").Signal<string[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAvatarLabeled, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarLabeled, "tui-avatar-labeled", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarLabeled, "tui-avatar-labeled", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/avatar/avatar-stack.component.d.ts

@@ -1,7 +1,7 @@
 import { type TuiHorizontalDirection } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiAvatarStack {
-    direction: TuiHorizontalDirection;
+    readonly direction: import("@angular/core").InputSignal<TuiHorizontalDirection>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAvatarStack, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarStack, "tui-avatar-stack", never, { "direction": { "alias": "direction"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarStack, "tui-avatar-stack", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

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

@@ -1,8 +1,7 @@
-import { type TuiSizeL, type TuiSizeXS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
 export declare class TuiBadgeNotification {
-    size: TuiSizeL | TuiSizeXS;
+    readonly size: import("@angular/core").InputSignal<"m" | "l" | "s" | "xs">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBadgeNotification, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBadgeNotification, "tui-badge-notification", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBadgeNotification, "tui-badge-notification", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
 }

package/components/badged-content/badged-content.directive.d.ts

@@ -1,7 +1,6 @@
-import { type TuiLooseUnion } from '@taiga-ui/cdk/types';
 import * as i0 from "@angular/core";
 export declare class TuiBadgedContentDirective {
-    tuiSlot: TuiLooseUnion<'bottom' | 'top'>;
+    readonly tuiSlot: import("@angular/core").InputSignal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBadgedContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadgedContentDirective, "[tuiSlot]", never, { "tuiSlot": { "alias": "tuiSlot"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadgedContentDirective, "[tuiSlot]", never, { "tuiSlot": { "alias": "tuiSlot"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/breadcrumbs/breadcrumbs.component.d.ts

@@ -1,15 +1,14 @@
-import { type QueryList, TemplateRef } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { type TuiBreadcrumbsOptions } from './breadcrumbs.options';
 import * as i0 from "@angular/core";
 export declare class TuiBreadcrumbs {
-    protected readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
     protected readonly options: TuiBreadcrumbsOptions;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     protected readonly more: import("@angular/core").Signal<string>;
-    size: TuiBreadcrumbsOptions['size'];
-    itemsLimit: number;
-    protected get limit(): number;
-    protected get offset(): number;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeL>;
+    readonly itemsLimit: import("@angular/core").InputSignal<number>;
+    protected readonly offset: import("@angular/core").Signal<0 | 1>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBreadcrumbs, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBreadcrumbs, "tui-breadcrumbs", never, { "size": { "alias": "size"; "required": false; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; }; }, {}, ["items"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBreadcrumbs, "tui-breadcrumbs", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
 }

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

@@ -2,11 +2,11 @@ import { type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiButtonLoading {
     private readonly options;
-    size: "m" | "l" | "xl" | "s" | "xs";
-    loading: boolean | string | null;
-    protected get loaderSize(): TuiSizeS;
-    protected get label(): string;
+    readonly size: import("@angular/core").InputSignal<"m" | "l" | "xl" | "s" | "xs">;
+    readonly loading: import("@angular/core").InputSignal<string | boolean | null>;
+    protected readonly loaderSize: import("@angular/core").Signal<TuiSizeS>;
+    protected readonly label: import("@angular/core").Signal<string | boolean | null>;
     protected onClick(event: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiButtonLoading, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiButtonLoading, "[tuiButton][loading],[tuiIconButton][loading]", never, { "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiButtonLoading, "[tuiButton][loading],[tuiIconButton][loading]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

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

@@ -7,10 +7,11 @@ export declare class TuiCalendarMonth {
     protected isYearPickerShown: boolean;
     protected readonly months: import("@angular/core").Signal<readonly [January: string, February: string, March: string, April: string, May: string, June: string, July: string, August: string, September: string, October: string, November: string, December: string]>;
     protected readonly isRangePicking: import("@angular/core").Signal<boolean>;
+    protected readonly handler: import("@angular/core").Signal<TuiBooleanHandler<TuiMonth>>;
     year: TuiYear;
-    disabledItemHandler: TuiBooleanHandler<TuiMonth>;
-    minLength: number | null;
-    maxLength: number | null;
+    readonly minLength: import("@angular/core").InputSignal<number | null>;
+    readonly maxLength: import("@angular/core").InputSignal<number | null>;
+    readonly disabledItemHandler: import("@angular/core").InputSignal<TuiBooleanHandler<TuiMonth>>;
     readonly monthClick: EventEmitter<TuiMonth>;
     readonly hoveredItemChange: EventEmitter<TuiMonth | null>;
     readonly yearChange: EventEmitter<TuiYear>;
@@ -25,7 +26,6 @@ export declare class TuiCalendarMonth {
     onNextYear(): void;
     onPreviousYear(): void;
     getItemRange(item: TuiMonth): 'active' | 'end' | 'middle' | 'start' | null;
-    protected get disabledItemHandlerWithMinMax(): TuiBooleanHandler<TuiMonth>;
     protected getTuiMonth(monthNumber: number, yearNumber: number): TuiMonth;
     protected isItemToday(item: TuiMonth): boolean;
     protected onPickerYearClick(year: number): void;
@@ -36,7 +36,7 @@ export declare class TuiCalendarMonth {
     private updateHoveredItem;
     private updateActiveYear;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCalendarMonth, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCalendarMonth, "tui-calendar-month", never, { "year": { "alias": "year"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "required": false; }; "valueSetter": { "alias": "value"; "required": false; }; }, { "monthClick": "monthClick"; "hoveredItemChange": "hoveredItemChange"; "yearChange": "yearChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCalendarMonth, "tui-calendar-month", never, { "year": { "alias": "year"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; "isSignal": true; }; "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "required": false; }; "valueSetter": { "alias": "value"; "required": false; }; }, { "monthClick": "monthClick"; "hoveredItemChange": "hoveredItemChange"; "yearChange": "yearChange"; }, never, never, true, never>;
     static ngAcceptInputType_minSetter: i1.TuiMonth | null;
     static ngAcceptInputType_maxSetter: i1.TuiMonth | null;
 }

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

@@ -28,7 +28,6 @@ export declare class TuiCalendarRange implements OnInit, OnChanges {
     item: TuiDayRangePeriod | null;
     readonly valueChange: EventEmitter<TuiDayRange | null>;
     readonly itemChange: EventEmitter<TuiDayRangePeriod | null>;
-    constructor();
     set valueSetter(value: TuiDayRange | null);
     set defaultViewedMonth(month: TuiMonth);
     set value(value: TuiDayRange | null);
@@ -43,7 +42,6 @@ export declare class TuiCalendarRange implements OnInit, OnChanges {
     set selectedActivePeriod(period: TuiDayRangePeriod | null);
     ngOnChanges(): void;
     ngOnInit(): void;
-    protected get calculatedDisabledItemHandler(): TuiBooleanHandler<TuiDay>;
     protected onEsc(event: KeyboardEvent): void;
     protected readonly monthOffset: TuiMapper<[TuiMonth, number], TuiMonth>;
     protected readonly mapper: TuiMapper<[
@@ -53,13 +51,13 @@ export declare class TuiCalendarRange implements OnInit, OnChanges {
         TuiDayLike | null,
         string | null | undefined
     ], ReadonlyArray<TuiDayRangePeriod | string>>;
+    protected readonly disabledMapper: (disabledItemHandler: TuiBooleanHandler<TuiDay>, value: TuiDay | TuiDayRange | null, minLength: TuiDayLike | null) => TuiBooleanHandler<TuiDay>;
     protected isItemActive(item: TuiDayRangePeriod | string): boolean;
     protected onItemSelect(item: TuiDayRangePeriod | string): void;
     protected onMonthChange(month: TuiMonth): void;
     protected onDayClick(day: TuiDay): void;
     protected updateValue(value: TuiDayRange | null): void;
     private get activePeriod();
-    private calculateDisabledItemHandler;
     private initDefaultViewedMonth;
     private findItemByDayRange;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCalendarRange, never>;

package/components/calendar-range/day-range-period.d.ts

@@ -1,5 +1,6 @@
 import { TuiDayRange } from '@taiga-ui/cdk/date-time';
 import { type TuiContext } from '@taiga-ui/cdk/types';
+import { type TuiLanguageKit } from '@taiga-ui/i18n/types';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 export declare class TuiDayRangePeriod {
     readonly range: TuiDayRange;
@@ -8,4 +9,4 @@ export declare class TuiDayRangePeriod {
     constructor(range: TuiDayRange, name: string, content?: PolymorpheusContent<TuiContext<TuiDayRange>>);
     toString(): string;
 }
-export declare function tuiCreateDefaultDayRangePeriods(periodTitles?: [string, string, string, string, string, string]): readonly TuiDayRangePeriod[];
+export declare function tuiCreateDefaultDayRangePeriods(periodTitles?: TuiLanguageKit['dayRangePeriods']): readonly TuiDayRangePeriod[];

package/components/carousel/carousel-autoscroll.directive.d.ts

@@ -1,7 +1,6 @@
-import { TuiCarouselDirective } from './carousel.directive';
 import * as i0 from "@angular/core";
 export declare class TuiCarouselAutoscroll {
-    readonly tuiCarouselAutoscroll: TuiCarouselDirective;
+    readonly tuiCarouselAutoscroll: import("@angular/core").OutputRef<unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselAutoscroll, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselAutoscroll, "[tuiCarouselAutoscroll]", never, {}, { "tuiCarouselAutoscroll": "tuiCarouselAutoscroll"; }, never, never, true, never>;
 }

package/components/carousel/carousel-scroll.directive.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class TuiCarouselScroll {
     private readonly el;
-    readonly tuiCarouselScroll: import("rxjs").Observable<number>;
+    readonly tuiCarouselScroll: import("@angular/core").OutputRef<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselScroll, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselScroll, "[tuiCarouselScroll]", never, {}, { "tuiCarouselScroll": "tuiCarouselScroll"; }, never, never, true, never>;
 }

package/components/carousel/carousel.component.d.ts

@@ -1,37 +1,34 @@
-import { EventEmitter, type QueryList, TemplateRef } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { type TuiSwipeDirection } from '@taiga-ui/cdk/directives/swipe';
 import * as i0 from "@angular/core";
 import * as i1 from "./carousel.directive";
 export declare class TuiCarouselComponent {
     private readonly el;
-    private readonly cdr;
     private readonly isMobile;
     private readonly directive;
-    private translate;
-    protected readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
-    protected transitioned: boolean;
-    protected index: number;
-    draggable: boolean;
-    itemsCount: number;
-    readonly indexChange: EventEmitter<number>;
-    readonly shift: EventEmitter<number>;
-    set indexSetter(index: number);
+    private readonly translate;
+    protected readonly transitioned: import("@angular/core").WritableSignal<boolean>;
+    protected readonly transform: import("@angular/core").Signal<string>;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
+    protected readonly computedDraggable: import("@angular/core").Signal<boolean>;
+    protected readonly computedTranslate: import("@angular/core").Signal<number>;
+    protected readonly x: import("@angular/core").Signal<number>;
+    protected readonly resetDuration: import("@angular/core").EffectRef;
+    readonly draggable: import("@angular/core").InputSignal<boolean>;
+    readonly itemsCount: import("@angular/core").InputSignal<number>;
+    readonly index: import("@angular/core").ModelSignal<number>;
+    readonly shift: import("@angular/core").OutputEmitterRef<number>;
     next(): void;
     prev(): void;
-    protected get transform(): string;
-    protected getStyle(itemsCount: number): Partial<CSSStyleDeclaration>;
     protected onTransitioned(transitioned: boolean): void;
     protected isDisabled(index: number): boolean;
-    protected onIntersection({ intersectionRatio }: IntersectionObserverEntry, index: number): void;
+    protected onIntersection(ratio: number, index: number): void;
     protected onScroll(delta: number): void;
     protected onPan(x: number): void;
     protected onSwipe(direction: TuiSwipeDirection): void;
     protected onAutoscroll(): void;
     protected onShift(): void;
-    private get x();
-    private get computedTranslate();
-    private get computedDraggable();
     private updateIndex;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCarouselComponent, "tui-carousel", never, { "draggable": { "alias": "draggable"; "required": false; }; "itemsCount": { "alias": "itemsCount"; "required": false; }; "indexSetter": { "alias": "index"; "required": false; }; }, { "indexChange": "indexChange"; "shift": "shift"; }, ["items"], never, true, [{ directive: typeof i1.TuiCarouselDirective; inputs: { "duration": "duration"; }; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCarouselComponent, "tui-carousel", never, { "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "itemsCount": { "alias": "itemsCount"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, { "index": "indexChange"; "shift": "shift"; }, ["items"], ["*"], true, [{ directive: typeof i1.TuiCarouselDirective; inputs: { "duration": "duration"; }; outputs: {}; }]>;
 }

package/components/carousel/carousel.directive.d.ts

@@ -5,11 +5,12 @@ export declare class TuiCarouselDirective extends Observable<unknown> {
     private readonly platform;
     private readonly visible$;
     private readonly zone;
-    private readonly duration$;
+    private readonly trigger$;
     private readonly running$;
-    private readonly output$;
+    readonly duration: import("@angular/core").InputSignal<number>;
+    protected readonly output$: Observable<number>;
     constructor();
-    set duration(duration: number);
+    restart(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselDirective, never, never, { "duration": { "alias": "duration"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselDirective, never, never, { "duration": { "alias": "duration"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/combo-box/combo-box.d.ts

@@ -1,5 +1,5 @@
 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 { TuiComboBoxDirective } from './combo-box.directive';
 export declare const TuiComboBox: readonly [typeof TuiComboBoxDirective, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

package/components/combo-box/combo-box.directive.d.ts

@@ -10,21 +10,19 @@ export declare class TuiComboBoxDirective<T> extends TuiControl<T | string | nul
     private readonly dropdownEnabled;
     private readonly dropdown;
     private readonly handlers;
-    private readonly matcher;
-    private readonly strict;
     private readonly datalist;
     private readonly options;
     protected readonly nonStrictControlEffect: import("@angular/core").EffectRef;
     protected readonly matchingEffect: import("@angular/core").EffectRef;
     protected readonly newValueEffect: import("@angular/core").EffectRef;
     protected readonly blurEffect: import("@angular/core").EffectRef;
-    set strictSetter(x: boolean);
-    set matcherSetter(x: TuiStringMatcher<T> | null);
+    readonly strict: import("@angular/core").InputSignal<boolean>;
+    readonly matcher: import("@angular/core").InputSignal<TuiStringMatcher<T> | null>;
     setValue(value: T | null): void;
     writeValue(value: T | string | null): void;
     protected toggleDropdown(open?: boolean): void;
     protected keydownEnter(event: KeyboardEvent): void;
     private stringify;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiComboBoxDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiComboBoxDirective<any>, "input[tuiComboBox]", never, { "strictSetter": { "alias": "strict"; "required": false; }; "matcherSetter": { "alias": "matcher"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiComboBoxDirective<any>, "input[tuiComboBox]", never, { "strict": { "alias": "strict"; "required": false; "isSignal": true; }; "matcher": { "alias": "matcher"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }]>;
 }

package/components/compass/compass.component.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from "@angular/core";
 export declare class TuiCompass {
-    degrees: number;
+    readonly degrees: import("@angular/core").InputSignal<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCompass, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCompass, "tui-compass", never, { "degrees": { "alias": "degrees"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCompass, "tui-compass", never, { "degrees": { "alias": "degrees"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/copy/copy.component.d.ts

@@ -7,9 +7,8 @@ export declare class TuiCopyComponent {
     protected readonly copied$: BehaviorSubject<boolean>;
     protected readonly texts: import("@angular/core").Signal<readonly [copy: string, copied: string]>;
     protected readonly hint: import("@angular/core").Signal<boolean | undefined>;
-    size: TuiSizeL;
-    protected get icon(): string;
+    readonly size: import("@angular/core").InputSignal<TuiSizeL>;
     protected get check(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCopyComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCopyComponent, "tui-copy", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCopyComponent, "tui-copy", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/drawer/drawer.component.d.ts

@@ -2,9 +2,8 @@ import { type TuiHorizontalDirection } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
 export declare class TuiDrawer {
-    direction: TuiHorizontalDirection;
-    overlay: boolean;
-    get from(): string;
+    readonly direction: import("@angular/core").InputSignal<TuiHorizontalDirection>;
+    readonly overlay: import("@angular/core").InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiDrawer, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiDrawer, "tui-drawer", never, { "direction": { "alias": "direction"; "required": false; }; "overlay": { "alias": "overlay"; "required": false; }; }, {}, never, ["header", "*", "footer"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiDrawer, "tui-drawer", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; }, {}, never, ["header", "*", "footer"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
 }

package/components/files/file/file.component.d.ts

@@ -1,47 +1,34 @@
-import { EventEmitter } from '@angular/core';
-import { type SafeValue } from '@angular/platform-browser';
-import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type TuiSizeL } from '@taiga-ui/core/types';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
-import { type Observable } from 'rxjs';
 import { type TuiFileLike, type TuiFileState } from '../files.types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/appearance";
 export declare class TuiFile {
-    private readonly sanitizer;
     private readonly options;
     private readonly locale;
-    private readonly units$;
+    private readonly units;
     private readonly win;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    protected readonly fileTexts$: Observable<{
+    protected readonly fileTexts: import("@angular/core").Signal<{
         loadingError: string;
         preview: string;
         remove: string;
     }>;
-    file: TuiFileLike;
-    state: TuiFileState;
-    size: TuiSizeL;
-    showDelete: boolean | 'always';
-    showSize: boolean;
-    leftContent: PolymorpheusContent;
-    readonly remove: EventEmitter<void>;
-    protected get preview(): SafeValue;
-    protected get isBig(): boolean;
-    protected get isLoading(): boolean;
-    protected get isError(): boolean;
-    protected get isDeleted(): boolean;
+    protected readonly content: import("@angular/core").Signal<PolymorpheusContent>;
+    protected readonly fileSize: import("@angular/core").Signal<string | null>;
+    protected readonly preview: import("@angular/core").Signal<string>;
+    protected readonly name: import("@angular/core").Signal<string>;
+    protected readonly type: import("@angular/core").Signal<string>;
+    protected readonly icon: import("@angular/core").Signal<PolymorpheusContent<import("@taiga-ui/cdk/types").TuiContext<TuiSizeL>>>;
+    readonly file: import("@angular/core").InputSignal<TuiFileLike>;
+    readonly state: import("@angular/core").InputSignal<TuiFileState>;
+    readonly size: import("@angular/core").InputSignal<TuiSizeL>;
+    readonly showDelete: import("@angular/core").InputSignal<boolean | "always">;
+    readonly showSize: import("@angular/core").InputSignal<boolean>;
+    readonly leftContent: import("@angular/core").InputSignal<PolymorpheusContent>;
+    readonly remove: import("@angular/core").OutputEmitterRef<void>;
     protected get allowDelete(): boolean;
-    protected get icon(): PolymorpheusContent<TuiContext<TuiSizeL>>;
-    protected get name(): string;
-    protected get type(): string;
-    protected get content$(): Observable<PolymorpheusContent>;
-    protected get fileSize$(): Observable<string | null>;
-    private calculateContent$;
-    private calculateFileSize$;
     private createPreview;
-    private getName;
-    private getType;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFile, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFile, "tui-file,a[tuiFile],button[tuiFile]", never, { "file": { "alias": "file"; "required": false; }; "state": { "alias": "state"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showDelete": { "alias": "showDelete"; "required": false; }; "showSize": { "alias": "showSize"; "required": false; }; "leftContent": { "alias": "leftContent"; "required": false; }; }, { "remove": "remove"; }, never, ["*"], true, [{ directive: typeof i1.TuiAppearance; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFile, "tui-file,a[tuiFile],button[tuiFile]", never, { "file": { "alias": "file"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showDelete": { "alias": "showDelete"; "required": false; "isSignal": true; }; "showSize": { "alias": "showSize"; "required": false; "isSignal": true; }; "leftContent": { "alias": "leftContent"; "required": false; "isSignal": true; }; }, { "remove": "remove"; }, never, ["*"], true, [{ directive: typeof i1.TuiAppearance; inputs: {}; outputs: {}; }]>;
 }

package/components/files/files/files.component.d.ts

@@ -1,15 +1,12 @@
-import { EventEmitter, type QueryList, TemplateRef } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/group";
 export declare class TuiFilesComponent {
-    protected readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
     protected readonly hideText: import("@angular/core").Signal<string>;
     protected readonly showAllText: import("@angular/core").Signal<string>;
-    max: number;
-    expanded: boolean;
-    readonly expandedChange: EventEmitter<boolean>;
-    protected get hasExtraItems(): boolean;
-    protected toggle(): void;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
+    readonly max: import("@angular/core").InputSignal<number>;
+    readonly expanded: import("@angular/core").ModelSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFilesComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFilesComponent, "tui-files", never, { "max": { "alias": "max"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; }, { "expandedChange": "expandedChange"; }, ["items"], ["*"], true, [{ directive: typeof i1.TuiGroup; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFilesComponent, "tui-files", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, ["items"], ["*"], true, [{ directive: typeof i1.TuiGroup; inputs: {}; outputs: {}; }]>;
 }

package/components/files/input-files/input-files.component.d.ts

@@ -5,10 +5,10 @@ import { TuiInputFilesContent } from './input-files.content';
 import { TuiInputFilesDirective } from './input-files.directive';
 import * as i0 from "@angular/core";
 export declare class TuiInputFiles {
-    protected readonly template?: TemplateRef<TuiContext<boolean>>;
     protected files?: FileList | null;
     protected readonly content: PolymorpheusComponent<TuiInputFilesContent>;
-    readonly input?: TuiInputFilesDirective;
+    protected readonly template: import("@angular/core").Signal<TemplateRef<TuiContext<boolean>> | undefined>;
+    readonly input: import("@angular/core").Signal<TuiInputFilesDirective | undefined>;
     protected get fileDragged(): boolean;
     protected onFilesSelected(input: HTMLInputElement): void;
     protected onDropped({ dataTransfer }: DragEvent): void;

package/components/files/input-files/input-files.content.d.ts

@@ -1,14 +1,13 @@
-import { type Observable } from 'rxjs';
+import { type TuiContext } from '@taiga-ui/cdk/types';
 import * as i0 from "@angular/core";
 export declare class TuiInputFilesContent {
-    private readonly breakpoint$;
-    private readonly text$;
-    private readonly context;
+    private readonly texts;
     private readonly component;
-    protected get link$(): Observable<string>;
-    protected get label$(): Observable<string>;
-    private computeLink$;
-    private computeLabel$;
+    protected readonly breakpoint: import("@angular/core").Signal<"desktopLarge" | "desktopSmall" | "mobile">;
+    protected readonly context: TuiContext<boolean>;
+    protected readonly link: import("@angular/core").Signal<string>;
+    protected readonly label: import("@angular/core").Signal<string>;
+    protected readonly dragged: import("@angular/core").Signal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputFilesContent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputFilesContent, "ng-component", never, {}, {}, never, never, true, never>;
 }

package/components/files/input-files/input-files.directive.d.ts

@@ -7,8 +7,8 @@ import * as i3 from "./input-files-validator.directive";
 export declare class TuiInputFilesDirective extends TuiControl<TuiFileLike | readonly TuiFileLike[]> {
     protected readonly host: any;
     protected readonly m: import("@angular/core").Signal<string | readonly string[] | null>;
-    readonly reject: import("rxjs").Observable<File[]>;
-    readonly input: HTMLInputElement;
+    readonly el: HTMLInputElement;
+    readonly reject: import("@angular/core").OutputRef<File[]>;
     process(files: FileList): void;
     protected onClick(event: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputFilesDirective, never>;

package/components/filter/filter.component.d.ts

@@ -1,19 +1,16 @@
-import { EventEmitter } from '@angular/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
-import { type TuiBooleanHandler, type TuiHandler, type TuiIdentityMatcher } from '@taiga-ui/cdk/types';
-import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
-import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { type TuiHandler } from '@taiga-ui/cdk/types';
 import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/items-handlers";
 export declare class TuiFilter<T> extends TuiControl<readonly T[]> {
-    identityMatcher: TuiIdentityMatcher<T>;
-    items: readonly T[];
-    size: TuiSizeL | TuiSizeS;
-    disabledItemHandler: TuiBooleanHandler<T>;
-    readonly toggledItem: EventEmitter<T>;
-    content: PolymorpheusContent;
-    badgeHandler: TuiHandler<T, number>;
+    protected readonly handlers: import("@taiga-ui/core/directives/items-handlers").TuiItemsHandlers<unknown>;
+    readonly items: import("@angular/core").InputSignal<readonly T[]>;
+    readonly size: import("@angular/core").InputSignal<"m" | "l" | "s">;
+    readonly badgeHandler: import("@angular/core").InputSignal<TuiHandler<T, number>>;
+    readonly content: import("@angular/core").InputSignal<import("@taiga-ui/polymorpheus").PolymorpheusContent>;
+    readonly toggledItem: import("@angular/core").OutputEmitterRef<T>;
     onCheckbox(value: boolean, item: T): void;
     protected isCheckboxEnabled(item: T): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFilter<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFilter<any>, "tui-filter", never, { "identityMatcher": { "alias": "identityMatcher"; "required": false; }; "items": { "alias": "items"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "content": { "alias": "content"; "required": false; }; "badgeHandler": { "alias": "badgeHandler"; "required": false; }; }, { "toggledItem": "toggledItem"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFilter<any>, "tui-filter", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "badgeHandler": { "alias": "badgeHandler"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, { "toggledItem": "toggledItem"; }, never, never, true, [{ directive: typeof i1.TuiWithItemsHandlers; inputs: {}; outputs: {}; }]>;
 }

package/components/fullscreen/fullscreen.component.d.ts

@@ -1,14 +1,11 @@
-import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiFullscreen {
-    private readonly root?;
+    private readonly root;
     private readonly doc;
-    protected readonly open: import("@angular/core").WritableSignal<boolean>;
-    readonly opened: EventEmitter<boolean>;
-    options?: FullscreenOptions;
-    set fullscreen(open: boolean);
+    readonly tuiFullscreen: import("@angular/core").ModelSignal<boolean>;
+    readonly options: import("@angular/core").InputSignal<FullscreenOptions>;
+    protected readonly handleState: import("@angular/core").EffectRef;
     protected closedByEscape(event: Event): void;
-    private fullscreenState;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFullscreen, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFullscreen, "[tuiFullscreen]", never, { "options": { "alias": "tuiFullscreenOptions"; "required": false; }; "fullscreen": { "alias": "tuiFullscreen"; "required": false; }; }, { "opened": "tuiFullscreenChange"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFullscreen, "[tuiFullscreen]", never, { "tuiFullscreen": { "alias": "tuiFullscreen"; "required": false; "isSignal": true; }; "options": { "alias": "tuiFullscreenOptions"; "required": false; "isSignal": true; }; }, { "tuiFullscreen": "tuiFullscreenChange"; }, never, ["*"], true, never>;
 }

package/components/index.d.ts

@@ -19,10 +19,8 @@ export * from '@taiga-ui/kit/components/confirm';
 export * from '@taiga-ui/kit/components/copy';
 export * from '@taiga-ui/kit/components/data-list-wrapper';
 export * from '@taiga-ui/kit/components/drawer';
-export * from '@taiga-ui/kit/components/elastic-container';
 export * from '@taiga-ui/kit/components/files';
 export * from '@taiga-ui/kit/components/filter';
-export * from '@taiga-ui/kit/components/floating-container';
 export * from '@taiga-ui/kit/components/fullscreen';
 export * from '@taiga-ui/kit/components/input-chip';
 export * from '@taiga-ui/kit/components/input-color';
@@ -62,7 +60,6 @@ export * from '@taiga-ui/kit/components/routable-dialog';
 export * from '@taiga-ui/kit/components/segmented';
 export * from '@taiga-ui/kit/components/select';
 export * from '@taiga-ui/kit/components/slider';
-export * from '@taiga-ui/kit/components/slides';
 export * from '@taiga-ui/kit/components/status';
 export * from '@taiga-ui/kit/components/stepper';
 export * from '@taiga-ui/kit/components/switch';

package/components/input-color/input-color.component.d.ts

@@ -1,24 +1,20 @@
 import { TuiControl } from '@taiga-ui/cdk/classes';
-import { type TuiHorizontalDirection } from '@taiga-ui/core/types';
-import { type TuiInputColorOptions } from './input-color.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@maskito/angular";
 import * as i2 from "@taiga-ui/core/components/input";
 export declare class TuiInputColorComponent extends TuiControl<string> {
-    protected readonly options: TuiInputColorOptions;
+    protected readonly options: import("./input-color.options").TuiInputColorOptions;
     protected readonly el: HTMLInputElement;
     protected readonly list: string | null;
-    protected readonly format: import("@angular/core").WritableSignal<"hex" | "hexa">;
-    protected readonly align: import("@angular/core").WritableSignal<TuiHorizontalDirection>;
     protected readonly left: string;
     protected readonly icon: import("@angular/core").Signal<string>;
-    protected readonly maskito: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions | null>;
+    protected readonly maskito: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions>;
     protected readonly filled: import("@angular/core").Signal<boolean>;
     protected readonly opacity: import("@angular/core").Signal<number>;
-    set alignSetter(align: TuiInputColorOptions['align']);
-    set formatSetter(mode: TuiInputColorOptions['format']);
+    readonly format: import("@angular/core").InputSignal<"hex" | "hexa">;
+    readonly align: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiHorizontalDirection>;
     protected onInput(value: string): void;
     protected onOpacity(opacity: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputColorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputColorComponent, "input[tuiInputColor]", never, { "alignSetter": { "alias": "align"; "required": false; }; "formatSetter": { "alias": "format"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithInput; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputColorComponent, "input[tuiInputColor]", never, { "format": { "alias": "format"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithInput; inputs: {}; outputs: {}; }]>;
 }

package/components/input-color/input-color.d.ts

@@ -1,5 +1,5 @@
 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 { TuiInputColorComponent } from './input-color.component';
 export declare const TuiInputColor: readonly [typeof TuiInputColorComponent, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];