@taiga-ui/kit 4.52.0-canary.6c67ccf → 4.52.0-canary.91aeb4a

package/components/input-phone-international/input-phone-international.component.d.ts

@@ -1,51 +1,45 @@
-import { TemplateRef } from '@angular/core';
+import { ElementRef, type QueryList } from '@angular/core';
 import { type MaskitoOptions } from '@maskito/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { type TuiCountryIsoCode } from '@taiga-ui/i18n/types';
-import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import { type MetadataJson } from 'libphonenumber-js/core';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/directives/group";
-import * as i2 from "@taiga-ui/core/directives/dropdown";
-/** @deprecated use version from experimental package instead */
+import * as i1 from "@maskito/angular";
+import * as i2 from "@taiga-ui/core/components/textfield";
 export declare class TuiInputPhoneInternational extends TuiControl<string> {
-    private readonly input?;
-    private readonly filter?;
-    private readonly listOptions?;
-    protected readonly isIos: boolean;
-    protected readonly dropdown: import("@angular/core").WritableSignal<import("@taiga-ui/polymorpheus").PolymorpheusComponent<unknown> | import("@taiga-ui/polymorpheus").PolymorpheusPrimitive | import("@taiga-ui/polymorpheus").PolymorpheusHandler<any> | import("@taiga-ui/polymorpheus").PolymorpheusTemplate<"" | Partial<any>> | TemplateRef<Partial<any>>>;
+    protected readonly list: QueryList<ElementRef<HTMLButtonElement>>;
+    protected readonly el: HTMLInputElement;
+    protected readonly ios: boolean;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     protected readonly options: import("./input-phone-international.options").TuiInputPhoneInternationalOptions;
-    protected readonly size: import("@angular/core").WritableSignal<"m" | "l" | "s">;
-    protected readonly open: import("@angular/core").WritableSignal<boolean>;
-    protected readonly names: import("@angular/core").Signal<Record<TuiCountryIsoCode, string> | undefined>;
-    protected readonly metadata: import("@angular/core").Signal<MetadataJson | undefined>;
     protected readonly countries: import("@angular/core").WritableSignal<readonly TuiCountryIsoCode[]>;
-    protected readonly countryIsoCode: import("@angular/core").WritableSignal<TuiCountryIsoCode>;
-    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    protected readonly label: import("@angular/core").Signal<string | undefined>;
+    protected readonly code: import("@angular/core").WritableSignal<TuiCountryIsoCode>;
+    protected readonly label: import("@angular/core").Signal<string>;
+    protected readonly metadata: import("@angular/core").Signal<MetadataJson | undefined>;
+    protected readonly names: import("@angular/core").Signal<Record<TuiCountryIsoCode, string>>;
+    protected readonly open: import("@angular/core").WritableSignal<boolean>;
     protected readonly search: import("@angular/core").WritableSignal<string>;
-    protected readonly separator: import("@angular/core").WritableSignal<string>;
+    protected readonly size: import("@angular/core").Signal<"m" | "l" | "s">;
+    protected readonly mask: import("@angular/core").Signal<MaskitoOptions | null>;
+    protected readonly masked: import("@angular/core").WritableSignal<string>;
+    protected valueChangeEffect: import("@angular/core").EffectRef;
     protected readonly filtered: import("@angular/core").Signal<{
         iso: TuiCountryIsoCode;
         name: string;
         code: string;
     }[]>;
-    protected readonly mask: import("@angular/core").Signal<MaskitoOptions | null>;
-    protected readonly $: import("@angular/core").Signal<boolean>;
-    protected textfieldValue: string;
+    protected readonly enabled: import("@angular/core").Signal<boolean>;
+    protected readonly $: import("rxjs").Subscription;
     countrySearch: boolean;
     readonly countryIsoCodeChange: import("rxjs").Observable<TuiCountryIsoCode>;
     set countriesValue(value: readonly TuiCountryIsoCode[]);
     set isoCode(code: TuiCountryIsoCode);
-    focusFirstItem(): void;
-    onPaste(event: Event): void;
-    onItemClick(isoCode: TuiCountryIsoCode): void;
-    writeValue(unmaskedValue: string): void;
-    protected set template(template: PolymorpheusContent);
-    protected onFocus(): void;
-    protected onValueChange(maskedValue: string): void;
-    protected onKeyDown({ key }: KeyboardEvent): void;
+    writeValue(unmasked: string | null): void;
+    protected onPaste(event: Event): void;
+    protected onItemClick(code: TuiCountryIsoCode): void;
     private computeMask;
+    private unmask;
+    private getCountryCode;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneInternational, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPhoneInternational, "tui-input-phone-international", never, { "countrySearch": { "alias": "countrySearch"; "required": false; }; "countriesValue": { "alias": "countries"; "required": false; }; "isoCode": { "alias": "countryIsoCode"; "required": false; }; }, { "countryIsoCodeChange": "countryIsoCodeChange"; }, never, ["tui-icon, img", "*"], true, [{ directive: typeof i1.TuiGroup; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiDropdownDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithDropdownOpen; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPhoneInternational, "input[tuiInputPhoneInternational]", never, { "countrySearch": { "alias": "countrySearch"; "required": false; }; "countriesValue": { "alias": "countries"; "required": false; }; "isoCode": { "alias": "countryIsoCode"; "required": false; }; }, { "countryIsoCodeChange": "countryIsoCodeChange"; }, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithTextfield; inputs: {}; outputs: {}; }]>;
 }

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

