@taiga-ui/kit 4.52.0-canary.763e67d → 4.52.0-canary.7c53ccc

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

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class TuiAvatarLabeled {
     readonly label: import("@angular/core").InputSignal<string>;
-    protected split(label: string): readonly 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; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

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 {
-    readonly tuiSlot: import("@angular/core").InputSignal<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; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

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

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

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

@@ -7,25 +7,22 @@ export declare class TuiCarouselComponent {
     private readonly isMobile;
     private readonly directive;
     private readonly translate;
-    private readonly transitioned;
-    private readonly index;
+    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 transform: import("@angular/core").Signal<string>;
     protected readonly resetDuration: import("@angular/core").EffectRef;
     readonly draggable: import("@angular/core").InputSignal<boolean>;
     readonly itemsCount: import("@angular/core").InputSignal<number>;
-    readonly indexSetter: import("@angular/core").InputSignal<number>;
-    readonly indexChange: import("@angular/core").OutputEmitterRef<number>;
+    readonly index: import("@angular/core").ModelSignal<number>;
     readonly shift: import("@angular/core").OutputEmitterRef<number>;
     next(): void;
     prev(): void;
-    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;
@@ -33,5 +30,5 @@ export declare class TuiCarouselComponent {
     protected onShift(): void;
     private updateIndex;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCarouselComponent, "tui-carousel", never, { "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "itemsCount": { "alias": "itemsCount"; "required": false; "isSignal": true; }; "indexSetter": { "alias": "index"; "required": false; "isSignal": true; }; }, { "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"], never, 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 trigger$;
     private readonly running$;
     readonly duration: import("@angular/core").InputSignal<number>;
-    protected readonly duration$: Observable<number>;
     protected readonly output$: Observable<number>;
     constructor();
+    restart(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselDirective, never, never, { "duration": { "alias": "duration"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

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

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

@@ -1,17 +1,13 @@
-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 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 win;
-    private readonly removeObserved;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     protected readonly fileTexts: import("@angular/core").Signal<{
         loadingError: string;
@@ -20,6 +16,10 @@ export declare class TuiFile {
     }>;
     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>;
@@ -27,20 +27,8 @@ export declare class TuiFile {
     readonly showSize: import("@angular/core").InputSignal<boolean>;
     readonly leftContent: import("@angular/core").InputSignal<PolymorpheusContent>;
     readonly remove: import("@angular/core").OutputEmitterRef<void>;
-    constructor();
-    protected get preview(): SafeValue;
-    protected get isBig(): boolean;
-    protected get isLoading(): boolean;
-    protected get isError(): boolean;
-    protected get isDeleted(): boolean;
     protected get allowDelete(): boolean;
-    protected get icon(): PolymorpheusContent<TuiContext<TuiSizeL>>;
-    protected get name(): string;
-    protected get type(): string;
-    private calculateContent;
     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; "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

@@ -2,13 +2,11 @@ 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: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
     protected readonly hideText: import("@angular/core").Signal<string>;
     protected readonly showAllText: import("@angular/core").Signal<string>;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
     readonly max: import("@angular/core").InputSignal<number>;
     readonly expanded: import("@angular/core").ModelSignal<boolean>;
-    protected readonly hasExtraItems: import("@angular/core").Signal<boolean>;
-    protected toggle(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFilesComponent, never>;
     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,9 +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>;
-    protected readonly reject$: import("rxjs").Observable<File[]>;
+    readonly el: HTMLInputElement;
     readonly reject: import("@angular/core").OutputRef<File[]>;
-    readonly input: HTMLInputElement;
     process(files: FileList): void;
     protected onClick(event: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputFilesDirective, never>;

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

@@ -1,17 +1,16 @@
 import { TuiControl } from '@taiga-ui/cdk/classes';
-import { type TuiBooleanHandler, type TuiHandler, type TuiIdentityMatcher } from '@taiga-ui/cdk/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[]> {
-    readonly identityMatcher: import("@angular/core").InputSignal<TuiIdentityMatcher<T>>;
+    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 disabledItemHandler: import("@angular/core").InputSignal<TuiBooleanHandler<T>>;
-    readonly toggledItem: import("@angular/core").OutputEmitterRef<T>;
-    readonly content: import("@angular/core").InputSignal<PolymorpheusContent>;
     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; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "badgeHandler": { "alias": "badgeHandler"; "required": false; "isSignal": true; }; }, { "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

@@ -2,10 +2,10 @@ import * as i0 from "@angular/core";
 export declare class TuiFullscreen {
     private readonly root;
     private readonly doc;
-    readonly options: import("@angular/core").InputSignal<FullscreenOptions>;
     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;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiFullscreen, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiFullscreen, "[tuiFullscreen]", never, { "options": { "alias": "tuiFullscreenOptions"; "required": false; "isSignal": true; }; "tuiFullscreen": { "alias": "tuiFullscreen"; "required": false; "isSignal": true; }; }, { "tuiFullscreen": "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/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-date/input-date.component.d.ts

@@ -3,8 +3,8 @@ import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/components/textfield";
 export declare class TuiInputDateComponent {
     protected readonly host: TuiInputDateDirective;
-    list: string | null;
+    readonly list: import("@angular/core").InputSignal<string | undefined>;
     protected onInput(value: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputDateComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputDateComponent, "input[tuiInputDate][type=\"date\"]", never, { "list": { "alias": "list"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithNativePicker; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputDateComponent, "input[tuiInputDate][type=\"date\"]", never, { "list": { "alias": "list"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithNativePicker; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,3 +1,4 @@
+import { type Signal } from '@angular/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { TuiDay, type TuiDayRange, type TuiTime } from '@taiga-ui/cdk/date-time';
 import { TuiCalendar } from '@taiga-ui/core/components/calendar';
@@ -11,38 +12,38 @@ import * as i2 from "@taiga-ui/core/portals/dropdown";
 import * as i3 from "@taiga-ui/core/directives/items-handlers";
 import * as i4 from "@maskito/angular";
 export declare abstract class TuiInputDateBase<T extends TuiDay | TuiDayRange | readonly [TuiDay, TuiTime | null]> extends TuiControl<T | null> {
+    abstract readonly max: Signal<TuiDay>;
+    abstract readonly min: Signal<TuiDay>;
     private readonly calendar;
     protected readonly el: HTMLInputElement;
     protected readonly input: TuiInputDirective<any>;
-    protected readonly filler: import("@angular/core").Signal<string>;
+    protected readonly filler: Signal<string>;
     protected readonly mobile: boolean;
     protected readonly open: import("@angular/core").ModelSignal<boolean>;
-    protected readonly icon: import("@angular/core").Signal<string>;
+    protected readonly icon: Signal<string>;
     protected readonly handlers: TuiItemsHandlers<T>;
-    protected readonly format: import("@angular/core").Signal<import("@taiga-ui/core/tokens").TuiDateFormatSettings>;
-    protected readonly dropdownEnabled: import("@angular/core").Signal<boolean>;
+    protected readonly format: Signal<import("@taiga-ui/core/tokens").TuiDateFormatSettings>;
+    protected readonly dropdownEnabled: Signal<boolean>;
     protected readonly identity: import("@angular/core").WritableSignal<(a: TuiDay, b: TuiDay) => boolean>;
     protected readonly options: Omit<TuiInputDateOptions, 'valueTransformer'>;
     protected readonly valueEffect: import("@angular/core").EffectRef;
     protected readonly calendarIn: import("@angular/core").EffectRef;
     protected readonly calendarOut: import("@angular/core").EffectRef;
-    readonly min: import("@angular/core").WritableSignal<TuiDay>;
-    readonly max: import("@angular/core").WritableSignal<TuiDay>;
     readonly native: boolean;
     protected abstract onValueChange(value: string): void;
-    set minSetter(min: Exclude<T, TuiDayRange> | TuiDay | null);
-    set maxSetter(max: Exclude<T, TuiDayRange> | TuiDay | null);
     writeValue(value: T | null): void;
     setDate(value: TuiDay | TuiDayRange | readonly TuiDay[]): void;
     protected processCalendar(calendar: TuiCalendar | TuiCalendarRange): void;
     protected onClick(): void;
     protected stringify(value: T | null): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputDateBase<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateBase<any>, never, never, { "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateBase<any>, never, never, {}, {}, never, never, true, never>;
 }
 export declare class TuiInputDateDirective extends TuiInputDateBase<TuiDay> {
-    protected readonly mask: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions | null>;
+    readonly max: import("@angular/core").InputSignalWithTransform<TuiDay, TuiDay | null>;
+    readonly min: import("@angular/core").InputSignalWithTransform<TuiDay, TuiDay | null>;
+    protected readonly mask: Signal<import("@maskito/core").MaskitoOptions>;
     protected onValueChange(value: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputDateDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateDirective, "input[tuiInputDate]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownAuto; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiItemsHandlersValidator; inputs: {}; outputs: {}; }, { directive: typeof i4.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateDirective, "input[tuiInputDate]", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownAuto; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiItemsHandlersValidator; inputs: {}; outputs: {}; }, { directive: typeof i4.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }

package/components/input-date-multi/input-date-multi.directive.d.ts

@@ -10,7 +10,7 @@ export declare class TuiInputDateMultiDirective extends TuiInputChipDirective<Tu
     protected readonly filler: import("@angular/core").Signal<string>;
     protected readonly format: import("@angular/core").Signal<import("@taiga-ui/core/tokens").TuiDateFormatSettings>;
     protected readonly stringify: import("@angular/core").WritableSignal<(item: any) => any>;
-    protected readonly mask: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions | null>;
+    protected readonly mask: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions>;
     protected readonly calendar: import("@angular/core").Signal<TuiCalendar | null>;
     protected readonly calendarIn: import("@angular/core").EffectRef;
     protected readonly calendarOut: import("@angular/core").EffectRef;

package/components/input-date-range/input-date-range.directive.d.ts

@@ -1,4 +1,4 @@
-import { type TuiDayLike, TuiDayRange } from '@taiga-ui/cdk/date-time';
+import { TuiDay, type TuiDayLike, TuiDayRange } from '@taiga-ui/cdk/date-time';
 import { type TuiCalendarRange } from '@taiga-ui/kit/components/calendar-range';
 import { TuiInputDateBase } from '@taiga-ui/kit/components/input-date';
 import * as i0 from "@angular/core";
@@ -6,12 +6,14 @@ import * as i1 from "@taiga-ui/core/components/input";
 import * as i2 from "@taiga-ui/core/portals/dropdown";
 import * as i3 from "@maskito/angular";
 export declare class TuiInputDateRangeDirective extends TuiInputDateBase<TuiDayRange> {
+    readonly max: import("@angular/core").InputSignalWithTransform<TuiDay, TuiDay | null>;
+    readonly min: import("@angular/core").InputSignalWithTransform<TuiDay, TuiDay | null>;
     protected readonly filler: import("@angular/core").Signal<string>;
-    protected readonly mask: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions | null>;
+    protected readonly mask: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions>;
     readonly minLength: import("@angular/core").InputSignal<TuiDayLike | null>;
     readonly maxLength: import("@angular/core").InputSignal<TuiDayLike | null>;
     protected processCalendar(calendar: TuiCalendarRange): void;
     protected onValueChange(value: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputDateRangeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateRangeDirective, "input[tuiInputDateRange]", never, { "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownAuto; inputs: {}; outputs: {}; }, { directive: typeof i3.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateRangeDirective, "input[tuiInputDateRange]", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownAuto; inputs: {}; outputs: {}; }, { directive: typeof i3.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }

package/components/input-date-time/input-date-time.directive.d.ts

@@ -1,5 +1,4 @@
 import { type MaskitoOptions } from '@maskito/core';
-import { type MaskitoTimeMode } from '@maskito/kit';
 import { TuiDay, TuiTime } from '@taiga-ui/cdk/date-time';
 import { type TuiCalendar } from '@taiga-ui/core/components/calendar';
 import { type TuiTextfieldAccessor } from '@taiga-ui/core/components/textfield';
@@ -16,13 +15,14 @@ export declare class TuiInputDateTimeDirective extends TuiInputDateBase<readonly
     protected readonly valueEffect: import("@angular/core").EffectRef;
     protected readonly identity: import("@angular/core").WritableSignal<(a: any, b: any) => boolean>;
     protected readonly disabledItemHandler: import("@angular/core").Signal<(value: readonly [TuiDay, TuiTime | null] | null) => boolean>;
-    protected readonly mask: import("@angular/core").Signal<MaskitoOptions | null>;
-    readonly timeMode: import("@angular/core").WritableSignal<MaskitoTimeMode>;
-    readonly minTime: import("@angular/core").WritableSignal<TuiTime>;
-    readonly maxTime: import("@angular/core").WritableSignal<TuiTime>;
-    set timeModeSetter(x: MaskitoTimeMode);
-    set minSetter(min: TuiDay | readonly [TuiDay, TuiTime | null] | null);
-    set maxSetter(max: TuiDay | readonly [TuiDay, TuiTime | null] | null);
+    protected readonly mask: import("@angular/core").Signal<MaskitoOptions>;
+    readonly min: import("@angular/core").Signal<TuiDay>;
+    readonly max: import("@angular/core").Signal<TuiDay>;
+    readonly minTime: import("@angular/core").Signal<any>;
+    readonly maxTime: import("@angular/core").Signal<any>;
+    readonly timeMode: import("@angular/core").InputSignal<import("@maskito/kit").MaskitoTimeMode>;
+    readonly minInput: import("@angular/core").InputSignal<TuiDay | readonly [TuiDay, TuiTime | null] | null>;
+    readonly maxInput: import("@angular/core").InputSignal<TuiDay | readonly [TuiDay, TuiTime | null] | null>;
     setValue(value: readonly [TuiDay, TuiTime | null] | null): void;
     setDate(newDate: TuiDay): void;
     writeValue(value: [TuiDay, TuiTime | null] | null): void;
@@ -33,5 +33,5 @@ export declare class TuiInputDateTimeDirective extends TuiInputDateBase<readonly
     private computeMask;
     private toNativeDate;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputDateTimeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateTimeDirective, "input[tuiInputDateTime]", never, { "timeModeSetter": { "alias": "timeMode"; "required": false; }; "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownAuto; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiItemsHandlersValidator; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithInput; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputDateTimeDirective, "input[tuiInputDateTime]", never, { "timeMode": { "alias": "timeMode"; "required": false; "isSignal": true; }; "minInput": { "alias": "min"; "required": false; "isSignal": true; }; "maxInput": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownAuto; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiItemsHandlersValidator; inputs: {}; outputs: {}; }, { directive: typeof i4.TuiWithInput; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,7 +1,8 @@
+import { NgControl } from '@angular/forms';
 import * as i0 from "@angular/core";
 export declare class TuiInputInline {
-    private readonly control?;
-    protected readonly value$: import("rxjs").Observable<unknown>;
+    protected readonly control: import("@angular/core").Signal<NgControl | undefined>;
+    protected readonly value: import("@angular/core").Signal<unknown>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputInline, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputInline, "tui-input-inline", never, {}, {}, ["control"], ["*", "input"], true, never>;
 }

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

@@ -4,12 +4,10 @@ import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/components/textfield";
 export declare class TuiInputMonthComponent {
     protected readonly host: TuiInputMonthDirective;
-    protected readonly min: import("@angular/core").WritableSignal<TuiMonth | null>;
-    protected readonly max: import("@angular/core").WritableSignal<TuiMonth | null>;
     protected readonly calendarSync: import("@angular/core").EffectRef;
-    set minSetter(x: TuiMonth | null);
-    set maxSetter(x: TuiMonth | null);
+    protected readonly min: import("@angular/core").InputSignal<TuiMonth | null>;
+    protected readonly max: import("@angular/core").InputSignal<TuiMonth | null>;
     protected onInput(value: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputMonthComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputMonthComponent, "input[tuiInputMonth][type=\"month\"]", never, { "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithNativePicker; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputMonthComponent, "input[tuiInputMonth][type=\"month\"]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithNativePicker; inputs: {}; outputs: {}; }]>;
 }

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

@@ -12,17 +12,15 @@ export declare class TuiInputNumberDirective extends TuiControl<number | null> {
     private readonly precision;
     private readonly unfinished;
     protected readonly element: HTMLInputElement;
-    protected readonly mask: import("@angular/core").Signal<MaskitoOptions | null>;
+    protected readonly mask: import("@angular/core").Signal<MaskitoOptions>;
     protected readonly inputMode: import("@angular/core").Signal<"text" | "decimal" | "numeric">;
     protected readonly defaultMaxLength: import("@angular/core").Signal<number>;
     protected readonly onChangeEffect: import("@angular/core").EffectRef;
     protected maskInitialCalibrationEffect: import("@angular/core").EffectRef;
-    readonly min: import("@angular/core").Signal<number>;
-    readonly max: import("@angular/core").Signal<number>;
+    readonly min: import("@angular/core").InputSignalWithTransform<number, number | null>;
+    readonly max: import("@angular/core").InputSignalWithTransform<number, number | null>;
     readonly prefix: import("@angular/core").InputSignal<string>;
     readonly postfix: import("@angular/core").InputSignal<string>;
-    readonly minRaw: import("@angular/core").InputSignalWithTransform<number, number | null>;
-    readonly maxRaw: import("@angular/core").InputSignalWithTransform<number, number | null>;
     writeValue(value: number | null): void;
     setValue(value: number | null): void;
     protected onFocus(): void;
@@ -30,5 +28,5 @@ export declare class TuiInputNumberDirective extends TuiControl<number | null> {
     private formatNumber;
     private computeMask;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputNumberDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputNumberDirective, "input[tuiInputNumber]", never, { "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "postfix": { "alias": "postfix"; "required": false; "isSignal": true; }; "minRaw": { "alias": "min"; "required": false; "isSignal": true; }; "maxRaw": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputNumberDirective, "input[tuiInputNumber]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "postfix": { "alias": "postfix"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }

package/components/input-number/input-number.options.d.ts

@@ -1,9 +1,8 @@
+import { type MaskitoNumberParams } from '@maskito/kit';
 import { type TuiValueTransformer } from '@taiga-ui/cdk/classes';
-export interface TuiInputNumberOptions {
+export interface TuiInputNumberOptions extends Pick<Required<MaskitoNumberParams>, 'minusSign' | 'postfix' | 'prefix'> {
     readonly max: number;
     readonly min: number;
-    readonly prefix: string;
-    readonly postfix: string;
     readonly step: number;
     readonly icons: Readonly<{
         decrease: string;

package/components/input-number/step/input-number-step.component.d.ts

@@ -2,19 +2,19 @@ import { Subject } from 'rxjs';
 import { TuiInputNumberDirective } from '../input-number.directive';
 import { type TuiInputNumberOptions } from '../input-number.options';
 import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/kit/directives/appearance-proxy";
 export declare class TuiInputNumberStep {
     protected readonly el: HTMLInputElement;
     protected readonly appearance: import("@angular/core").Signal<string>;
     protected readonly options: TuiInputNumberOptions;
     protected readonly input: TuiInputNumberDirective;
-    protected readonly step: import("@angular/core").WritableSignal<number>;
     protected readonly value: import("@angular/core").Signal<number>;
     protected readonly step$: Subject<number>;
     protected readonly doc: Document;
     protected readonly stop$: import("rxjs").Observable<Event>;
     protected readonly stepping: import("rxjs").Subscription;
-    set stepSetter(x: number);
+    readonly step: import("@angular/core").InputSignal<number>;
     protected onStep(step: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputNumberStep, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputNumberStep, "input[tuiInputNumber][step]", never, { "stepSetter": { "alias": "step"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputNumberStep, "input[tuiInputNumber][step]", never, { "step": { "alias": "step"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiAppearanceProxy; inputs: {}; outputs: {}; }]>;
 }

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

@@ -12,16 +12,14 @@ export declare class TuiInputPhoneDirective extends TuiControl<string | null> {
     protected inputMode: import("@angular/core").Signal<"text" | "numeric">;
     protected readonly valueEffect: import("@angular/core").EffectRef;
     protected readonly blurEffect: import("@angular/core").EffectRef;
-    protected readonly mask: import("@angular/core").Signal<MaskitoOptions>;
-    protected readonly maskito: import("@angular/core").Signal<MaskitoOptions | null>;
-    readonly countryCode: import("@angular/core").WritableSignal<string>;
-    readonly allowText: import("@angular/core").WritableSignal<boolean>;
-    readonly phoneMask: import("@angular/core").WritableSignal<string>;
-    set allowTextSetter(allow: boolean);
-    set maskSetter(mask: string);
+    protected readonly countryCode: import("@angular/core").Signal<string>;
+    protected readonly phoneMask: import("@angular/core").Signal<string>;
+    protected readonly maskito: import("@angular/core").Signal<MaskitoOptions>;
+    readonly allowText: import("@angular/core").InputSignal<boolean>;
+    readonly mask: import("@angular/core").InputSignal<string>;
     protected onInput(value: string): void;
     private get maxPhoneLength();
     private calculateMask;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputPhoneDirective, "input[tuiInputPhone]", never, { "allowTextSetter": { "alias": "allowText"; "required": false; }; "maskSetter": { "alias": "mask"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputPhoneDirective, "input[tuiInputPhone]", never, { "allowText": { "alias": "allowText"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }