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

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

@@ -1,51 +1,43 @@
-import { TemplateRef } from '@angular/core';
+import { ElementRef } 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 */
-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>>>;
+import * as i1 from "@maskito/angular";
+import * as i2 from "@taiga-ui/core/components/input";
+import * as i3 from "@taiga-ui/kit/directives/appearance-proxy";
+export declare class TuiInputPhoneInternationalComponent extends TuiControl<string> {
+    protected readonly list: import("@angular/core").Signal<readonly ElementRef<any>[]>;
+    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 label: import("@angular/core").Signal<string>;
     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 names: import("@angular/core").Signal<Record<TuiCountryIsoCode, string>>;
+    protected readonly open: import("@angular/core").ModelSignal<boolean>;
+    protected readonly dropdownEnabled: import("@angular/core").Signal<boolean>;
+    protected readonly change: import("@angular/core").EffectRef;
     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 masked: import("@angular/core").WritableSignal<string>;
+    protected readonly mask: import("@angular/core").Signal<MaskitoOptions>;
     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;
-    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;
+    protected readonly $: import("rxjs").Subscription;
+    readonly countrySearch: import("@angular/core").InputSignal<boolean>;
+    readonly countryIsoCode: import("@angular/core").ModelSignal<TuiCountryIsoCode>;
+    readonly countries: import("@angular/core").InputSignal<readonly TuiCountryIsoCode[]>;
+    writeValue(unmasked: string | null): void;
+    protected onPaste(event: Event): void;
+    protected onItemClick(code: TuiCountryIsoCode): void;
     private computeMask;
-    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: {}; }]>;
+    private unmask;
+    private getCountryCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneInternationalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPhoneInternationalComponent, "input[tuiInputPhoneInternational]", never, { "countrySearch": { "alias": "countrySearch"; "required": false; "isSignal": true; }; "countryIsoCode": { "alias": "countryIsoCode"; "required": false; "isSignal": true; }; "countries": { "alias": "countries"; "required": false; "isSignal": true; }; }, { "countryIsoCode": "countryIsoCodeChange"; }, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiAppearanceProxy; inputs: {}; outputs: {}; }]>;
 }

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

