@taiga-ui/kit 4.52.0-canary.1ea42f6 → 4.52.0-canary.217a686

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/portals/alert";
 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.TuiAlertDirective; 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;

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,6 @@
-import { InjectionToken, type Provider } from '@angular/core';
-export interface TuiPushOptions {
+import { InjectionToken } from '@angular/core';
+import { type TuiPositionOptions } from '@taiga-ui/core/portals/alert';
+export interface TuiPushOptions extends TuiPositionOptions {
     readonly buttons: readonly string[];
     readonly heading: string;
     readonly icon: string;
@@ -8,9 +9,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_OPTIONS: InjectionToken<TuiPushOptions>, tuiPushOptionsProvider: (item: Partial<TuiPushOptions> | (() => Partial<TuiPushOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_PUSH_CONCURRENCY: InjectionToken<number>;

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

@@ -1,7 +1,11 @@
-import { TuiPopoverService } from '@taiga-ui/cdk/services';
+import { TuiAlertService } from '@taiga-ui/core/portals/alert';
 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 TuiAlertService<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

@@ -6,7 +6,7 @@ import * as i1 from "@taiga-ui/core/directives/appearance";
 import * as i2 from "@taiga-ui/cdk/directives/native-validator";
 export declare class TuiRadioComponent<T extends TuiRadioOptions> implements DoCheck, OnInit {
     private readonly destroyRef;
-    private readonly el;
+    protected readonly el: HTMLInputElement;
     protected readonly options: T;
     protected readonly appearance: import("@angular/core").WritableSignal<string>;
     protected readonly control: NgControl | null;

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

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

package/components/range/range-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;

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

@@ -1,45 +1,36 @@
-import { ElementRef, type OnChanges, type QueryList } from '@angular/core';
+import { ElementRef } from '@angular/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { type TuiSizeS } from '@taiga-ui/core/types';
-import { type TuiKeySteps } from '@taiga-ui/kit/components/slider';
 import * as i0 from "@angular/core";
 import * as i1 from "./range-change.directive";
-export declare class TuiRange extends TuiControl<[number, number]> implements OnChanges {
-    private readonly changes;
+export declare class TuiRange extends TuiControl<[number, number]> {
     private readonly el;
     protected readonly options: import("@taiga-ui/kit/components/slider").TuiSliderOptions;
     protected lastActiveThumb: 'end' | 'start';
-    min: number;
-    max: number;
-    step: number;
-    size: TuiSizeS;
-    segments: number;
-    keySteps: TuiKeySteps | null;
-    focusable: boolean;
-    margin: number;
-    limit: number;
-    readonly slidersRefs: QueryList<ElementRef<HTMLInputElement>>;
+    readonly min: import("@angular/core").InputSignal<number>;
+    readonly max: import("@angular/core").InputSignal<number>;
+    readonly step: import("@angular/core").InputSignal<number>;
+    readonly size: import("@angular/core").InputSignal<TuiSizeS>;
+    readonly segments: import("@angular/core").InputSignal<number>;
+    readonly keySteps: import("@angular/core").InputSignal<[[0, number], ...[number, number][], [100, number]] | undefined>;
+    readonly focusable: import("@angular/core").InputSignal<boolean>;
+    readonly margin: import("@angular/core").InputSignal<number>;
+    readonly limit: import("@angular/core").InputSignal<number>;
     readonly start: import("@angular/core").Signal<number>;
     readonly end: import("@angular/core").Signal<number>;
-    /**
-     * TODO(v5): standardize logic between `TuiSlider` & `TuiInputSlider` & `Range` & `InputRange`
-     * For non-linear slider (with `[keySteps]` property) `step` means percentage
-     */
-    legacyMode: boolean;
-    ngOnChanges(): void;
+    readonly sliders: import("@angular/core").Signal<readonly ElementRef<HTMLInputElement>[]>;
+    protected readonly segmentWidthRatio: import("@angular/core").Signal<number>;
+    protected readonly fractionStep: import("@angular/core").Signal<number>;
+    protected readonly computedKeySteps: import("@angular/core").Signal<[[0, number], ...[number, number][], [100, number]]>;
     processValue(value: number, end: boolean): void;
     takeStep(coefficients: readonly [number, number]): readonly [number, number];
     toValue(fraction: number): number;
-    protected get fractionStep(): number;
-    protected get computedKeySteps(): TuiKeySteps;
-    protected get segmentWidthRatio(): number;
     protected get rtl(): boolean;
     protected changeByStep(coefficient: number, target: HTMLElement): void;
     protected toPercent(value: number): number;
-    private computePureKeySteps;
     private updateStart;
     private updateEnd;
     private checkDistance;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiRange, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRange, "tui-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "size": { "alias": "size"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "keySteps": { "alias": "keySteps"; "required": false; }; "focusable": { "alias": "focusable"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiRangeChange; inputs: {}; outputs: { "activeThumbChange": "activeThumbChange"; }; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiRange, "tui-range", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "segments": { "alias": "segments"; "required": false; "isSignal": true; }; "keySteps": { "alias": "keySteps"; "required": false; "isSignal": true; }; "focusable": { "alias": "focusable"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiRangeChange; inputs: {}; outputs: { "activeThumbChange": "activeThumbChange"; }; }]>;
 }

package/components/rating/rating.component.d.ts

@@ -3,7 +3,7 @@ import * as i0 from "@angular/core";
 export declare class TuiRating extends TuiControl<number> {
     private readonly options;
     protected readonly active: import("@angular/core").WritableSignal<number>;
-    protected readonly array: import("@angular/core").Signal<any[]>;
+    protected readonly array: import("@angular/core").Signal<unknown[]>;
     readonly icon: import("@angular/core").InputSignal<import("@taiga-ui/polymorpheus").PolymorpheusContent<import("./rating.options").TuiRatingContext>>;
     readonly max: import("@angular/core").InputSignal<number>;
     protected onKeyDown(event: KeyboardEvent): void;

package/components/rating/rating.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 export interface TuiRatingContext extends TuiContext<number> {
@@ -10,5 +9,4 @@ export interface TuiRatingOptions {
     readonly max: number;
 }
 export declare const TUI_RATING_DEFAULT_OPTIONS: TuiRatingOptions;
-export declare const TUI_RATING_OPTIONS: InjectionToken<TuiRatingOptions>;
-export declare function tuiRatingOptionsProvider(options: Partial<TuiRatingOptions>): Provider;
+export declare const TUI_RATING_OPTIONS: import("@angular/core").InjectionToken<TuiRatingOptions>, tuiRatingOptionsProvider: (item: Partial<TuiRatingOptions> | (() => Partial<TuiRatingOptions>)) => import("@angular/core").FactoryProvider;

package/components/routable-dialog/generate-dialogable-route.d.ts

@@ -1,6 +1,6 @@
 import { type Type } from '@angular/core';
 import { type DefaultExport, type Route } from '@angular/router';
-import { type TuiDialogOptions } from '@taiga-ui/core/components/dialog';
+import { type TuiDialogOptions } from '@taiga-ui/core/portals/dialog';
 export declare function tuiGenerateDialogableRoute<I>(component: Type<any> | (() => Promise<DefaultExport<Type<any>> | Type<any>>), { path, outlet, ...dialogOptions }?: Partial<TuiDialogOptions<I>> & {
     path?: string;
     outlet?: string;

package/components/segmented/segmented.component.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter, type OnChanges } from '@angular/core';
+import { type OnChanges } from '@angular/core';
 import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "./segmented.directive";
@@ -12,13 +12,11 @@ export declare const TUI_SEGMENTED_OPTIONS: import("@angular/core").InjectionTok
 export declare class TuiSegmented implements OnChanges {
     private readonly el;
     protected readonly sub: import("rxjs").Subscription;
-    size: TuiSizeL | TuiSizeS;
-    activeItemIndex: number;
-    readonly activeItemIndexChange: EventEmitter<number>;
+    readonly size: import("@angular/core").InputSignal<"s" | "m" | "l">;
+    readonly activeItemIndex: import("@angular/core").ModelSignal<number>;
     ngOnChanges(): void;
     update(activeItemIndex: number): void;
-    private get activeElement();
     private refresh;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSegmented, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSegmented, "tui-segmented", never, { "size": { "alias": "size"; "required": false; }; "activeItemIndex": { "alias": "activeItemIndex"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, never, ["*"], true, [{ directive: typeof i1.TuiSegmentedDirective; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSegmented, "tui-segmented", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "activeItemIndex": { "alias": "activeItemIndex"; "required": false; "isSignal": true; }; }, { "activeItemIndex": "activeItemIndexChange"; }, never, ["*"], true, [{ directive: typeof i1.TuiSegmentedDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,17 +1,16 @@
 import { type AfterContentChecked, type AfterContentInit } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiSegmentedDirective implements AfterContentChecked, AfterContentInit {
-    private readonly controls;
-    private readonly radios;
-    private readonly links;
-    private readonly elements;
     private readonly component;
     private readonly el;
+    private readonly links;
+    private readonly elements;
+    private readonly controls;
+    private readonly controls$;
+    private readonly radios;
     ngAfterContentInit(): void;
     ngAfterContentChecked(): void;
     protected update(target: Element | null): void;
-    private get linkIndex();
-    private getIndex;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSegmentedDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSegmentedDirective, never, never, {}, {}, ["controls", "radios", "links", "elements"], never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSegmentedDirective, never, never, {}, {}, ["links", "elements", "controls", "radios"], never, true, never>;
 }

package/components/select/native-select/native-select.component.d.ts

@@ -3,21 +3,20 @@ import { type TuiTextfieldAccessor } from '@taiga-ui/core/components/textfield';
 import { type TuiItemsHandlers } from '@taiga-ui/core/directives/items-handlers';
 import { tuiIsFlat } from '@taiga-ui/kit/utils';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/components/textfield";
+import * as i1 from "@taiga-ui/core/components/input";
 export declare class TuiNativeSelect<T> extends TuiControl<T | null> implements TuiTextfieldAccessor<T> {
-    private readonly textfield;
+    private readonly input;
+    private readonly options;
     protected readonly isFlat: typeof tuiIsFlat;
-    protected readonly placeholder: import("@angular/core").WritableSignal<string>;
     protected readonly itemsHandlers: TuiItemsHandlers<T>;
     protected readonly stringified: import("@angular/core").Signal<string>;
-    protected readonly showPlaceholder: import("@angular/core").Signal<boolean | "">;
     protected readonly isSelected: import("@angular/core").Signal<(x: T) => boolean>;
     protected readonly valueEffect: import("@angular/core").EffectRef;
-    items: ReadonlyArray<readonly T[]> | readonly T[] | null;
-    labels: readonly string[];
-    set placeholderSetter(x: string);
+    readonly items: import("@angular/core").InputSignal<readonly T[] | readonly (readonly T[])[] | null>;
+    readonly labels: import("@angular/core").InputSignal<readonly string[]>;
+    readonly placeholder: import("@angular/core").InputSignal<string>;
     setValue(value: T | null): void;
     protected selectOption(index: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiNativeSelect<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiNativeSelect<any>, "select[tuiSelect]", never, { "items": { "alias": "items"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "placeholderSetter": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiNativeSelect<any>, "select[tuiSelect]", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }]>;
 }

package/components/select/select.d.ts

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

package/components/select/select.directive.d.ts

@@ -1,14 +1,15 @@
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { type TuiTextfieldAccessor } from '@taiga-ui/core/components/textfield';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/components/textfield";
+import * as i1 from "@taiga-ui/core/components/input";
+import * as i2 from "@taiga-ui/core/components/textfield";
 export declare class TuiSelectDirective<T> extends TuiControl<T | null> implements TuiTextfieldAccessor<T> {
-    private readonly textfield;
+    private readonly input;
     private readonly open;
     private readonly itemsHandlers;
     protected readonly dropdownEnabled: import("@angular/core").Signal<boolean>;
     protected readonly valueEffect: import("@angular/core").EffectRef;
     setValue(value: T | null): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSelectDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSelectDirective<any>, "input[tuiSelect]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }, { directive: typeof i1.TuiSelectLike; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSelectDirective<any>, "input[tuiSelect]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiSelectLike; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,5 +1,4 @@
 import { type TuiValueTransformer } from '@taiga-ui/cdk/classes';
-import { type TuiSliderComponent } from '../slider.component';
 /**
  * Used as a limit for eliminating JS issues with floating point math
  */
@@ -25,4 +24,4 @@ export declare const TUI_FLOATING_PRECISION = 7;
 export type TuiKeySteps = [[0, number], ...Array<[number, number]>, [100, number]];
 export declare function tuiPercentageToKeyStepValue(valuePercentage: number, keySteps: TuiKeySteps): number;
 export declare function tuiKeyStepValueToPercentage(value: number, keySteps: TuiKeySteps): number;
-export declare function tuiCreateKeyStepsTransformer(keySteps: TuiKeySteps, slider: TuiSliderComponent): TuiValueTransformer<number, number>;
+export declare function tuiCreateKeyStepsTransformer(keySteps: TuiKeySteps): TuiValueTransformer<number, number>;

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

@@ -5,34 +5,26 @@ import * as i0 from "@angular/core";
 export declare class TuiSliderKeyStepsBase {
     private readonly injector;
     private readonly control;
-    protected min?: number;
-    protected max?: number;
-    step: number | null;
-    transformer: import("@angular/core").WritableSignal<TuiValueTransformer<number, number> | null>;
-    value: import("@angular/core").Signal<number | undefined>;
+    protected readonly min: import("@angular/core").WritableSignal<number | undefined>;
+    protected readonly max: import("@angular/core").WritableSignal<number | undefined>;
+    protected readonly sync: import("@angular/core").EffectRef;
+    readonly step: import("@angular/core").InputSignal<number>;
+    readonly keySteps: import("@angular/core").InputSignal<[[0, number], ...[number, number][], [100, number]] | undefined>;
+    readonly transformer: import("@angular/core").WritableSignal<TuiValueTransformer<number, number> | undefined>;
+    controlValue: import("@angular/core").Signal<number | undefined>;
+    readonly totalSteps: import("@angular/core").Signal<number>;
     get slider(): TuiSliderComponent;
-    set keySteps(steps: TuiKeySteps | null);
-    /**
-     * TODO(v5): standardize logic between `TuiSlider` & `TuiInputSlider` & `Range` & `InputRange`
-     * For non-linear slider (with `[keySteps]` property) `step` means percentage
-     * Add these host-bindings to `TuiSliderKeyStepsBase`:
-     * ```
-     * host: {
-     *     '[attr.min]': '0',
-     *     '[attr.step]': '1',
-     *     '[attr.max]': 'totalSteps',
-     * },
-     * ```
-     */
-    get totalSteps(): number;
     takeStep(coefficient: number): number;
+    toSliderValue(fraction: number): number;
+    setControlValue(controlValue: number): void;
+    getControlValue(): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderKeyStepsBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderKeyStepsBase, "input[tuiSlider][keySteps]", never, { "step": { "alias": "step"; "required": false; }; "keySteps": { "alias": "keySteps"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_step: number | "any";
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderKeyStepsBase, "input[tuiSlider][keySteps]", never, { "step": { "alias": "step"; "required": false; "isSignal": true; }; "keySteps": { "alias": "keySteps"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 export declare class TuiSliderKeySteps extends TuiControl<number> {
-    private readonly slider;
-    set keySteps(steps: TuiKeySteps);
+    protected readonly base: TuiSliderKeyStepsBase;
+    set keySteps(steps: TuiKeySteps | null | undefined);
+    protected setValue(sliderValue: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderKeySteps, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiSliderKeySteps, "input[tuiSlider][keySteps][ngModel],input[tuiSlider][keySteps][formControl],input[tuiSlider][keySteps][formControlName]", never, { "keySteps": { "alias": "keySteps"; "required": false; }; }, {}, never, never, true, never>;
 }

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

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

package/components/slider/slider.options.d.ts

@@ -1,12 +1,7 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 export interface TuiSliderOptions {
     readonly size: TuiSizeS;
     readonly trackColor: string;
 }
 export declare const TUI_SLIDER_DEFAULT_OPTIONS: TuiSliderOptions;
-/**
- * Default parameters for Slider component
- */
-export declare const TUI_SLIDER_OPTIONS: InjectionToken<TuiSliderOptions>;
-export declare function tuiSliderOptionsProvider(options: Partial<TuiSliderOptions>): Provider;
+export declare const TUI_SLIDER_OPTIONS: import("@angular/core").InjectionToken<TuiSliderOptions>, tuiSliderOptionsProvider: (item: Partial<TuiSliderOptions> | (() => Partial<TuiSliderOptions>)) => import("@angular/core").FactoryProvider;

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

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

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

@@ -1,27 +1,20 @@
-import { EventEmitter, type OnChanges } from '@angular/core';
+import { type OnChanges } from '@angular/core';
 import { type TuiOrientation } from '@taiga-ui/core/types';
-import { type Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiStepperComponent implements OnChanges {
-    private readonly steps;
-    private readonly cdr;
     private readonly el;
-    private readonly scrollService;
-    private readonly speed;
-    private readonly destroyRef;
+    private readonly steps;
     protected readonly $: import("rxjs").Subscription;
-    activeItemIndex: number;
-    orientation: TuiOrientation;
-    readonly activeItemIndexChange: EventEmitter<number>;
+    readonly orientation: import("@angular/core").InputSignal<TuiOrientation>;
+    readonly activeItemIndex: import("@angular/core").ModelSignal<number>;
     ngOnChanges(): void;
     indexOf(step: HTMLElement): number;
     isActive(index: number): boolean;
     activate(index: number): void;
-    protected get changes$(): Observable<unknown>;
     protected onHorizontal(event: Event, step: number): void;
     protected onVertical(event: Event, step: number): void;
     private moveFocus;
     private scrollIntoView;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiStepperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiStepperComponent, "tui-stepper, nav[tuiStepper]", never, { "activeItemIndex": { "alias": "activeItemIndex"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, ["steps"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiStepperComponent, "tui-stepper, nav[tuiStepper]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "activeItemIndex": { "alias": "activeItemIndex"; "required": false; "isSignal": true; }; }, { "activeItemIndex": "activeItemIndexChange"; }, ["steps"], ["*"], true, never>;
 }

package/components/switch/switch.component.d.ts

@@ -3,6 +3,7 @@ import { type TuiSwitchOptions } from './switch.options';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/directives/icons";
 export declare class TuiSwitch extends TuiRadioComponent<TuiSwitchOptions> {
+    protected readonly native: boolean;
     protected readonly icon: import("@angular/core").Signal<string>;
     readonly showIcons: import("@angular/core").InputSignal<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiSwitch, never>;

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

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