@taiga-ui/legacy 4.0.0-rc.1

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

@@ -0,0 +1,35 @@
+import type { TuiMonth, TuiYear } from '@taiga-ui/cdk/date-time';
+import { TuiMonthRange } from '@taiga-ui/cdk/date-time';
+import type { TuiBooleanHandler } from '@taiga-ui/cdk/types';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { TuiInputDateOptions } from '@taiga-ui/kit/tokens';
+import { AbstractTuiNullableControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import * as i0 from "@angular/core";
+export declare class TuiInputMonthRangeComponent extends AbstractTuiNullableControl<TuiMonthRange> implements TuiFocusableElementAccessor {
+    private readonly textfield?;
+    private readonly options;
+    private readonly textfieldSize;
+    protected readonly formatter: import("@taiga-ui/cdk/types").TuiHandler<TuiMonth | null, import("rxjs").Observable<string>>;
+    min: TuiMonth;
+    max: TuiMonth;
+    disabledItemHandler: TuiBooleanHandler<TuiMonth>;
+    minLength: number | null;
+    maxLength: number | null;
+    defaultActiveYear: TuiYear;
+    open: boolean;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    get focused(): boolean;
+    setDisabledState(): void;
+    computeValue(from: string | null, to: string | null): string;
+    onValueChange(value: string): void;
+    onMonthClick(month: TuiMonth): void;
+    protected get size(): TuiSizeL | TuiSizeS;
+    protected get computedDefaultActiveYear(): TuiYear;
+    protected get calendarIcon(): TuiInputDateOptions['icon'];
+    protected onOpenChange(open: boolean): void;
+    protected onActiveZone(focused: boolean): void;
+    private close;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputMonthRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputMonthRangeComponent, "tui-input-month-range", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "defaultActiveYear": { "alias": "defaultActiveYear"; "required": false; }; }, {}, never, ["*", "input"], false, never>;
+}

package/components/input-month-range/input-month-range.directive.d.ts

@@ -0,0 +1,15 @@
+import type { DoCheck } from '@angular/core';
+import { AbstractTuiTextfieldHost } from '@taiga-ui/legacy/classes';
+import type { TuiInputMonthRangeComponent } from './input-month-range.component';
+import * as i0 from "@angular/core";
+export declare class TuiInputMonthRangeDirective extends AbstractTuiTextfieldHost<TuiInputMonthRangeComponent> implements DoCheck {
+    private readonly value$;
+    private localizedValue;
+    constructor();
+    get readOnly(): boolean;
+    get value(): string;
+    ngDoCheck(): void;
+    onValueChange(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputMonthRangeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputMonthRangeDirective, "tui-input-month-range", never, {}, {}, never, never, false, never>;
+}

package/components/input-month-range/input-month-range.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-month-range.component";
+import * as i2 from "./input-month-range.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@taiga-ui/kit/components/calendar-month";
+import * as i5 from "@taiga-ui/legacy/components/primitive-textfield";
+import * as i6 from "@taiga-ui/cdk/pipes/mapper";
+import * as i7 from "@taiga-ui/legacy/directives";
+import * as i8 from "@taiga-ui/core/directives/dropdown";
+export declare class TuiInputMonthRangeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputMonthRangeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputMonthRangeModule, [typeof i1.TuiInputMonthRangeComponent, typeof i2.TuiInputMonthRangeDirective], [typeof i3.CommonModule, typeof i4.TuiCalendarMonth, typeof i5.TuiPrimitiveTextfieldModule, typeof i6.TuiMapperPipe, typeof i7.TuiTextfieldControllerModule, typeof i7.TuiLegacyDropdownOpenMonitorDirective, typeof i8.TuiDropdownOptionsDirective, typeof i8.TuiDropdownDriverDirective, typeof i8.TuiDropdownDirective, typeof i8.TuiDropdownComponent, typeof i8.TuiDropdownOpen, typeof i8.TuiDropdownPortal, typeof i8.TuiDropdownManual, typeof i8.TuiDropdownHover, typeof i8.TuiDropdownContext, typeof i8.TuiDropdownPosition, typeof i8.TuiDropdownPositionSided, typeof i8.TuiDropdownSelection], [typeof i1.TuiInputMonthRangeComponent, typeof i2.TuiInputMonthRangeDirective, typeof i5.TuiTextfieldComponent, typeof i8.TuiDropdownOptionsDirective, typeof i8.TuiDropdownDriverDirective, typeof i8.TuiDropdownDirective, typeof i8.TuiDropdownComponent, typeof i8.TuiDropdownOpen, typeof i8.TuiDropdownPortal, typeof i8.TuiDropdownManual, typeof i8.TuiDropdownHover, typeof i8.TuiDropdownContext, typeof i8.TuiDropdownPosition, typeof i8.TuiDropdownPositionSided, typeof i8.TuiDropdownSelection]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputMonthRangeModule>;
+}

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

@@ -0,0 +1,4 @@
+export * from './input-number.component';
+export * from './input-number.directive';
+export * from './input-number.module';
+export * from './input-number.options';

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

@@ -0,0 +1,56 @@
+import type { QueryList } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { MaskitoOptions } from '@maskito/core';
+import type { TuiValueTransformer } from '@taiga-ui/cdk/classes';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import { AbstractTuiNullableControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import type { TuiInputNumberOptions } from './input-number.options';
+import * as i0 from "@angular/core";
+export declare const TUI_NUMBER_VALUE_TRANSFORMER: InjectionToken<TuiValueTransformer<number | null, unknown>>;
+export declare class TuiInputNumberComponent extends AbstractTuiNullableControl<number> implements TuiFocusableElementAccessor {
+    private readonly textfield?;
+    private readonly isIOS;
+    private readonly textfieldSize;
+    private readonly options;
+    private unfinishedValue;
+    protected readonly polymorpheusValueContent: QueryList<unknown>;
+    protected readonly valueTransformer: TuiValueTransformer<number | null, unknown> | null;
+    protected numberFormat: import("@taiga-ui/core/tokens").TuiNumberFormatSettings;
+    protected readonly controller: import("@taiga-ui/legacy/directives").TuiTextfieldController;
+    protected readonly numberFormat$: import("rxjs").Subscription;
+    min: number | null;
+    max: number | null;
+    step: number;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    get focused(): boolean;
+    get inputMode(): string;
+    get calculatedMaxLength(): number;
+    get computedValue(): string;
+    onValueChange(nativeValue: string): void;
+    writeValue(value: number | null): void;
+    protected get size(): TuiSizeL | TuiSizeS;
+    protected get icons(): TuiInputNumberOptions['icons'];
+    protected get computedMin(): number;
+    protected get computedMax(): number;
+    protected get isNegativeAllowed(): boolean;
+    protected get formattedValue(): string;
+    protected get canDecrement(): boolean;
+    protected get canIncrement(): boolean;
+    protected get computedPrefix(): string;
+    protected get computedPostfix(): string;
+    protected get mask(): MaskitoOptions;
+    protected get nativeValue(): string;
+    protected set nativeValue(value: string);
+    protected onArrow(step: number | null): void;
+    protected onFocused(focused: boolean): void;
+    protected getFormattedValue(value: number): string;
+    private get isNativeValueNotFinished();
+    private get nativeNumberValue();
+    private get precision();
+    private computeMin;
+    private computeMax;
+    private calculateMask;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputNumberComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputNumberComponent, "tui-input-number", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; }, {}, ["polymorpheusValueContent"], ["*", "input", "tuiContent"], false, never>;
+}

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