@@ -5,7 +5,7 @@ import * as i1 from "@maskito/angular";
 export declare class TuiInputPin {
     protected readonly el: HTMLInputElement;
     protected readonly mask: import("@angular/core").WritableSignal<MaskitoMask>;
-    protected readonly appearance: import("@angular/core").WritableSignal<string>;
+    protected readonly appearance: import("@angular/core").Signal<string>;
     protected readonly control: NgControl;
     protected readonly maskito: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions | null>;
     set maskSetter(mask: MaskitoMask | string);

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

@@ -1,4 +1,3 @@
-import { type AfterViewInit } from '@angular/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type TuiKeySteps } from '@taiga-ui/kit/components/slider';
@@ -7,25 +6,23 @@ import * as i0 from "@angular/core";
 export declare class TuiInputRangeComponent extends TuiControl<readonly [
     number,
     number
-]> implements AfterViewInit {
+]> {
     private readonly inputNumberRefs;
     private readonly range?;
     private readonly isMobile;
     private readonly quantum;
     private readonly quantumTransformer;
-    protected readonly size: import("@angular/core").WritableSignal<"m" | "l" | "s">;
+    protected readonly size: import("@angular/core").Signal<"m" | "l" | "s">;
     protected textfieldValueStart: number;
     protected textfieldValueEnd: number;
     protected lastActiveSide: 'end' | 'start';
+    protected readonly contentStart: import("@angular/core").Signal<PolymorpheusContent<TuiContext<number>>>;
+    protected readonly contentEnd: import("@angular/core").Signal<PolymorpheusContent<TuiContext<number>>>;
     min: number;
     max: number;
     step: number;
     segments: number;
     keySteps: TuiKeySteps | null;
-    content: readonly [
-        PolymorpheusContent<TuiContext<number>>,
-        PolymorpheusContent<TuiContext<number>>
-    ];
     prefix: readonly [
         string,
         string
@@ -34,14 +31,14 @@ export declare class TuiInputRangeComponent extends TuiControl<readonly [
         string,
         string
     ];
+    content: import("@angular/core").InputSignal<readonly [PolymorpheusContent<TuiContext<number>>, PolymorpheusContent<TuiContext<number>>]>;
     set quantumSetter(x: number);
     writeValue(value: [
         number,
         number
     ]): void;
-    ngAfterViewInit(): void;
-    protected get hideStartContent(): boolean;
-    protected get hideEndContent(): boolean;
+    protected get contentStartHidden(): boolean;
+    protected get contentEndHidden(): boolean;
     protected takeStep(event: Event | KeyboardEvent, coefficients: readonly [
         number,
         number
@@ -55,7 +52,6 @@ export declare class TuiInputRangeComponent extends TuiControl<readonly [
         number
     ]): void;
     protected focusToTextfield(): void;
-    protected onActiveThumbChange(activeThumb: 'left' | 'right'): void;
     protected setTextfieldValues([start, end]: readonly [
         number,
         number
@@ -65,8 +61,9 @@ export declare class TuiInputRangeComponent extends TuiControl<readonly [
     private get activeTextfield();
     private setValue;
     private valueGuard;
+    private isPrimitive;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputRangeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputRangeComponent, "tui-input-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "keySteps": { "alias": "keySteps"; "required": false; }; "content": { "alias": "content"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "postfix": { "alias": "postfix"; "required": false; }; "quantumSetter": { "alias": "quantum"; "required": false; }; }, {}, never, ["label"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputRangeComponent, "tui-input-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "keySteps": { "alias": "keySteps"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "postfix": { "alias": "postfix"; "required": false; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "quantumSetter": { "alias": "quantum"; "required": false; }; }, {}, never, ["label"], true, never>;
     static ngAcceptInputType_prefix: readonly [
         string,
         string

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

@@ -3,17 +3,15 @@ import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/kit/components/input-number";
 export declare class TuiInputSliderDirective {
     private readonly isMobile;
-    private readonly element;
+    private readonly el;
     private readonly slider;
     private readonly controlTransformer;
-    private readonly keyStepsTransformer;
+    protected readonly nothing: undefined;
     protected readonly inputNumber: TuiInputNumberDirective;
     protected readonly value: import("@angular/core").Signal<number>;
-    protected readonly nothing: undefined;
     protected readonly textfieldToSliderSync: import("@angular/core").EffectRef;
     protected readonly sliderInitEffect: import("@angular/core").EffectRef;
     protected onStep(coefficient: number): void;
-    private onSliderInput;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputSliderDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputSliderDirective, "input[tuiInputSlider]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiInputNumberDirective; inputs: { "min": "min"; "max": "max"; "prefix": "prefix"; "postfix": "postfix"; "invalid": "invalid"; "readOnly": "readOnly"; }; outputs: {}; }, { directive: typeof i1.TuiWithQuantumValueTransformer; inputs: {}; outputs: {}; }]>;
 }

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

@@ -12,25 +12,23 @@ export declare class TuiInputTimeDirective extends TuiControl<TuiTime | null> im
     private readonly open;
     private readonly options;
     private readonly fillers;
-    private readonly prefix;
-    private readonly postfix;
     protected readonly icon: import("@angular/core").Signal<string>;
     protected readonly dropdownEnabled: import("@angular/core").Signal<boolean>;
     protected readonly filler: import("@angular/core").Signal<string>;
     protected readonly mask: import("@angular/core").Signal<MaskitoOptions | null>;
-    accept: readonly TuiTime[];
+    readonly accept: import("@angular/core").InputSignal<readonly TuiTime[]>;
     readonly native: boolean;
-    readonly timeMode: import("@angular/core").WritableSignal<MaskitoTimeMode>;
-    set modeSetter(x: MaskitoTimeMode);
-    set prefixSetter(x: string);
-    set postfixSetter(x: string);
+    readonly timeMode: import("@angular/core").InputSignal<MaskitoTimeMode>;
+    readonly prefix: import("@angular/core").InputSignal<string>;
+    readonly postfix: import("@angular/core").InputSignal<string>;
     setValue(value: TuiTime | null): void;
     writeValue(value: TuiTime | null): void;
     protected onInput(valueWithAffixes: string): void;
     protected toggle(): void;
+    protected onBlur(valueWithAffixes: string): void;
     private computeMask;
     private findNearestTime;
     private stringify;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputTimeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputTimeDirective, "input[tuiInputTime]", never, { "accept": { "alias": "accept"; "required": false; }; "modeSetter": { "alias": "mode"; "required": false; }; "prefixSetter": { "alias": "prefix"; "required": false; }; "postfixSetter": { "alias": "postfix"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputTimeDirective, "input[tuiInputTime]", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "timeMode": { "alias": "mode"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "postfix": { "alias": "postfix"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -8,4 +8,4 @@ export interface TuiInputTimeOptions extends Required<Pick<MaskitoTimeParams, 'm
     readonly valueTransformer: TuiValueTransformer<TuiTime | null, any> | null;
 }
 export declare const TUI_INPUT_TIME_DEFAULT_OPTIONS: TuiInputTimeOptions;
-export declare const TUI_INPUT_TIME_OPTIONS: import("@angular/core").InjectionToken<TuiInputTimeOptions>, tuiInputTimeOptionsProvider: (item: Partial<TuiInputTimeOptions> | import("@angular/core").ProviderToken<Partial<TuiInputTimeOptions>> | (() => Partial<TuiInputTimeOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_INPUT_TIME_OPTIONS: import("@angular/core").InjectionToken<TuiInputTimeOptions>, tuiInputTimeOptionsProvider: (item: Partial<TuiInputTimeOptions> | (() => Partial<TuiInputTimeOptions>)) => import("@angular/core").FactoryProvider;

package/components/like/like.component.d.ts

@@ -1,16 +1,9 @@
-import { type TuiStringHandler } from '@taiga-ui/cdk/types';
-import { type TuiSizeS } from '@taiga-ui/core/types';
-import { type TuiLikeOptions } from './like.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/appearance";
+import * as i2 from "@taiga-ui/core/directives/icons";
 export declare class TuiLike {
-    private readonly options;
-    private readonly resolver;
-    color: string;
-    uncheckedIcon: TuiStringHandler<TuiSizeS> | string;
-    checkedIcon: TuiStringHandler<TuiSizeS> | string;
-    size: TuiSizeS;
-    protected getIcon(state: keyof TuiLikeOptions['icons']): string;
+    readonly color: import("@angular/core").InputSignal<string>;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeS>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiLike, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLike, "input[tuiLike][type=checkbox]", never, { "color": { "alias": "tuiLike"; "required": false; }; "uncheckedIcon": { "alias": "uncheckedIcon"; "required": false; }; "checkedIcon": { "alias": "checkedIcon"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLike, "input[tuiLike][type=checkbox]", never, { "color": { "alias": "tuiLike"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiIcons; inputs: { "iconStart": "uncheckedIcon"; "iconEnd": "checkedIcon"; }; outputs: {}; }]>;
 }

package/components/like/like.options.d.ts

@@ -1,11 +1,10 @@
-import { type TuiStringHandler } from '@taiga-ui/cdk/types';
 import { type TuiAppearanceOptions } from '@taiga-ui/core/directives';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 export interface TuiLikeOptions extends TuiAppearanceOptions {
     readonly size: TuiSizeS;
     readonly icons: Readonly<{
-        checked: TuiStringHandler<TuiSizeS> | string;
-        unchecked: TuiStringHandler<TuiSizeS> | string;
+        checked: string;
+        unchecked: string;
     }>;
 }
-export declare const TUI_LIKE_OPTIONS: import("@angular/core").InjectionToken<TuiLikeOptions>, tuiLikeOptionsProvider: (item: Partial<TuiLikeOptions> | import("@angular/core").ProviderToken<Partial<TuiLikeOptions>> | (() => Partial<TuiLikeOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_LIKE_OPTIONS: import("@angular/core").InjectionToken<TuiLikeOptions>, tuiLikeOptionsProvider: (item: Partial<TuiLikeOptions> | (() => Partial<TuiLikeOptions>)) => import("@angular/core").FactoryProvider;

package/components/line-clamp/line-clamp-box.component.d.ts

@@ -1,8 +1,7 @@
-import { TuiHintBaseComponent } from '@taiga-ui/core/directives/hint';
+import { TuiHintComponent } from '@taiga-ui/core/directives/hint';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/cdk/directives/animated";
-export declare class TuiLineClampBox extends TuiHintBaseComponent {
+export declare class TuiLineClampBox extends TuiHintComponent {
     protected get width(): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiLineClampBox, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLineClampBox, "tui-line-clamp-box", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLineClampBox, "tui-line-clamp-box", never, {}, {}, never, never, true, never>;
 }

package/components/line-clamp/line-clamp.component.d.ts

@@ -1,24 +1,22 @@
 import { type DoCheck } from '@angular/core';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
-import { type Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/transitioned";
 export declare class TuiLineClamp implements DoCheck {
-    private readonly outlet?;
+    private readonly outlet;
     private readonly options;
     private readonly el;
-    private readonly linesLimit$;
     private readonly isOverflown$;
-    protected lineClamp: import("@angular/core").Signal<number>;
-    lineHeight: number;
-    content: PolymorpheusContent;
-    readonly overflownChange: Observable<boolean>;
-    set linesLimit(linesLimit: number);
+    private readonly maxHeight;
+    readonly lineHeight: import("@angular/core").InputSignal<number>;
+    readonly linesLimit: import("@angular/core").InputSignal<number>;
+    readonly content: import("@angular/core").InputSignal<PolymorpheusContent>;
+    readonly overflownChange: import("@angular/core").OutputRef<boolean>;
+    protected readonly lineClamp: import("@angular/core").Signal<number>;
     ngDoCheck(): void;
     protected get overflown(): boolean;
     protected get computedContent(): PolymorpheusContent;
     protected update(): void;
-    private get maxHeight();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiLineClamp, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLineClamp, "tui-line-clamp", never, { "lineHeight": { "alias": "lineHeight"; "required": false; }; "content": { "alias": "content"; "required": false; }; "linesLimit": { "alias": "linesLimit"; "required": false; }; }, { "overflownChange": "overflownChange"; }, never, never, true, [{ directive: typeof i1.TuiTransitioned; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiLineClamp, "tui-line-clamp", never, { "lineHeight": { "alias": "lineHeight"; "required": false; "isSignal": true; }; "linesLimit": { "alias": "linesLimit"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, { "overflownChange": "overflownChange"; }, never, never, true, [{ directive: typeof i1.TuiTransitioned; inputs: {}; outputs: {}; }]>;
 }

package/components/multi-select/multi-select-group/multi-select-group.component.d.ts

@@ -2,14 +2,14 @@ import { type QueryList } from '@angular/core';
 import { TuiOptionWithValue } from '@taiga-ui/core/components/data-list';
 import * as i0 from "@angular/core";
 export declare class TuiMultiSelectGroupComponent<T> {
-    private readonly values;
     private readonly handlers;
     private readonly control;
+    protected readonly values: import("@angular/core").WritableSignal<readonly T[]>;
     protected readonly texts: import("@angular/core").Signal<{
         all: string;
         none: string;
-    } | undefined>;
-    protected readonly value: import("@angular/core").Signal<readonly T[]>;
+    }>;
+    protected readonly value: import("@angular/core").Signal<readonly T[] | null>;
     protected readonly checked: import("@angular/core").Signal<boolean>;
     label: string;
     protected set options(options: QueryList<TuiOptionWithValue<T>>);

package/components/multi-select/multi-select-option/multi-select-option.component.d.ts

@@ -5,7 +5,7 @@ export declare class TuiMultiSelectOption<T> {
     protected readonly option: TuiOptionWithValue<T> | null;
     protected readonly handlers: TuiItemsHandlers<T>;
     protected readonly value: import("@angular/core").Signal<readonly T[]>;
-    protected readonly size: import("@angular/core").WritableSignal<"m" | "l" | "s">;
+    protected readonly size: import("@angular/core").Signal<"m" | "l" | "s">;
     protected readonly selected: import("@angular/core").Signal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectOption<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiMultiSelectOption<any>, "ng-component", never, {}, {}, never, never, true, never>;

package/components/pager/pager.component.d.ts

@@ -6,7 +6,7 @@ export declare class TuiPager implements OnChanges, AfterViewInit {
     protected start: number;
     protected end: number;
     protected left: import("@angular/core").WritableSignal<number>;
-    protected readonly maxWidth: import("@angular/core").Signal<number | undefined>;
+    protected readonly maxWidth: import("@angular/core").Signal<number>;
     max: number;
     count: number;
     size: TuiSizeS;

package/components/pagination/pagination.component.d.ts

@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
 export declare class TuiPagination {
     private readonly els;
     private readonly el;
-    protected readonly texts$: import("rxjs").Observable<readonly [previous_page: string, next_page: string]>;
+    protected readonly texts: import("@angular/core").Signal<readonly [previous_page: string, next_page: string]>;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiSpinIcons;
     length: number;
     focusable: boolean;

package/components/pin/pin.directive.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class TuiPin {
     protected readonly nothing: undefined;
-    open: boolean;
+    readonly open: import("@angular/core").InputSignal<boolean | "">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiPin, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiPin, "tui-pin,[tuiPin]", never, { "open": { "alias": "open"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiPin, "[tuiPin]", never, { "open": { "alias": "tuiPin"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/preview/pagination/preview-pagination.component.d.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiPreviewPagination {
     protected readonly icons: import("@taiga-ui/kit/tokens").TuiPreviewIcons;
-    protected readonly texts$: import("rxjs").Observable<readonly [previous_page: string, next_page: string]>;
+    protected readonly paginationTexts: import("@angular/core").Signal<readonly [previous_page: string, next_page: string]>;
     length: number;
     index: number;
     readonly indexChange: EventEmitter<number>;

package/components/preview/preview.component.d.ts

@@ -7,7 +7,7 @@ export declare class TuiPreviewComponent {
     protected minZoom: number;
     protected width: number;
     protected height: number;
-    protected readonly texts$: import("rxjs").Observable<{
+    protected readonly previewTexts: import("@angular/core").Signal<{
         rotate: string;
     }>;
     protected readonly icons: import("@taiga-ui/kit/tokens").TuiPreviewIcons;

package/components/preview/zoom/preview-zoom.component.d.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiPreviewZoom {
     protected readonly icons: import("@taiga-ui/kit/tokens").TuiPreviewIcons;
-    protected readonly zoomTexts$: import("rxjs").Observable<{
+    protected readonly zoomTexts: import("@angular/core").Signal<{
         zoomIn: string;
         zoomOut: string;
         reset: string;

package/components/progress/progress-bar/fixed-gradient/progress-fixed-gradient.directive.d.ts

@@ -1,8 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class TuiProgressFixedGradientDirective {
-    private readonly nativeProgress;
     protected readonly nothing: undefined;
-    protected get progressPercent(): number;
+    protected readonly el: HTMLProgressElement;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiProgressFixedGradientDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiProgressFixedGradientDirective, "progress[tuiProgressBar][tuiProgressFixedGradient]", never, {}, {}, never, never, true, never>;
 }

package/components/progress/progress-bar/progress-color-segments.directive.d.ts

@@ -1,9 +1,9 @@
 import * as i0 from "@angular/core";
 export declare class TuiProgressColorSegments {
-    private readonly colors$;
     private readonly el;
-    protected readonly color: import("@angular/core").Signal<string | undefined>;
-    set colors(colors: string[]);
+    private readonly position;
+    protected readonly color: import("@angular/core").Signal<string | null>;
+    readonly colors: import("@angular/core").InputSignal<readonly string[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiProgressColorSegments, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiProgressColorSegments, "progress[tuiProgressBar][tuiProgressColorSegments]", never, { "colors": { "alias": "tuiProgressColorSegments"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiProgressColorSegments, "progress[tuiProgressBar][tuiProgressColorSegments]", never, { "colors": { "alias": "tuiProgressColorSegments"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/progress/progress-segmented/progress-segmented.directive.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class TuiProgressSegmented {
     protected readonly nothing: undefined;
-    segments: number;
+    readonly segments: import("@angular/core").InputSignal<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiProgressSegmented, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiProgressSegmented, "[tuiProgressBar][segments]", never, { "segments": { "alias": "segments"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiProgressSegmented, "[tuiProgressBar][segments]", never, { "segments": { "alias": "segments"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,10 +1,11 @@
-import { type TuiPopover } from '@taiga-ui/cdk/services';
+import { type TuiPortalContext } from '@taiga-ui/cdk/portals';
 import { type TuiPushOptions } from './push.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
+import * as i2 from "@taiga-ui/core/directives/notification";
 export declare class TuiPushAlert {
-    protected readonly context: TuiPopover<TuiPushOptions, string>;
+    protected readonly context: TuiPortalContext<TuiPushOptions, string>;
     protected get isDirective(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiPushAlert, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiPushAlert, "ng-component", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiPushAlert, "tui-push-alert", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiNotificationDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -3,7 +3,7 @@ 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("rxjs").Observable<string>;
+    protected readonly closeWord: import("@angular/core").Signal<string>;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     heading: string;
     type: string;
@@ -11,5 +11,5 @@ export declare class TuiPushComponent {
     timestamp: number | string;
     readonly close: EventEmitter<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-svg,tui-icon", "*", "[tuiButton]", "[tuiLink]"], true, 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>;
 }

package/components/push/push.directive.d.ts

@@ -1,10 +1,8 @@
-import { PolymorpheusTemplate } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
-export declare class TuiPushDirective extends PolymorpheusTemplate {
-    private readonly push;
-    private readonly show$;
+import * as i1 from "@taiga-ui/cdk/portals";
+export declare class TuiPushDirective {
+    private readonly sub;
     constructor();
-    set tuiPush(show: boolean);
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiPushDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiPushDirective, "ng-template[tuiPush]", never, { "tuiPush": { "alias": "tuiPush"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiPushDirective, "ng-template[tuiPush]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiPortalDirective; inputs: { "open": "tuiPush"; }; outputs: {}; }]>;
 }

package/components/push/push.options.d.ts

@@ -1,5 +1,5 @@
-import { InjectionToken, type Provider } from '@angular/core';
-export interface TuiPushOptions {
+import { type TuiPositionOptions } from '@taiga-ui/core/directives/notification';
+export interface TuiPushOptions extends TuiPositionOptions {
     readonly buttons: readonly string[];
     readonly heading: string;
     readonly icon: string;
@@ -8,9 +8,5 @@ export interface TuiPushOptions {
     readonly timestamp: number | string;
     readonly type: string;
 }
-export declare const TUI_PUSH_DEFAULT_OPTIONS: TuiPushOptions;
-/**
- * Default parameters for Push component
- */
-export declare const TUI_PUSH_OPTIONS: InjectionToken<TuiPushOptions>;
-export declare function tuiPushOptionsProvider(options: Partial<TuiPushOptions>): Provider;
+export declare const TUI_PUSH_CONCURRENCY: import("@angular/core").InjectionToken<number>;
+export declare const TUI_PUSH_OPTIONS: import("@angular/core").InjectionToken<TuiPushOptions>, tuiPushOptionsProvider: (item: Partial<TuiPushOptions> | (() => Partial<TuiPushOptions>)) => import("@angular/core").FactoryProvider;

package/components/push/push.service.d.ts

@@ -1,7 +1,11 @@
-import { TuiPopoverService } from '@taiga-ui/cdk/services';
+import { TuiNotificationService } from '@taiga-ui/core/directives/notification';
 import { type TuiPushOptions } from './push.options';
+import { TuiPushAlert } from './push-alert.component';
 import * as i0 from "@angular/core";
-export declare class TuiPushService extends TuiPopoverService<TuiPushOptions, string> {
+export declare class TuiPushService extends TuiNotificationService<TuiPushOptions, string> {
+    protected readonly options: TuiPushOptions;
+    protected readonly component: typeof TuiPushAlert;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiPushService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TuiPushService>;
 }

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

@@ -1,19 +1,18 @@
 import { type DoCheck, type OnInit } from '@angular/core';
 import { NgControl } from '@angular/forms';
-import { type TuiSizeS } from '@taiga-ui/core/types';
+import { type TuiRadioOptions } from './radio.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/appearance";
 import * as i2 from "@taiga-ui/cdk/directives/native-validator";
-export declare class TuiRadioComponent implements DoCheck, OnInit {
-    private readonly appearance;
+export declare class TuiRadioComponent<T extends TuiRadioOptions> implements DoCheck, OnInit {
     private readonly destroyRef;
-    private readonly cdr;
-    private readonly options;
     private readonly el;
+    protected readonly options: T;
+    protected readonly appearance: import("@angular/core").WritableSignal<string>;
     protected readonly control: NgControl | null;
-    size: TuiSizeS;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeS>;
     ngOnInit(): void;
     ngDoCheck(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiRadioComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRadioComponent, "input[type=\"radio\"][tuiRadio]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiAppearance; inputs: { "tuiAppearanceState": "tuiAppearanceState"; "tuiAppearanceFocus": "tuiAppearanceFocus"; "tuiAppearanceMode": "tuiAppearanceMode"; }; outputs: {}; }, { directive: typeof i2.TuiNativeValidator; inputs: {}; outputs: {}; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiRadioComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRadioComponent<any>, "input[type=\"radio\"][tuiRadio]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiAppearance; inputs: { "tuiAppearanceState": "tuiAppearanceState"; "tuiAppearanceFocus": "tuiAppearanceFocus"; "tuiAppearanceMode": "tuiAppearanceMode"; }; outputs: {}; }, { directive: typeof i2.TuiNativeValidator; inputs: {}; outputs: {}; }]>;
 }

package/components/radio/radio.directive.d.ts

@@ -1,8 +1,8 @@
 import { type TuiIdentityMatcher } from '@taiga-ui/cdk/types';
 import * as i0 from "@angular/core";
 export declare class TuiRadioDirective<T> {
-    identityMatcher: TuiIdentityMatcher<T>;
+    readonly identityMatcher: import("@angular/core").InputSignal<TuiIdentityMatcher<T>>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiRadioDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiRadioDirective<any>, "input[type=\"radio\"][tuiRadio][identityMatcher]", never, { "identityMatcher": { "alias": "identityMatcher"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiRadioDirective<any>, "input[type=\"radio\"][tuiRadio][identityMatcher]", never, { "identityMatcher": { "alias": "identityMatcher"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/radio/radio.options.d.ts

@@ -1,10 +1,7 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiStringHandler } from '@taiga-ui/cdk/types';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 export interface TuiRadioOptions {
-    readonly appearance: TuiStringHandler<HTMLInputElement> | string;
+    readonly appearance: TuiStringHandler<HTMLInputElement>;
     readonly size: TuiSizeS;
 }
-export declare const TUI_RADIO_DEFAULT_OPTIONS: TuiRadioOptions;
-export declare const TUI_RADIO_OPTIONS: InjectionToken<TuiRadioOptions>;
-export declare function tuiRadioOptionsProvider(options: Partial<TuiRadioOptions>): Provider;
+export declare const TUI_RADIO_OPTIONS: import("@angular/core").InjectionToken<TuiRadioOptions>, tuiRadioOptionsProvider: (item: Partial<TuiRadioOptions> | (() => Partial<TuiRadioOptions>)) => import("@angular/core").FactoryProvider;

package/components/range/range-change.directive.d.ts

@@ -1,10 +1,9 @@
-import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiRangeChange {
     private readonly doc;
     private readonly el;
     private readonly range;
-    readonly activeThumbChange: EventEmitter<"left" | "right">;
+    readonly activeThumbChange: import("@angular/core").OutputEmitterRef<"end" | "start">;
     constructor();
     private getFractionFromEvents;
     private detectActiveThumb;