@taiga-ui/kit 4.52.0-canary.9fae831 → 4.52.0-canary.a59c4d0

package/components/accordion/accordion.component.d.ts

@@ -0,0 +1,13 @@
+import { TuiExpand } from '@taiga-ui/core/components/expand';
+import { TuiAccordionDirective } from './accordion.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/group";
+export declare class TuiAccordionComponent {
+    protected readonly expands: import("@angular/core").Signal<readonly TuiExpand[]>;
+    protected readonly directives: import("@angular/core").Signal<readonly TuiAccordionDirective[]>;
+    readonly closeOthers: import("@angular/core").InputSignal<boolean>;
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "l">;
+    toggle(directive: TuiAccordionDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAccordionComponent, "tui-accordion", never, { "closeOthers": { "alias": "closeOthers"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["expands", "directives"], ["*"], true, [{ directive: typeof i1.TuiGroup; inputs: {}; outputs: {}; }]>;
+}

package/components/accordion/accordion.d.ts

@@ -1,5 +1,5 @@
+import { TuiItem } from '@taiga-ui/cdk/directives/item';
+import { TuiExpand } from '@taiga-ui/core/components/expand';
+import { TuiAccordionComponent } from './accordion.component';
 import { TuiAccordionDirective } from './accordion.directive';
-import { TuiAccordionItem } from './accordion-item.component';
-import { TuiAccordionItemContent } from './accordion-item-content.directive';
-import { TuiAccordionItemEagerContent } from './accordion-item-eager-content.directive';
-export declare const TuiAccordion: readonly [typeof TuiAccordionItem, typeof TuiAccordionDirective, typeof TuiAccordionItemContent, typeof TuiAccordionItemEagerContent];
+export declare const TuiAccordion: readonly [typeof TuiAccordionComponent, typeof TuiAccordionDirective, typeof TuiExpand, typeof TuiItem];

package/components/accordion/accordion.directive.d.ts

@@ -1,13 +1,14 @@
-import { type AfterContentInit, type QueryList } from '@angular/core';
-import { TuiAccordionItem } from './accordion-item.component';
+import { type OnChanges } from '@angular/core';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/directives/group";
-export declare class TuiAccordionDirective implements AfterContentInit {
-    private readonly destroyRef;
-    protected readonly accordionItems: QueryList<TuiAccordionItem>;
-    closeOthers: boolean;
-    constructor();
-    ngAfterContentInit(): void;
+import * as i1 from "@taiga-ui/core/components/button";
+import * as i2 from "@taiga-ui/kit/directives/chevron";
+export declare class TuiAccordionDirective implements OnChanges {
+    private readonly accordion;
+    readonly open: import("@angular/core").ModelSignal<boolean | "">;
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "l">;
+    readonly chevron: import("@angular/core").ModelSignal<boolean | "">;
+    ngOnChanges(): void;
+    toggle(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAccordionDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAccordionDirective, "tui-accordion", never, { "closeOthers": { "alias": "closeOthers"; "required": false; }; }, {}, ["accordionItems"], never, true, [{ directive: typeof i1.TuiGroup; inputs: { "rounded": "rounded"; }; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAccordionDirective, "button[tuiAccordion]", never, { "open": { "alias": "tuiAccordion"; "required": false; "isSignal": true; }; }, { "open": "tuiAccordionChange"; }, never, never, true, [{ directive: typeof i1.TuiButton; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiChevron; inputs: {}; outputs: {}; }]>;
 }

package/components/accordion/index.d.ts

@@ -1,5 +1,3 @@
 export * from './accordion';
+export * from './accordion.component';
 export * from './accordion.directive';
-export * from './accordion-item.component';
-export * from './accordion-item-content.directive';
-export * from './accordion-item-eager-content.directive';

package/components/action-bar/action-bar.component.d.ts

@@ -1,11 +1,9 @@
-import { type TuiButtonOptions } from '@taiga-ui/core/components/button';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
-export declare class TuiActionBarComponent implements TuiButtonOptions {
-    expanded: boolean;
-    size: TuiSizeS;
-    readonly appearance = "secondary-grayscale";
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiActionBarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiActionBarComponent, "tui-action-bar", never, { "expanded": { "alias": "expanded"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["tui-data-list,[tuiMenu]", "*", "a,button,[tuiAction]"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+export declare class TuiActionBar {
+    readonly expanded: import("@angular/core").InputSignal<boolean>;
+    readonly size: import("@angular/core").InputSignal<TuiSizeS>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiActionBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiActionBar, "tui-action-bar", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["tui-data-list,[tuiMenu]", "*", "a,button,[tuiAction]"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
 }

package/components/action-bar/index.d.ts

@@ -1,3 +1 @@
-export * from './action-bar';
 export * from './action-bar.component';
-export * from './action-bar.directive';

package/components/avatar/avatar-outline.directive.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class TuiAvatarOutline {
     protected readonly nothing: undefined;
-    tuiAvatarOutline: string | null;
-    protected get value(): string | null;
+    protected readonly value: import("@angular/core").Signal<string | null>;
+    readonly tuiAvatarOutline: import("@angular/core").InputSignal<string | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAvatarOutline, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAvatarOutline, "[tuiAvatarOutline]", never, { "tuiAvatarOutline": { "alias": "tuiAvatarOutline"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAvatarOutline, "[tuiAvatarOutline]", never, { "tuiAvatarOutline": { "alias": "tuiAvatarOutline"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/badge/badge.directive.d.ts

@@ -3,7 +3,7 @@ import * as i1 from "@taiga-ui/core/directives/appearance";
 import * as i2 from "@taiga-ui/core/directives/icons";
 export declare class TuiBadge {
     protected readonly nothing: undefined;
-    size: "m" | "s" | "l" | "xl";
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "l" | "xl">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBadge, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadge, "tui-badge,[tuiBadge],tui-icon[tuiBadge]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadge, "tui-badge,[tuiBadge],tui-icon[tuiBadge]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
 }

package/components/block/block.directive.d.ts

@@ -1,13 +1,13 @@
 import { NgControl } from '@angular/forms';
-import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/native-validator";
 import * as i2 from "@taiga-ui/core/directives/appearance";
 import * as i3 from "@taiga-ui/core/directives/icons";
 export declare class TuiBlock {
-    protected readonly control?: NgControl;
     protected readonly nothing: undefined;
-    size: TuiSizeL | TuiSizeS | '';
+    protected readonly options: import("./block.options").TuiBlockOptions;
+    protected readonly control: import("@angular/core").Signal<NgControl | undefined>;
+    readonly size: import("@angular/core").InputSignal<"" | "m" | "l" | "s">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBlock, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBlock, "label[tuiBlock],input[tuiBlock]", never, { "size": { "alias": "tuiBlock"; "required": false; }; }, {}, ["control"], never, true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBlock, "label[tuiBlock],input[tuiBlock]", never, { "size": { "alias": "tuiBlock"; "required": false; "isSignal": true; }; }, {}, ["control"], never, true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithIcons; inputs: {}; outputs: {}; }]>;
 }

package/components/block/block.options.d.ts

@@ -2,7 +2,7 @@ import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 export interface TuiBlockOptions extends TuiAppearanceOptions {
-    readonly size: TuiSizeL | TuiSizeS;
+    readonly size: TuiSizeL | TuiSizeS | '';
 }
 export declare const TUI_BLOCK_DEFAULT_OPTIONS: TuiBlockOptions;
 export declare const TUI_BLOCK_OPTIONS: InjectionToken<TuiBlockOptions>;

package/components/chip/chip.directive.d.ts

@@ -1,11 +1,9 @@
-import { type TuiSizeXXS } from '@taiga-ui/core/types';
 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 TuiChip {
-    private readonly options;
     protected readonly nothing: undefined;
-    size: TuiSizeXXS;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeXXS>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiChip, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiChip, "tui-chip,[tuiChip]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiChip, "tui-chip,[tuiChip]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
 }

package/components/comment/comment.directive.d.ts

@@ -2,7 +2,7 @@ import { type TuiHorizontalDirection, type TuiVerticalDirection } from '@taiga-u
 import * as i0 from "@angular/core";
 export declare class TuiComment {
     protected readonly nothing: undefined;
-    tuiComment: TuiHorizontalDirection | TuiVerticalDirection | '';
+    readonly direction: import("@angular/core").InputSignal<"" | TuiHorizontalDirection | TuiVerticalDirection>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiComment, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiComment, "[tuiComment]", never, { "tuiComment": { "alias": "tuiComment"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiComment, "[tuiComment]", never, { "direction": { "alias": "tuiComment"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/floating-container/floating-container.directive.d.ts

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

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

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

package/components/fullscreen/index.d.ts

@@ -0,0 +1 @@
+export * from './fullscreen.component';

package/components/index.d.ts

@@ -16,12 +16,14 @@ export * from '@taiga-ui/kit/components/combo-box';
 export * from '@taiga-ui/kit/components/comment';
 export * from '@taiga-ui/kit/components/compass';
 export * from '@taiga-ui/kit/components/confirm';
+export * from '@taiga-ui/kit/components/copy';
 export * from '@taiga-ui/kit/components/data-list-wrapper';
 export * from '@taiga-ui/kit/components/drawer';
 export * from '@taiga-ui/kit/components/elastic-container';
 export * from '@taiga-ui/kit/components/files';
 export * from '@taiga-ui/kit/components/filter';
 export * from '@taiga-ui/kit/components/floating-container';
+export * from '@taiga-ui/kit/components/fullscreen';
 export * from '@taiga-ui/kit/components/input-chip';
 export * from '@taiga-ui/kit/components/input-color';
 export * from '@taiga-ui/kit/components/input-date';
@@ -47,7 +49,6 @@ export * from '@taiga-ui/kit/components/multi-select';
 export * from '@taiga-ui/kit/components/notification-middle';
 export * from '@taiga-ui/kit/components/pager';
 export * from '@taiga-ui/kit/components/pagination';
-export * from '@taiga-ui/kit/components/pdf-viewer';
 export * from '@taiga-ui/kit/components/pin';
 export * from '@taiga-ui/kit/components/preview';
 export * from '@taiga-ui/kit/components/progress';
@@ -68,4 +69,5 @@ export * from '@taiga-ui/kit/components/switch';
 export * from '@taiga-ui/kit/components/tabs';
 export * from '@taiga-ui/kit/components/textarea';
 export * from '@taiga-ui/kit/components/tiles';
+export * from '@taiga-ui/kit/components/toast';
 export * from '@taiga-ui/kit/components/tree';

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

@@ -13,7 +13,7 @@ export declare class TuiQuantumValueTransformer extends TuiQuantumValueTransform
     protected parent: TuiValueTransformer<number | null, any> | null;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiQuantumValueTransformer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiQuantumValueTransformer, "[tuiInputNumber][quantum], [tuiInputSlider][quantum]", never, { "quantum": { "alias": "quantum"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiQuantumValueTransformer, "[tuiInputNumber][quantum]", never, { "quantum": { "alias": "quantum"; "required": false; }; }, {}, never, never, true, never>;
 }
 export declare class TuiWithQuantumValueTransformer {
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiWithQuantumValueTransformer, never>;

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 code: import("@angular/core").WritableSignal<TuiCountryIsoCode>;
     protected readonly label: import("@angular/core").Signal<string | undefined>;
+    protected readonly metadata: import("@angular/core").Signal<MetadataJson | undefined>;
+    protected readonly names: import("@angular/core").Signal<Record<TuiCountryIsoCode, string> | undefined>;
+    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").WritableSignal<"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-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,7 +6,7 @@ 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;
@@ -17,15 +16,13 @@ export declare class TuiInputRangeComponent extends TuiControl<readonly [
     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/like/like.component.d.ts

@@ -2,8 +2,8 @@ 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 {
-    readonly tuiLike: import("@angular/core").InputSignal<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, { "tuiLike": { "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: {}; }]>;
+    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/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/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/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/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-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,10 @@
-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";
 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: {}; }]>;
 }

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

@@ -7,6 +7,8 @@ export interface TuiPushOptions {
     readonly image: string;
     readonly timestamp: number | string;
     readonly type: string;
+    readonly position: 'bottom' | 'top';
+    readonly orientation: 'center' | 'end' | 'start';
 }
 export declare const TUI_PUSH_DEFAULT_OPTIONS: TuiPushOptions;
 /**

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

@@ -1,7 +1,10 @@
-import { TuiPopoverService } from '@taiga-ui/cdk/services';
+import { TuiPortal } from '@taiga-ui/cdk/portals';
 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 TuiPortal<TuiPushOptions, string> {
+    protected readonly options: TuiPushOptions;
+    protected readonly component: typeof TuiPushAlert;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiPushService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TuiPushService>;
 }

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

@@ -4,7 +4,7 @@ export declare class TuiRangeChange {
     private readonly doc;
     private readonly el;
     private readonly range;
-    readonly activeThumbChange: EventEmitter<"left" | "right">;
+    readonly activeThumbChange: EventEmitter<"end" | "start">;
     constructor();
     private getFractionFromEvents;
     private detectActiveThumb;

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

@@ -21,11 +21,6 @@ export declare class TuiRange extends TuiControl<[number, number]> implements On
     readonly slidersRefs: QueryList<ElementRef<HTMLInputElement>>;
     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;
     processValue(value: number, end: boolean): void;
     takeStep(coefficients: readonly [number, number]): readonly [number, number];

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