@@ -0,0 +1,5 @@
+import { TuiLabel } from '@taiga-ui/core/components/label';
+import { TuiTextfieldComponent, TuiTextfieldOptionsDirective } from '@taiga-ui/core/components/textfield';
+import { TuiDropdownContent } from '@taiga-ui/core/portals/dropdown';
+import { TuiInputPhoneInternationalComponent } from './input-phone-international.component';
+export declare const TuiInputPhoneInternational: readonly [typeof TuiInputPhoneInternationalComponent, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

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

@@ -1,9 +1,9 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiCountryIsoCode } from '@taiga-ui/i18n/types';
 import { type MetadataJson } from 'libphonenumber-js/core';
 import { type Observable } from 'rxjs';
 export interface TuiInputPhoneInternationalOptions {
     readonly countries: readonly TuiCountryIsoCode[];
+    readonly countrySearch: boolean;
     readonly countryIsoCode: TuiCountryIsoCode;
     readonly metadata: Observable<MetadataJson> | Promise<MetadataJson>;
     readonly separator: string;
@@ -12,5 +12,4 @@ export declare const TUI_INPUT_PHONE_INTERNATIONAL_DEFAULT_OPTIONS: TuiInputPhon
 /**
  * Default parameters for input phone international component
  */
-export declare const TUI_INPUT_PHONE_INTERNATIONAL_OPTIONS: InjectionToken<TuiInputPhoneInternationalOptions>;
-export declare function tuiInputPhoneInternationalOptionsProvider(options: Partial<TuiInputPhoneInternationalOptions>): Provider;
+export declare const TUI_INPUT_PHONE_INTERNATIONAL_OPTIONS: import("@angular/core").InjectionToken<TuiInputPhoneInternationalOptions>, tuiInputPhoneInternationalOptionsProvider: (item: Partial<TuiInputPhoneInternationalOptions> | (() => Partial<TuiInputPhoneInternationalOptions>)) => import("@angular/core").FactoryProvider;

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

@@ -1 +1,2 @@
+export * from './input-pin';
 export * from './input-pin.component';

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

@@ -2,17 +2,16 @@ import { NgControl } from '@angular/forms';
 import { type MaskitoMask } from '@maskito/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@maskito/angular";
-export declare class TuiInputPin {
+export declare class TuiInputPinComponent {
     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);
+    protected readonly maskito: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions>;
+    readonly mask: import("@angular/core").InputSignalWithTransform<MaskitoMask, string | MaskitoMask>;
     onClick(index: number): void;
     onSelection(): void;
     onArrow(): void;
     isFocused(index: number): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPin, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPin, "input[tuiInputPin]", never, { "maskSetter": { "alias": "mask"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPinComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPinComponent, "input[tuiInputPin]", never, { "mask": { "alias": "mask"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -0,0 +1,5 @@
+import { TuiLabel } from '@taiga-ui/core/components/label';
+import { TuiTextfieldComponent, TuiTextfieldOptionsDirective } from '@taiga-ui/core/components/textfield';
+import { TuiDropdownContent } from '@taiga-ui/core/portals/dropdown';
+import { TuiInputPinComponent } from './input-pin.component';
+export declare const TuiInputPin: readonly [typeof TuiInputPinComponent, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

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

@@ -1,2 +1 @@
-export * from './input-range';
 export * from './input-range.component';

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

@@ -1,75 +1,42 @@
-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';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
-export declare class TuiInputRangeComponent extends TuiControl<readonly [
-    number,
-    number
-]> implements AfterViewInit {
-    private readonly inputNumberRefs;
-    private readonly range?;
+export declare class TuiInputRange extends TuiControl<readonly [number, number]> {
+    private readonly inputs;
+    private readonly range;
+    private readonly options;
     private readonly isMobile;
-    private readonly quantum;
     private readonly quantumTransformer;
-    protected readonly size: import("@angular/core").WritableSignal<"m" | "l" | "s">;
-    protected textfieldValueStart: number;
-    protected textfieldValueEnd: number;
-    protected lastActiveSide: 'end' | 'start';
-    min: number;
-    max: number;
-    step: number;
-    segments: number;
-    keySteps: TuiKeySteps | null;
-    content: readonly [
-        PolymorpheusContent<TuiContext<number>>,
-        PolymorpheusContent<TuiContext<number>>
-    ];
-    prefix: readonly [
-        string,
-        string
-    ];
-    postfix: readonly [
-        string,
-        string
-    ];
-    set quantumSetter(x: number);
-    writeValue(value: [
-        number,
-        number
-    ]): void;
-    ngAfterViewInit(): void;
-    protected get hideStartContent(): boolean;
-    protected get hideEndContent(): boolean;
-    protected takeStep(event: Event | KeyboardEvent, coefficients: readonly [
-        number,
-        number
-    ]): void;
-    protected onInput([start, end]: [
-        number | null,
-        number | null
-    ]): void;
-    protected onExternalValueUpdate(value: readonly [
-        number,
-        number
-    ]): void;
+    protected readonly size: import("@angular/core").Signal<"m" | "s" | "l">;
+    protected start: number;
+    protected end: number;
+    protected side: 'end' | 'start';
+    protected readonly contentStart: import("@angular/core").Signal<PolymorpheusContent<TuiContext<number>>>;
+    protected readonly contentEnd: import("@angular/core").Signal<PolymorpheusContent<TuiContext<number>>>;
+    readonly min: import("@angular/core").InputSignal<number>;
+    readonly max: import("@angular/core").InputSignal<number>;
+    readonly step: import("@angular/core").InputSignal<number>;
+    readonly segments: import("@angular/core").InputSignal<number>;
+    readonly keySteps: import("@angular/core").InputSignal<[[0, number], ...[number, number][], [100, number]] | undefined>;
+    readonly quantum: import("@angular/core").InputSignal<number>;
+    readonly prefix: import("@angular/core").InputSignalWithTransform<readonly [string, string], readonly [string, string] | null | undefined>;
+    readonly postfix: import("@angular/core").InputSignalWithTransform<readonly [string, string], readonly [string, string] | null | undefined>;
+    content: import("@angular/core").InputSignal<readonly [PolymorpheusContent<TuiContext<number>>, PolymorpheusContent<TuiContext<number>>]>;
+    writeValue(value: [number, number]): void;
+    protected get contentStartHidden(): boolean;
+    protected get contentEndHidden(): boolean;
+    protected takeStep(event: Event | KeyboardEvent, coefficients: readonly [number, number]): void;
+    protected onInput([start, end]: [number | null, number | null]): void;
+    protected onExternalValueUpdate(value: readonly [number, number]): void;
     protected focusToTextfield(): void;
-    protected onActiveThumbChange(activeThumb: 'left' | 'right'): void;
-    protected setTextfieldValues([start, end]: readonly [
-        number,
-        number
-    ]): void;
+    protected setTextfieldValues([start, end]: readonly [number, number]): void;
     private get textfieldStart();
     private get textfieldEnd();
     private get activeTextfield();
     private setValue;
     private valueGuard;
-    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 ngAcceptInputType_prefix: readonly [
-        string,
-        string
-    ] | null;
-    static ngAcceptInputType_postfix: readonly [string, string] | null;
+    private isPrimitive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputRange, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputRange, "tui-input-range", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "segments": { "alias": "segments"; "required": false; "isSignal": true; }; "keySteps": { "alias": "keySteps"; "required": false; "isSignal": true; }; "quantum": { "alias": "quantum"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "postfix": { "alias": "postfix"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/input-slider/input-slider.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 { TuiSliderComponent, TuiSliderKeySteps, TuiSliderKeyStepsBase } from '@taiga-ui/kit/components/slider';
 import { TuiInputSliderDirective } from './input-slider.directive';
-export declare const TuiInputSlider: readonly [typeof TuiSliderComponent, typeof TuiSliderKeyStepsBase, typeof TuiSliderKeySteps, typeof TuiInputSliderDirective];
+export declare const TuiInputSlider: readonly [typeof TuiSliderComponent, typeof TuiSliderKeyStepsBase, typeof TuiSliderKeySteps, typeof TuiInputSliderDirective, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

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 readonly sliderInit: 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.component.d.ts

@@ -1,6 +1,5 @@
 import { type MaskitoTimeMode } from '@maskito/kit';
 import { type TuiDay, TuiTime } from '@taiga-ui/cdk/date-time';
-import { TuiTextfieldDirective } from '@taiga-ui/core/components/textfield';
 import { TuiInputTimeDirective } from './input-time.directive';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/core/components/textfield";
@@ -9,12 +8,11 @@ export declare abstract class TuiNativeTimePicker {
     protected getStep(timeMode: MaskitoTimeMode): number;
     protected toISOString(value: TuiTime | readonly [TuiDay, TuiTime | null] | null): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiNativeTimePicker, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNativeTimePicker, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNativeTimePicker, never, never, {}, {}, never, never, true, never>;
 }
 export declare class TuiInputTimeComponent extends TuiNativeTimePicker {
     private readonly control;
     protected readonly host: TuiInputTimeDirective;
-    protected readonly textfield: TuiTextfieldDirective<any>;
     protected readonly value: import("@angular/core").Signal<string>;
     protected readonly step: import("@angular/core").Signal<number>;
     protected setValue(value: string): void;

package/components/input-time/input-time.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 { TuiInputTimeComponent } from './input-time.component';
 import { TuiInputTimeDirective } from './input-time.directive';
-export declare const TuiInputTime: readonly [typeof TuiInputTimeDirective, typeof TuiInputTimeComponent];
+export declare const TuiInputTime: readonly [typeof TuiInputTimeDirective, typeof TuiInputTimeComponent, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

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

@@ -4,33 +4,31 @@ import { TuiControl } from '@taiga-ui/cdk/classes';
 import { TuiTime } from '@taiga-ui/cdk/date-time';
 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 "@maskito/angular";
 export declare class TuiInputTimeDirective extends TuiControl<TuiTime | null> implements TuiTextfieldAccessor<TuiTime | null> {
-    private readonly textfield;
+    private readonly input;
     private readonly dropdown;
     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[];
+    protected readonly mask: import("@angular/core").Signal<MaskitoOptions>;
+    readonly accept: import("@angular/core").InputSignal<readonly TuiTime[]>;
+    readonly timeMode: import("@angular/core").InputSignal<MaskitoTimeMode>;
+    readonly prefix: import("@angular/core").InputSignal<string>;
+    readonly postfix: import("@angular/core").InputSignal<string>;
     readonly native: boolean;
-    readonly timeMode: import("@angular/core").WritableSignal<MaskitoTimeMode>;
-    set modeSetter(x: MaskitoTimeMode);
-    set prefixSetter(x: string);
-    set postfixSetter(x: 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.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,3 +1,6 @@
 import { TuiCalendarYear } from '@taiga-ui/core/components/calendar';
+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 { TuiInputYearDirective } from './input-year.directive';
-export declare const TuiInputYear: readonly [typeof TuiInputYearDirective, typeof TuiCalendarYear];
+export declare const TuiInputYear: readonly [typeof TuiInputYearDirective, typeof TuiCalendarYear, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

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

@@ -1,31 +1,29 @@
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import { TuiCalendarYear } from '@taiga-ui/core/components/calendar';
 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 "@maskito/angular";
-import * as i3 from "@taiga-ui/core/directives/dropdown";
+import * as i3 from "@taiga-ui/core/portals/dropdown";
 export declare class TuiInputYearDirective extends TuiControl<number | null> {
     private readonly options;
-    private readonly textfield;
+    private readonly input;
     private readonly open;
     private readonly initialItem;
-    protected readonly calendar: import("@angular/core").Signal<TuiCalendarYear | null>;
     protected readonly dropdownEnabled: import("@angular/core").Signal<boolean>;
     protected readonly icon: import("@angular/core").Signal<string>;
-    protected readonly min: import("@angular/core").WritableSignal<number>;
-    protected readonly max: import("@angular/core").WritableSignal<number>;
+    protected readonly calendar: import("@angular/core").Signal<TuiCalendarYear | null>;
     /**
      * TODO: move to [value]="value()" after update to Angular 17+
      * something wrong with change detection on host binding
      */
     protected readonly valueEffect: import("@angular/core").EffectRef;
-    protected readonly mask: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions | null>;
+    protected readonly mask: import("@angular/core").Signal<import("@maskito/core").MaskitoOptions>;
     protected readonly calendarInEffect: import("@angular/core").EffectRef;
     protected readonly calendarOutEffect: import("@angular/core").EffectRef;
-    set minSetter(x: number);
-    set maxSetter(x: number);
+    readonly min: import("@angular/core").InputSignal<number>;
+    readonly max: import("@angular/core").InputSignal<number>;
     protected toggle(): void;
     protected onInput(raw: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputYearDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputYearDirective, "input[tuiInputYear]", never, { "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiDropdownAuto; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputYearDirective, "input[tuiInputYear]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiDropdownAuto; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,7 +1,7 @@
 import { type FactoryProvider, InjectionToken } from '@angular/core';
 import { type TuiValueTransformer } from '@taiga-ui/cdk/classes';
-import { type TuiInputDateOptionsNew } from '@taiga-ui/kit/components/input-date';
-export interface TuiInputYearOptions extends Omit<TuiInputDateOptionsNew, 'valueTransformer'> {
+import { type TuiInputDateOptions } from '@taiga-ui/kit/components/input-date';
+export interface TuiInputYearOptions extends Omit<TuiInputDateOptions, 'valueTransformer'> {
     readonly valueTransformer: TuiValueTransformer<number | null, any>;
 }
 export declare const TUI_INPUT_YEAR_OPTIONS: InjectionToken<TuiInputYearOptions>;

package/components/items-with-more/items-with-more.component.d.ts

@@ -1,16 +1,16 @@
-import { type QueryList, TemplateRef } from '@angular/core';
-import { type TuiContext } from '@taiga-ui/cdk/types';
+import { TemplateRef } from '@angular/core';
 import { TuiItemsWithMoreDirective } from './items-with-more.directive';
 import { TuiItemsWithMoreService } from './items-with-more.service';
 import * as i0 from "@angular/core";
 import * as i1 from "./items-with-more.directive";
 export declare class TuiItemsWithMoreComponent {
-    protected readonly items: QueryList<TemplateRef<unknown>>;
-    protected readonly more?: TemplateRef<TuiContext<number>>;
+    protected readonly service: TuiItemsWithMoreService;
     protected readonly directive: TuiItemsWithMoreDirective;
-    readonly lastIndexChange: TuiItemsWithMoreService;
+    protected readonly more: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
+    protected readonly isMoreHidden: import("@angular/core").Signal<boolean>;
+    readonly lastIndexChange: import("@angular/core").OutputRef<number>;
     readonly lastIndex: import("@angular/core").Signal<number>;
-    protected get isMoreHidden(): boolean;
     protected isHidden(index: number): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiItemsWithMoreComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiItemsWithMoreComponent, "tui-items-with-more", never, {}, { "lastIndexChange": "lastIndexChange"; }, ["more", "items"], never, true, [{ directive: typeof i1.TuiItemsWithMoreDirective; inputs: { "itemsLimit": "itemsLimit"; "required": "required"; "side": "side"; "linesLimit": "linesLimit"; }; outputs: {}; }]>;

package/components/items-with-more/items-with-more.directive.d.ts

@@ -3,14 +3,14 @@ import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiItemsWithMoreDirective implements OnChanges {
     private readonly el;
-    itemsLimit: number;
-    required: number;
-    linesLimit: number;
-    side: 'end' | 'start';
+    readonly itemsLimit: import("@angular/core").InputSignal<number>;
+    readonly required: import("@angular/core").InputSignal<number>;
+    readonly linesLimit: import("@angular/core").InputSignal<number>;
+    readonly side: import("@angular/core").InputSignal<"end" | "start">;
+    readonly align: import("@angular/core").Signal<"end" | "start">;
     readonly change$: Subject<void>;
-    get computedSide(): 'end' | 'start';
     ngOnChanges(): void;
     protected maxWidth(): number;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiItemsWithMoreDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiItemsWithMoreDirective, never, never, { "itemsLimit": { "alias": "itemsLimit"; "required": false; }; "required": { "alias": "required"; "required": false; }; "linesLimit": { "alias": "linesLimit"; "required": false; }; "side": { "alias": "side"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiItemsWithMoreDirective, never, never, { "itemsLimit": { "alias": "itemsLimit"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "linesLimit": { "alias": "linesLimit"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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/like/like.options.d.ts

@@ -1,4 +1,4 @@
-import { type TuiAppearanceOptions } from '@taiga-ui/core/directives';
+import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 export interface TuiLikeOptions extends TuiAppearanceOptions {
     readonly size: TuiSizeS;

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/portals/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/line-clamp/line-clamp.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 export interface TuiLineClampOptions {
     readonly showHint: boolean;
 }
@@ -6,5 +5,4 @@ export declare const TUI_LINE_CLAMP_DEFAULT_OPTIONS: TuiLineClampOptions;
 /**
  * Default parameters for LineClamp component
  */
-export declare const TUI_LINE_CLAMP_OPTIONS: InjectionToken<TuiLineClampOptions>;
-export declare function tuiLineClampOptionsProvider(options: Partial<TuiLineClampOptions>): Provider;
+export declare const TUI_LINE_CLAMP_OPTIONS: import("@angular/core").InjectionToken<TuiLineClampOptions>, tuiLineClampOptionsProvider: (item: Partial<TuiLineClampOptions> | (() => Partial<TuiLineClampOptions>)) => import("@angular/core").FactoryProvider;

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

@@ -1,19 +1,17 @@
-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 options;
     private readonly handlers;
     private readonly control;
+    protected readonly values: import("@angular/core").Signal<(T | undefined)[]>;
     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>>);
+    readonly label: import("@angular/core").InputSignal<string>;
     protected toggle(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectGroupComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiMultiSelectGroupComponent<any>, "tui-opt-group[tuiMultiSelectGroup]", never, { "label": { "alias": "label"; "required": false; }; }, {}, ["options"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiMultiSelectGroupComponent<any>, "tui-opt-group[tuiMultiSelectGroup]", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, ["options"], ["*"], true, never>;
 }