@taiga-ui/kit 4.69.0 → 5.0.0-canary.0c88239

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

@@ -1,38 +1,21 @@
-import { type MaskitoOptions } from '@maskito/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/components/textfield";
-import * as i2 from "@maskito/angular";
-export declare class TuiInputNumberDirective extends TuiControl<number | null> {
-    private readonly options;
-    private readonly textfield;
+import * as i1 from "@taiga-ui/core/components/input";
+import * as i2 from "./number-mask.directive";
+import * as i3 from "./transformers/number.value-transformer";
+export declare class TuiInputNumberDirective extends TuiControl<string> {
+    private readonly mask;
+    private readonly input;
     private readonly isIOS;
-    private readonly minRaw;
-    private readonly maxRaw;
-    private readonly numberFormat;
-    private readonly formatted;
-    private readonly precision;
-    private readonly unfinished;
     protected readonly element: HTMLInputElement;
-    protected readonly mask: import("@angular/core").Signal<MaskitoOptions | null>;
     protected readonly inputMode: import("@angular/core").Signal<"text" | "decimal" | "numeric">;
     protected readonly defaultMaxLength: import("@angular/core").Signal<number>;
+    readonly parsed: import("@angular/core").Signal<number | bigint>;
     protected readonly onChangeEffect: import("@angular/core").EffectRef;
-    protected maskInitialCalibrationEffect: import("@angular/core").EffectRef;
-    readonly min: import("@angular/core").Signal<number>;
-    readonly max: import("@angular/core").Signal<number>;
-    readonly prefix: import("@angular/core").WritableSignal<string>;
-    readonly postfix: import("@angular/core").WritableSignal<string>;
-    set minSetter(x: number | null);
-    set maxSetter(x: number | null);
-    set prefixSetter(x: string);
-    set postfixSetter(x: string);
-    writeValue(value: number | null): void;
-    setValue(value: number | null): void;
+    writeValue(value: any): void;
+    setValue(value: bigint | number | string | null): void;
     protected onFocus(): void;
-    private get maskParams();
-    private formatNumber;
-    private computeMask;
+    private parse;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputNumberDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputNumberDirective, "input[tuiInputNumber]", never, { "minSetter": { "alias": "min"; "required": false; }; "maxSetter": { "alias": "max"; "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<TuiInputNumberDirective, "input[tuiInputNumber]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithNumberMask; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiNumberValueTransformer; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,15 +1,12 @@
+import { type MaskitoNumberParams } from '@maskito/kit';
 import { type TuiValueTransformer } from '@taiga-ui/cdk/classes';
-export interface TuiInputNumberOptions {
-    readonly max: number;
-    readonly min: number;
-    readonly prefix: string;
-    readonly postfix: string;
-    readonly step: number;
+export interface TuiInputNumberOptions extends Pick<Required<MaskitoNumberParams>, 'max' | 'min' | 'minusSign' | 'postfix' | 'prefix'> {
+    readonly step: bigint | number;
     readonly icons: Readonly<{
         decrease: string;
         increase: string;
     }>;
-    readonly valueTransformer: TuiValueTransformer<number | null, any> | null;
+    readonly valueTransformer: TuiValueTransformer<bigint | null, any> | TuiValueTransformer<number | null, any> | null;
 }
 export declare const TUI_INPUT_NUMBER_DEFAULT_OPTIONS: TuiInputNumberOptions;
-export declare const TUI_INPUT_NUMBER_OPTIONS: import("@angular/core").InjectionToken<TuiInputNumberOptions>, tuiInputNumberOptionsProvider: (item: Partial<TuiInputNumberOptions> | import("@angular/core").ProviderToken<Partial<TuiInputNumberOptions>> | (() => Partial<TuiInputNumberOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_INPUT_NUMBER_OPTIONS: import("@angular/core").InjectionToken<TuiInputNumberOptions>, tuiInputNumberOptionsProvider: (item: Partial<TuiInputNumberOptions> | (() => Partial<TuiInputNumberOptions>)) => import("@angular/core").FactoryProvider;

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

@@ -0,0 +1,42 @@
+import { type MaskitoOptions } from '@maskito/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@maskito/angular";
+export declare class TuiNumberMask {
+    private readonly options;
+    private readonly numberFormat;
+    private readonly input;
+    readonly prefix: import("@angular/core").InputSignal<string>;
+    readonly postfix: import("@angular/core").InputSignal<string>;
+    readonly maximumFractionDigits: import("@angular/core").Signal<number>;
+    readonly min: import("@angular/core").InputSignalWithTransform<number | bigint, number | bigint | null>;
+    readonly max: import("@angular/core").InputSignalWithTransform<number | bigint, number | bigint | null>;
+    readonly params: import("@angular/core").Signal<{
+        readonly maximumFractionDigits: number;
+        readonly min: number | bigint;
+        readonly max: number | bigint;
+        readonly prefix: string;
+        readonly postfix: string;
+        readonly minimumFractionDigits: number;
+        readonly step: bigint | number;
+        readonly icons: Readonly<{
+            decrease: string;
+            increase: string;
+        }>;
+        readonly valueTransformer: import("@taiga-ui/cdk/classes").TuiValueTransformer<bigint | null, any> | import("@taiga-ui/cdk/classes").TuiValueTransformer<number | null, any> | null;
+        readonly minusSign: string;
+        readonly precision: number;
+        readonly decimalSeparator: import("@taiga-ui/core/tokens").TuiDecimalSymbol;
+        readonly rounding: import("@taiga-ui/cdk/types").TuiRounding;
+        readonly thousandSeparator: string;
+    }>;
+    protected readonly mask: import("@angular/core").Signal<MaskitoOptions>;
+    protected readonly maskInitialCalibration: import("@angular/core").EffectRef;
+    stringify(value: bigint | number | null | undefined): string;
+    private computeMask;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNumberMask, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNumberMask, never, never, { "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "postfix": { "alias": "postfix"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+}
+export declare class TuiWithNumberMask {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiWithNumberMask, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiWithNumberMask, never, never, {}, {}, never, never, true, [{ directive: typeof TuiNumberMask; inputs: { "min": "min"; "max": "max"; "prefix": "prefix"; "postfix": "postfix"; }; outputs: {}; }]>;
+}

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

@@ -1,21 +1,23 @@
 import { TuiValueTransformer } from '@taiga-ui/cdk/classes';
+import { identity } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiQuantumValueTransformerBase extends TuiValueTransformer<number | null, number | null> {
     quantum: number;
-    protected parent: TuiValueTransformer<number | null, any> | null;
+    fromControlValue: typeof identity;
     constructor(quantum?: number);
-    fromControlValue(controlValue: number | null): number | null;
-    toControlValue(internalValue: number | null): number | null;
+    toControlValue(value: number | null): number | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiQuantumValueTransformerBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiQuantumValueTransformerBase, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiQuantumValueTransformerBase, never, never, {}, {}, never, never, true, never>;
 }
 export declare class TuiQuantumValueTransformer extends TuiQuantumValueTransformerBase {
-    protected parent: TuiValueTransformer<number | null, any> | null;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiQuantumValueTransformer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiQuantumValueTransformer, "[tuiInputNumber][quantum]", never, { "quantum": { "alias": "quantum"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiQuantumValueTransformer, "[tuiInputNumber][quantum]:not([bigint])", never, { "quantum": { "alias": "quantum"; "required": false; }; }, {}, never, never, true, never>;
 }
-export declare class TuiWithQuantumValueTransformer {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiWithQuantumValueTransformer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiWithQuantumValueTransformer, never, never, {}, {}, never, never, true, [{ directive: typeof TuiQuantumValueTransformer; inputs: { "quantum": "quantum"; }; outputs: {}; }]>;
+export declare class TuiBigIntQuantumValueTransformer extends TuiValueTransformer<bigint | null, bigint | null> {
+    readonly quantum: import("@angular/core").InputSignal<bigint>;
+    fromControlValue: typeof identity;
+    toControlValue(value: bigint | null): bigint | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiBigIntQuantumValueTransformer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBigIntQuantumValueTransformer, "[tuiInputNumber][bigint][quantum]", never, { "quantum": { "alias": "quantum"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

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

package/components/input-number/transformers/bigint.value-transformer.d.ts

@@ -0,0 +1,11 @@
+import { TuiValueTransformer } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare class TuiBigIntValueTransformer extends TuiValueTransformer<string, bigint | null> {
+    private readonly quantumTransformer;
+    private readonly optionsTransformer;
+    private readonly mask;
+    toControlValue(textfieldValue: string | null): bigint | null;
+    fromControlValue(controlValue: bigint | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiBigIntValueTransformer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBigIntValueTransformer, "[tuiInputNumber][bigint]", never, {}, {}, never, never, true, never>;
+}

package/components/input-number/transformers/number.value-transformer.d.ts

@@ -0,0 +1,11 @@
+import { TuiValueTransformer } from '@taiga-ui/cdk/classes';
+import * as i0 from "@angular/core";
+export declare class TuiNumberValueTransformer extends TuiValueTransformer<string, number | null> {
+    private readonly mask;
+    private readonly quantumTransformer;
+    private readonly optionsTransformer;
+    toControlValue(textfieldValue: string | null): number | null;
+    fromControlValue(controlValue: number | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNumberValueTransformer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiNumberValueTransformer, never, never, {}, {}, never, never, true, never>;
+}

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

@@ -1,2 +1,3 @@
+export * from './input-phone';
 export * from './input-phone.directive';
 export * from './input-phone.options';

package/components/input-phone/input-phone.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 { TuiInputPhoneDirective } from './input-phone.directive';
+export declare const TuiInputPhone: readonly [typeof TuiInputPhoneDirective, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

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

@@ -1,27 +1,25 @@
 import { type MaskitoOptions } from '@maskito/core';
 import { TuiControl } from '@taiga-ui/cdk/classes';
 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 TuiInputPhone extends TuiControl<string | null> {
-    private readonly textfield;
+export declare class TuiInputPhoneDirective extends TuiControl<string | null> {
+    private readonly input;
     private readonly host;
+    protected readonly options: import("./input-phone.options").TuiInputPhoneOptions;
+    protected readonly el: HTMLInputElement;
     protected readonly nonRemovablePrefix: import("@angular/core").Signal<string>;
     protected inputMode: import("@angular/core").Signal<"text" | "numeric">;
     protected readonly valueEffect: import("@angular/core").EffectRef;
     protected readonly blurEffect: import("@angular/core").EffectRef;
-    protected readonly options: import("./input-phone.options").TuiInputPhoneOptions;
-    protected readonly el: HTMLInputElement;
-    protected readonly mask: import("@angular/core").Signal<MaskitoOptions>;
-    protected readonly maskito: import("@angular/core").Signal<MaskitoOptions | null>;
-    readonly countryCode: import("@angular/core").WritableSignal<string>;
-    readonly allowText: import("@angular/core").WritableSignal<boolean>;
-    readonly phoneMask: import("@angular/core").WritableSignal<string>;
-    set allowTextSetter(allow: boolean);
-    set maskSetter(mask: string);
+    protected readonly countryCode: import("@angular/core").Signal<string>;
+    protected readonly phoneMask: import("@angular/core").Signal<string>;
+    protected readonly maskito: import("@angular/core").Signal<MaskitoOptions>;
+    readonly allowText: import("@angular/core").InputSignal<boolean>;
+    readonly mask: import("@angular/core").InputSignal<string>;
     protected onInput(value: string): void;
     private get maxPhoneLength();
     private calculateMask;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhone, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputPhone, "input[tuiInputPhone]", never, { "allowTextSetter": { "alias": "allowText"; "required": false; }; "maskSetter": { "alias": "mask"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputPhoneDirective, "input[tuiInputPhone]", never, { "allowText": { "alias": "allowText"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }, { directive: typeof i2.MaskitoDirective; inputs: {}; outputs: {}; }]>;
 }

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

@@ -5,4 +5,4 @@ export interface TuiInputPhoneOptions {
     readonly valueTransformer: TuiValueTransformer<string | null, any>;
 }
 export declare const TUI_INPUT_PHONE_DEFAULT_OPTIONS: TuiInputPhoneOptions;
-export declare const TUI_INPUT_PHONE_OPTIONS: import("@angular/core").InjectionToken<TuiInputPhoneOptions>, tuiInputPhoneOptionsProvider: (item: Partial<TuiInputPhoneOptions> | import("@angular/core").ProviderToken<Partial<TuiInputPhoneOptions>> | (() => Partial<TuiInputPhoneOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_INPUT_PHONE_OPTIONS: import("@angular/core").InjectionToken<TuiInputPhoneOptions>, tuiInputPhoneOptionsProvider: (item: Partial<TuiInputPhoneOptions> | (() => Partial<TuiInputPhoneOptions>)) => import("@angular/core").FactoryProvider;

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

@@ -1,2 +1,3 @@
+export * from './input-phone-international';
 export * from './input-phone-international.component';
 export * from './input-phone-international.options';

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,80 +1,43 @@
-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';
-    protected readonly content: import("@angular/core").WritableSignal<readonly [PolymorpheusContent<TuiContext<number>>, PolymorpheusContent<TuiContext<number>>]>;
+    protected readonly size: import("@angular/core").Signal<"m" | "l" | "s">;
+    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>>>;
-    min: number;
-    max: number;
-    step: number;
-    segments: number;
-    keySteps: TuiKeySteps | null;
-    prefix: readonly [
-        string,
-        string
-    ];
-    postfix: readonly [
-        string,
-        string
-    ];
-    set quantumSetter(x: number);
-    set contentSetter(x: readonly [
-        PolymorpheusContent<TuiContext<number>>,
-        PolymorpheusContent<TuiContext<number>>
-    ]);
-    writeValue(value: [
-        number,
-        number
-    ]): void;
-    ngAfterViewInit(): void;
+    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 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 onBlur(): 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;
     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; }; "prefix": { "alias": "prefix"; "required": false; }; "postfix": { "alias": "postfix"; "required": false; }; "quantumSetter": { "alias": "quantum"; "required": false; }; "contentSetter": { "alias": "content"; "required": false; }; }, {}, never, ["label"], true, never>;
-    static ngAcceptInputType_prefix: readonly [
-        string,
-        string
-    ] | null;
-    static ngAcceptInputType_postfix: readonly [string, string] | null;
+    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

@@ -1,4 +1,4 @@
-import { TuiInputNumberDirective } from '@taiga-ui/kit/components/input-number';
+import { TuiInputNumberDirective, TuiNumberMask } from '@taiga-ui/kit/components/input-number';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/kit/components/input-number";
 export declare class TuiInputSliderDirective {
@@ -6,13 +6,13 @@ export declare class TuiInputSliderDirective {
     private readonly el;
     private readonly slider;
     private readonly controlTransformer;
-    private readonly keyStepsTransformer;
+    protected readonly nothing: undefined;
+    protected readonly mask: TuiNumberMask;
     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;
     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: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputSliderDirective, "input[tuiInputSlider]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiInputNumberDirective; inputs: { "invalid": "invalid"; "readOnly": "readOnly"; }; outputs: {}; }, { directive: typeof i1.TuiQuantumValueTransformer; inputs: { "quantum": "quantum"; }; 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];