@@ -0,0 +1,12 @@
+import type { DoCheck } from '@angular/core';
+import { AbstractTuiTextfieldHost } from '@taiga-ui/legacy/classes';
+import type { TuiInputNumberComponent } from './input-number.component';
+import * as i0 from "@angular/core";
+export declare class TuiInputNumberDirective extends AbstractTuiTextfieldHost<TuiInputNumberComponent> implements DoCheck {
+    protected input?: HTMLInputElement;
+    get value(): string;
+    onValueChange(value: string): void;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputNumberDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputNumberDirective, "tui-input-number", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-number.component";
+import * as i2 from "./input-number.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@maskito/angular";
+import * as i5 from "@taiga-ui/legacy/components/primitive-textfield";
+import * as i6 from "@taiga-ui/legacy/directives";
+import * as i7 from "@taiga-ui/polymorpheus";
+import * as i8 from "@taiga-ui/core/components/button";
+export declare class TuiInputNumberModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputNumberModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputNumberModule, [typeof i1.TuiInputNumberComponent, typeof i2.TuiInputNumberDirective], [typeof i3.CommonModule, typeof i4.MaskitoDirective, typeof i5.TuiPrimitiveTextfieldModule, typeof i6.TuiTextfieldControllerModule, typeof i6.TuiValueAccessorModule, typeof i7.PolymorpheusOutlet, typeof i7.PolymorpheusTemplate, typeof i8.TuiButton], [typeof i1.TuiInputNumberComponent, typeof i2.TuiInputNumberDirective, typeof i5.TuiTextfieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputNumberModule>;
+}

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

@@ -0,0 +1,17 @@
+import type { Provider } from '@angular/core';
+export interface TuiInputNumberOptions {
+    readonly icons: Readonly<{
+        down: string;
+        up: string;
+    }>;
+    readonly max: number;
+    readonly min: number;
+    readonly step: number;
+}
+/** Default values for the input number options. */
+export declare const TUI_INPUT_NUMBER_DEFAULT_OPTIONS: TuiInputNumberOptions;
+/**
+ * Default parameters for input count component
+ */
+export declare const TUI_INPUT_NUMBER_OPTIONS: import("@angular/core").InjectionToken<TuiInputNumberOptions>;
+export declare function tuiInputNumberOptionsProvider(options: Partial<TuiInputNumberOptions>): Provider;

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

@@ -0,0 +1,4 @@
+export * from './input-password.component';
+export * from './input-password.directive';
+export * from './input-password.module';
+export * from './input-password.options';

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

@@ -0,0 +1,30 @@
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import { TuiHintOptionsDirective } from '@taiga-ui/core/directives/hint';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import { AbstractTuiControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor, TuiNativeFocusableElement } from '@taiga-ui/legacy/tokens';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import type { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TuiInputPasswordComponent extends AbstractTuiControl<string> implements TuiFocusableElementAccessor {
+    private readonly textfield?;
+    private readonly textfieldSize;
+    protected readonly hintOptions: TuiHintOptionsDirective | null;
+    protected readonly directive$: Observable<any>;
+    protected isPasswordHidden: boolean;
+    protected readonly computedAppearance$: Observable<string>;
+    protected readonly passwordTexts$: Observable<[string, string]>;
+    protected readonly options: import("./input-password.options").TuiInputPasswordOptions;
+    protected readonly type: TuiContext<TuiSizeL | TuiSizeS>;
+    get nativeFocusableElement(): TuiNativeFocusableElement | null;
+    get focused(): boolean;
+    get inputType(): string;
+    onValueChange(textValue: string): void;
+    protected get size(): TuiSizeL | TuiSizeS;
+    protected get icon(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    protected onFocused(focused: boolean): void;
+    protected togglePasswordVisibility(): void;
+    protected getFallbackValue(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPasswordComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPasswordComponent, "tui-input-password", never, {}, {}, never, ["*", "input"], false, never>;
+}

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

@@ -0,0 +1,12 @@
+import type { DoCheck } from '@angular/core';
+import { AbstractTuiTextfieldHost } from '@taiga-ui/legacy/classes';
+import type { TuiInputPasswordComponent } from './input-password.component';
+import * as i0 from "@angular/core";
+export declare class TuiInputPasswordDirective extends AbstractTuiTextfieldHost<TuiInputPasswordComponent> implements DoCheck {
+    protected input?: HTMLInputElement;
+    onValueChange(value: string): void;
+    process(input: HTMLInputElement): void;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPasswordDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputPasswordDirective, "tui-input-password", never, {}, {}, never, never, false, never>;
+}

package/components/input-password/input-password.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-password.component";
+import * as i2 from "./input-password.directive";
+import * as i3 from "@taiga-ui/core/directives/hint";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "@taiga-ui/polymorpheus";
+import * as i7 from "@taiga-ui/legacy/components/primitive-textfield";
+import * as i8 from "@taiga-ui/legacy/directives";
+import * as i9 from "@taiga-ui/core/directives/appearance";
+import * as i10 from "@taiga-ui/core/components/icon";
+export declare class TuiInputPasswordModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPasswordModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputPasswordModule, [typeof i1.TuiInputPasswordComponent, typeof i2.TuiInputPasswordDirective], [typeof i3.TuiHintComponent, typeof i3.TuiHintDirective, typeof i3.TuiHintOptionsDirective, typeof i3.TuiHintUnstyled, typeof i3.TuiHintDriver, typeof i3.TuiHintPosition, typeof i3.TuiHintHover, typeof i3.TuiHintDescribe, typeof i3.TuiHintHost, typeof i3.TuiHintManual, typeof i3.TuiHintPointer, typeof i4.CommonModule, typeof i5.FormsModule, typeof i6.PolymorpheusOutlet, typeof i6.PolymorpheusTemplate, typeof i7.TuiPrimitiveTextfieldModule, typeof i8.TuiTextfieldControllerModule, typeof i9.TuiAppearance, typeof i10.TuiIcon], [typeof i1.TuiInputPasswordComponent, typeof i2.TuiInputPasswordDirective, typeof i7.TuiTextfieldComponent, typeof i3.TuiHintComponent, typeof i3.TuiHintDirective, typeof i3.TuiHintOptionsDirective, typeof i3.TuiHintUnstyled, typeof i3.TuiHintDriver, typeof i3.TuiHintPosition, typeof i3.TuiHintHover, typeof i3.TuiHintDescribe, typeof i3.TuiHintHost, typeof i3.TuiHintManual, typeof i3.TuiHintPointer]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputPasswordModule>;
+}

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

@@ -0,0 +1,13 @@
+import type { Provider } from '@angular/core';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+export interface TuiInputPasswordOptions {
+    readonly icons: Readonly<{
+        hide: PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+        show: PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    }>;
+}
+export declare const TUI_INPUT_PASSWORD_DEFAULT_OPTIONS: TuiInputPasswordOptions;
+export declare const TUI_INPUT_PASSWORD_OPTIONS: import("@angular/core").InjectionToken<TuiInputPasswordOptions>;
+export declare function tuiInputPasswordOptionsProvider(options: Partial<TuiInputPasswordOptions>): Provider;

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

@@ -0,0 +1,4 @@
+export * from './input-phone.component';
+export * from './input-phone.directive';
+export * from './input-phone.module';
+export * from './input-phone.options';

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

@@ -0,0 +1,48 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import type { MaskitoOptions } from '@maskito/core';
+import type { TuiActiveZone } from '@taiga-ui/cdk/directives/active-zone';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiDataListHost } from '@taiga-ui/core/components/data-list';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import { AbstractTuiControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import * as i0 from "@angular/core";
+export declare class TuiInputPhoneComponent extends AbstractTuiControl<string> implements TuiFocusableElementAccessor, TuiDataListHost<string> {
+    private readonly dropdown?;
+    private readonly textfield?;
+    private readonly textfieldCleaner;
+    private readonly options;
+    private readonly textfieldSize;
+    protected readonly datalist?: TemplateRef<TuiContext<TuiActiveZone>>;
+    protected open: boolean;
+    phoneMaskAfterCountryCode: string;
+    allowText: boolean;
+    search: string;
+    readonly searchChange: EventEmitter<string>;
+    countryCode: string;
+    set countryCodeSetter(newCountryCode: string);
+    get size(): TuiSizeL | TuiSizeS;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    get focused(): boolean;
+    get nativeValue(): string;
+    set nativeValue(value: string);
+    get inputMode(): string;
+    onValueChange(value: string): void;
+    handleOption(item: string): void;
+    setDisabledState(): void;
+    writeValue(value: string | null): void;
+    protected get canOpen(): boolean;
+    protected get canClean(): boolean;
+    protected get maskOptions(): MaskitoOptions;
+    protected onActiveZone(active: boolean): void;
+    protected getFallbackValue(): string;
+    private get nonRemovablePrefix();
+    private get maxPhoneLength();
+    private get isTextValue();
+    private calculateMask;
+    private focusInput;
+    private updateSearch;
+    private updateValueWithNewCountryCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPhoneComponent, "tui-input-phone", never, { "phoneMaskAfterCountryCode": { "alias": "phoneMaskAfterCountryCode"; "required": false; }; "allowText": { "alias": "allowText"; "required": false; }; "search": { "alias": "search"; "required": false; }; "countryCodeSetter": { "alias": "countryCode"; "required": false; }; }, { "searchChange": "searchChange"; }, ["datalist"], ["*", "input"], false, never>;
+}

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

@@ -0,0 +1,13 @@
+import type { DoCheck } from '@angular/core';
+import { AbstractTuiTextfieldHost } from '@taiga-ui/legacy/classes';
+import type { TuiInputPhoneComponent } from './input-phone.component';
+import * as i0 from "@angular/core";
+export declare class TuiInputPhoneDirective extends AbstractTuiTextfieldHost<TuiInputPhoneComponent> implements DoCheck {
+    protected input?: HTMLInputElement;
+    get value(): string;
+    onValueChange(value: string): void;
+    process(input: HTMLInputElement): void;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputPhoneDirective, "tui-input-phone", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-phone.component";
+import * as i2 from "./input-phone.directive";
+import * as i3 from "@maskito/angular";
+import * as i4 from "@taiga-ui/legacy/components/primitive-textfield";
+import * as i5 from "@taiga-ui/legacy/directives";
+import * as i6 from "@taiga-ui/core/directives/dropdown";
+export declare class TuiInputPhoneModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputPhoneModule, [typeof i1.TuiInputPhoneComponent, typeof i2.TuiInputPhoneDirective], [typeof i3.MaskitoDirective, typeof i4.TuiPrimitiveTextfieldModule, typeof i5.TuiTextfieldControllerModule, typeof i5.TuiValueAccessorModule, typeof i5.TuiLegacyDropdownOpenMonitorDirective, typeof i6.TuiDropdownOptionsDirective, typeof i6.TuiDropdownDriverDirective, typeof i6.TuiDropdownDirective, typeof i6.TuiDropdownComponent, typeof i6.TuiDropdownOpen, typeof i6.TuiDropdownPortal, typeof i6.TuiDropdownManual, typeof i6.TuiDropdownHover, typeof i6.TuiDropdownContext, typeof i6.TuiDropdownPosition, typeof i6.TuiDropdownPositionSided, typeof i6.TuiDropdownSelection], [typeof i1.TuiInputPhoneComponent, typeof i2.TuiInputPhoneDirective, typeof i4.TuiTextfieldComponent, typeof i6.TuiDropdownOptionsDirective, typeof i6.TuiDropdownDriverDirective, typeof i6.TuiDropdownDirective, typeof i6.TuiDropdownComponent, typeof i6.TuiDropdownOpen, typeof i6.TuiDropdownPortal, typeof i6.TuiDropdownManual, typeof i6.TuiDropdownHover, typeof i6.TuiDropdownContext, typeof i6.TuiDropdownPosition, typeof i6.TuiDropdownPositionSided, typeof i6.TuiDropdownSelection]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputPhoneModule>;
+}

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

@@ -0,0 +1,12 @@
+import type { Provider } from '@angular/core';
+export interface TuiInputPhoneOptions {
+    readonly allowText: boolean;
+    readonly countryCode: string;
+    readonly phoneMaskAfterCountryCode: string;
+}
+export declare const TUI_INPUT_PHONE_DEFAULT_OPTIONS: TuiInputPhoneOptions;
+/**
+ * Default parameters for input phone component
+ */
+export declare const TUI_INPUT_PHONE_OPTIONS: import("@angular/core").InjectionToken<TuiInputPhoneOptions>;
+export declare function tuiInputPhoneOptionsProvider(options: Partial<TuiInputPhoneOptions>): Provider;

package/components/input-phone/utils/complete-phone-insertion-preprocessor.d.ts

@@ -0,0 +1,9 @@
+import type { MaskitoPreprocessor } from '@maskito/core';
+/**
+ * `InputPhone` component sets country code as non-removable prefix.
+ * This prefix appears on focus and cannot be erased.
+ * But users sometimes can copy complete phone number (from any different source)
+ * and try to insert the whole string inside our `InputPhone` textfield.
+ * This preprocessor helps to avoid country prefix duplication on paste/drop/autofill events.
+ */
+export declare function tuiCreateCompletePhoneInsertionPreprocessor(countryCode: string, phoneMaskAfterCountryCode: string): MaskitoPreprocessor;

package/components/input-phone/utils/create-phone-mask-expression.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create {@link https://maskito.dev/core-concepts/mask-expression pattern mask expression} for phone number
+ *
+ * @example
+ * tuiCreatePhoneMaskExpression('+1', '(###) ###-####');
+ */
+export declare function tuiCreatePhoneMaskExpression(countryCode: string, phoneMaskAfterCountryCode: string): Array<RegExp | string>;

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

@@ -0,0 +1,2 @@
+export * from './complete-phone-insertion-preprocessor';
+export * from './create-phone-mask-expression';

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

@@ -0,0 +1,3 @@
+export * from './input-phone-international.component';
+export * from './input-phone-international.options';
+export * from './utils/extract-value-from-event';

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

@@ -0,0 +1,38 @@
+import { EventEmitter } from '@angular/core';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiSizeL, TuiSizeM, TuiSizeS } from '@taiga-ui/core/types';
+import type { TuiCountryIsoCode } from '@taiga-ui/i18n/enums';
+import { AbstractTuiControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class TuiInputPhoneInternationalComponent extends AbstractTuiControl<string> implements TuiFocusableElementAccessor {
+    private readonly inputPhoneComponent?;
+    private readonly primitiveTextfield?;
+    private readonly options;
+    private readonly extractCountryCodePipe;
+    private readonly textfieldSize;
+    protected open: boolean;
+    protected readonly countriesNames$: import("rxjs").Observable<Record<TuiCountryIsoCode, string>>;
+    protected readonly countriesMasks: Record<TuiCountryIsoCode, string>;
+    protected readonly arrow: PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeM | TuiSizeS>>;
+    countries: readonly TuiCountryIsoCode[];
+    readonly countryIsoCodeChange: EventEmitter<TuiCountryIsoCode>;
+    countryIsoCode: TuiCountryIsoCode;
+    set isoCode(code: TuiCountryIsoCode);
+    get nativeFocusableElement(): HTMLElement | null;
+    get focused(): boolean;
+    get inputPhoneCountryCode(): string;
+    get phoneMaskAfterCountryCode(): string;
+    onPaste(event: ClipboardEvent | DragEvent): void;
+    onItemClick(isoCode: TuiCountryIsoCode): void;
+    setDisabledState(): void;
+    protected get size(): TuiSizeL | TuiSizeS;
+    protected onActiveZone(active: boolean): void;
+    protected getFallbackValue(): string;
+    private calculateMaskAfterCountryCode;
+    private close;
+    private updateCountryIsoCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputPhoneInternationalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputPhoneInternationalComponent, "tui-input-phone-international", never, { "countries": { "alias": "countries"; "required": false; }; "isoCode": { "alias": "countryIsoCode"; "required": false; }; }, { "countryIsoCodeChange": "countryIsoCodeChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,12 @@
+import type { Provider } from '@angular/core';
+import type { TuiCountryIsoCode } from '@taiga-ui/i18n/enums';
+export interface TuiInputPhoneInternationalOptions {
+    readonly countries: readonly TuiCountryIsoCode[];
+    readonly countryIsoCode: TuiCountryIsoCode;
+}
+export declare const TUI_INPUT_PHONE_INTERNATIONAL_DEFAULT_OPTIONS: TuiInputPhoneInternationalOptions;
+/**
+ * Default parameters for input phone international component
+ */
+export declare const TUI_INPUT_PHONE_INTERNATIONAL_OPTIONS: import("@angular/core").InjectionToken<TuiInputPhoneInternationalOptions>;
+export declare function tuiInputPhoneInternationalOptionsProvider(options: Partial<TuiInputPhoneInternationalOptions>): Provider;

package/components/input-phone-international/utils/extract-value-from-event.d.ts

@@ -0,0 +1 @@
+export declare function tuiExtractValueFromEvent(event: ClipboardEvent | DragEvent): string;

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

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

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

@@ -0,0 +1,52 @@
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiKeySteps } from '@taiga-ui/kit/components/slider';
+import { AbstractTuiControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor, TuiNativeFocusableElement } from '@taiga-ui/legacy/tokens';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class TuiInputRangeComponent extends AbstractTuiControl<[number, number]> implements TuiFocusableElementAccessor {
+    private readonly inputNumberRefs;
+    private readonly range?;
+    private readonly isMobile;
+    private readonly el;
+    protected leftTextfieldValue: number;
+    protected rightTextfieldValue: number;
+    protected lastActiveSide: 'left' | 'right';
+    protected readonly controller: import("@taiga-ui/legacy/directives").TuiTextfieldController;
+    min: number;
+    max: number;
+    quantum: number;
+    steps: number;
+    segments: number;
+    keySteps: TuiKeySteps | null;
+    leftValueContent: PolymorpheusContent<TuiContext<number>>;
+    rightValueContent: PolymorpheusContent<TuiContext<number>>;
+    pluralize: Record<string, string> | null;
+    get nativeFocusableElement(): TuiNativeFocusableElement | null;
+    get focused(): boolean;
+    writeValue(value: [number, number]): void;
+    protected get leftFocusableElement(): HTMLInputElement | null;
+    protected get rightFocusableElement(): HTMLInputElement | null;
+    protected get appearance(): string;
+    protected get showLeftValueContent(): boolean;
+    protected get showRightValueContent(): boolean;
+    protected get precision(): number;
+    protected get computedSteps(): number;
+    protected get step(): number;
+    protected computeKeySteps(keySteps: TuiKeySteps | null, min: number, max: number): TuiKeySteps;
+    protected onActiveZone(active: boolean): void;
+    protected onTextInputFocused(focused: boolean): void;
+    protected changeByStep(event: Event | KeyboardEvent, [leftCoefficient, rightCoefficient]: [number, number]): void;
+    protected onInputLeft(value: number | null): void;
+    protected onInputRight(value: number | null): void;
+    protected onExternalValueUpdate(value: [number, number]): void;
+    protected focusToTextInput(): void;
+    protected onActiveThumbChange(activeThumb: 'left' | 'right'): void;
+    protected getFallbackValue(): [number, number];
+    private safelyUpdateValue;
+    private valueGuard;
+    private calibrate;
+    private updateTextfieldValues;
+    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; }; "quantum": { "alias": "quantum"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "keySteps": { "alias": "keySteps"; "required": false; }; "leftValueContent": { "alias": "leftValueContent"; "required": false; }; "rightValueContent": { "alias": "rightValueContent"; "required": false; }; "pluralize": { "alias": "pluralize"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-range.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@taiga-ui/polymorpheus";
+import * as i5 from "@taiga-ui/cdk/directives/active-zone";
+import * as i6 from "@taiga-ui/legacy/components/input-number";
+import * as i7 from "@taiga-ui/kit/components/range";
+import * as i8 from "@taiga-ui/legacy/directives";
+import * as i9 from "@taiga-ui/core/directives/number-format";
+export declare class TuiInputRangeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputRangeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputRangeModule, [typeof i1.TuiInputRangeComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.PolymorpheusOutlet, typeof i4.PolymorpheusTemplate, typeof i5.TuiActiveZone, typeof i6.TuiInputNumberModule, typeof i7.TuiRange, typeof i8.TuiWrapperModule, typeof i8.TuiTextfieldControllerModule, typeof i9.TuiNumberFormat], [typeof i1.TuiInputRangeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputRangeModule>;
+}

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

@@ -0,0 +1,2 @@
+export * from './input-slider.component';
+export * from './input-slider.module';

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

@@ -0,0 +1,38 @@
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiKeySteps } from '@taiga-ui/kit/components/slider';
+import { AbstractTuiControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor, TuiNativeFocusableElement } from '@taiga-ui/legacy/tokens';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class TuiInputSliderComponent extends AbstractTuiControl<number> implements TuiFocusableElementAccessor {
+    private readonly inputNumberRef?;
+    private readonly sliderRef?;
+    protected textfieldValue: number;
+    protected readonly controller: import("@taiga-ui/legacy/directives").TuiTextfieldController;
+    min: number;
+    max: number;
+    quantum: number;
+    steps: number;
+    segments: number;
+    keySteps: TuiKeySteps | null;
+    valueContent: PolymorpheusContent<TuiContext<number>>;
+    get nativeFocusableElement(): TuiNativeFocusableElement | null;
+    get focused(): boolean;
+    writeValue(value: number | null): void;
+    protected get prefix(): string;
+    protected get postfix(): string;
+    protected get computedSteps(): number;
+    protected get precision(): number;
+    protected get showValueContent(): boolean;
+    protected get step(): number;
+    protected computeKeySteps(keySteps: TuiKeySteps | null, min: number, max: number): TuiKeySteps;
+    protected focusTextInput(): void;
+    protected safelyUpdateValue(value: number | null): void;
+    protected onVerticalArrowKeyDown(coefficient: number): void;
+    protected onSliderChange(newValue: number): void;
+    protected onFocused(focused: boolean): void;
+    protected getFallbackValue(): number;
+    private valueGuard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputSliderComponent, "tui-input-slider", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "quantum": { "alias": "quantum"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; "keySteps": { "alias": "keySteps"; "required": false; }; "valueContent": { "alias": "valueContent"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-slider.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@taiga-ui/polymorpheus";
+import * as i5 from "@taiga-ui/legacy/components/input-number";
+import * as i6 from "@taiga-ui/core/directives/number-format";
+import * as i7 from "@taiga-ui/legacy/directives";
+import * as i8 from "@taiga-ui/kit/components/slider";
+export declare class TuiInputSliderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputSliderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputSliderModule, [typeof i1.TuiInputSliderComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.PolymorpheusOutlet, typeof i4.PolymorpheusTemplate, typeof i5.TuiInputNumberModule, typeof i6.TuiNumberFormat, typeof i7.TuiTextfieldControllerModule, typeof i8.TuiSliderComponent, typeof i8.TuiSliderThumbLabel, typeof i8.TuiSliderKeySteps, typeof i8.TuiSliderReadonly], [typeof i1.TuiInputSliderComponent, typeof i8.TuiSliderComponent, typeof i8.TuiSliderThumbLabel, typeof i8.TuiSliderKeySteps, typeof i8.TuiSliderReadonly]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputSliderModule>;
+}

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

@@ -0,0 +1,3 @@
+export * from './input-tag.component';
+export * from './input-tag.module';
+export * from './input-tag.options';