@taiga-ui/legacy 4.0.0-rc.1

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

@@ -0,0 +1,94 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import type { TuiActiveZone } from '@taiga-ui/cdk/directives/active-zone';
+import type { TuiBooleanHandler, TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiDataListHost } from '@taiga-ui/core/components/data-list';
+import { TuiHintOptionsDirective } from '@taiga-ui/core/directives/hint';
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import type { TuiStringifiableItem } from '@taiga-ui/legacy/classes';
+import { AbstractTuiMultipleControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import type { TuiStatus } from '@taiga-ui/legacy/utils';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class TuiInputTagComponent extends AbstractTuiMultipleControl<string> implements TuiFocusableElementAccessor, TuiDataListHost<string> {
+    private readonly dropdown?;
+    private readonly focusableElement?;
+    private readonly tagsContainer?;
+    private readonly tags;
+    private readonly cleanerSvg?;
+    private readonly scrollBar?;
+    private readonly el;
+    private readonly options;
+    protected readonly datalist?: TemplateRef<TuiContext<TuiActiveZone>>;
+    protected readonly errorIconTemplate?: TemplateRef<Record<string, unknown>>;
+    protected readonly hintOptions: TuiHintOptionsDirective | null;
+    protected readonly controller: import("@taiga-ui/legacy/directives").TuiTextfieldController;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected status: TuiStatus;
+    protected open: boolean;
+    separator: RegExp | string;
+    search: string | null;
+    editable: boolean;
+    tagValidator: TuiBooleanHandler<string> | TuiBooleanHandler<TuiStringifiableItem<unknown> | string>;
+    rows: number;
+    inputHidden: boolean;
+    uniqueTags: boolean;
+    maxLength: number | null;
+    placeholder: string;
+    removable: boolean;
+    /**
+     * @deprecated hack
+     */
+    pseudoOpen: boolean;
+    disabledItemHandler: TuiBooleanHandler<TuiStringifiableItem<any> | string>;
+    readonly searchChange: EventEmitter<string>;
+    set pseudoFocusedSetter(value: boolean | null);
+    get labelOutside(): boolean;
+    get size(): TuiSizeL | TuiSizeS;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    get hasValue(): boolean;
+    get hasExampleText(): boolean;
+    get hasPlaceholder(): boolean;
+    get focused(): boolean;
+    onTagEdited(value: string, index: number): void;
+    handleOption(item: string): void;
+    setDisabledState(): void;
+    protected get iconLeft(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    protected get appearance(): string;
+    protected get expandable(): boolean;
+    protected get icon(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    protected get iconCleaner(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    protected get hasCleaner(): boolean;
+    protected get hasNativeValue(): boolean;
+    protected get placeholderRaised(): boolean;
+    protected get hasRightIcons(): boolean;
+    protected get showHint(): boolean;
+    protected get canOpen(): boolean;
+    protected get computeMaxHeight(): number | null;
+    protected onFocusInOut(): void;
+    protected detectRetargetFromLabel(event: Event): void;
+    protected getLeftContent(tag: string): PolymorpheusContent;
+    protected onCleanerClick(): void;
+    protected onActiveZone(active: boolean): void;
+    protected onMouseDown(event: MouseEvent): void;
+    protected onFieldKeyDownBackspace(event: Event): void;
+    protected onFieldKeyDownArrowLeft(event: Event): void;
+    protected onFieldKeyDownEnter(): void;
+    protected onTagKeyDownArrowLeft(currentIndex: number): void;
+    protected onTagKeyDownArrowRight(currentIndex: number): void;
+    protected onInput(value: string): void;
+    protected onPaste(event: Event): void;
+    protected onDrop({ dataTransfer }: DragEvent): void;
+    protected trackByFn(_: number, tag: string): string;
+    private get lineHeight();
+    private scrollTo;
+    private filterValue;
+    private onScrollKeyDown;
+    private updateSearch;
+    private addTag;
+    private deleteLastEnabledItem;
+    private focusInput;
+    private clippedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputTagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputTagComponent, "tui-input-tag", never, { "separator": { "alias": "separator"; "required": false; }; "search": { "alias": "search"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "tagValidator": { "alias": "tagValidator"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "inputHidden": { "alias": "inputHidden"; "required": false; }; "uniqueTags": { "alias": "uniqueTags"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "pseudoOpen": { "alias": "pseudoOpen"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "pseudoFocusedSetter": { "alias": "pseudoFocused"; "required": false; }; }, { "searchChange": "searchChange"; }, ["datalist"], ["*", "tuiContent", "select"], false, never>;
+}

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

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-tag.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/hovered";
+import * as i6 from "@taiga-ui/core/components/scrollbar";
+import * as i7 from "@taiga-ui/legacy/components/tooltip";
+import * as i8 from "@taiga-ui/legacy/components/tag";
+import * as i9 from "@taiga-ui/legacy/directives";
+import * as i10 from "@taiga-ui/core/directives/appearance";
+import * as i11 from "@taiga-ui/core/components/icon";
+import * as i12 from "@taiga-ui/core/directives/dropdown";
+export declare class TuiInputTagModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputTagModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputTagModule, [typeof i1.TuiInputTagComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4.PolymorpheusOutlet, typeof i4.PolymorpheusTemplate, typeof i5.TuiHovered, typeof i6.TuiScrollbar, typeof i7.TuiTooltip, typeof i8.TuiTagModule, typeof i9.TuiWrapperModule, typeof i9.TuiLegacyDropdownOpenMonitorDirective, typeof i10.TuiAppearance, typeof i11.TuiIcon, typeof i12.TuiDropdownOptionsDirective, typeof i12.TuiDropdownDriverDirective, typeof i12.TuiDropdownDirective, typeof i12.TuiDropdownComponent, typeof i12.TuiDropdownOpen, typeof i12.TuiDropdownPortal, typeof i12.TuiDropdownManual, typeof i12.TuiDropdownHover, typeof i12.TuiDropdownContext, typeof i12.TuiDropdownPosition, typeof i12.TuiDropdownPositionSided, typeof i12.TuiDropdownSelection], [typeof i1.TuiInputTagComponent, typeof i12.TuiDropdownOptionsDirective, typeof i12.TuiDropdownDriverDirective, typeof i12.TuiDropdownDirective, typeof i12.TuiDropdownComponent, typeof i12.TuiDropdownOpen, typeof i12.TuiDropdownPortal, typeof i12.TuiDropdownManual, typeof i12.TuiDropdownHover, typeof i12.TuiDropdownContext, typeof i12.TuiDropdownPosition, typeof i12.TuiDropdownPositionSided, typeof i12.TuiDropdownSelection]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputTagModule>;
+}

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

@@ -0,0 +1,13 @@
+import type { Provider } from '@angular/core';
+import type { TuiStatus } from '@taiga-ui/legacy/utils';
+export interface TuiInputTagOptions {
+    readonly separator: RegExp | string;
+    readonly tagStatus: TuiStatus;
+    readonly uniqueTags: boolean;
+}
+export declare const TUI_INPUT_TAG_DEFAULT_OPTIONS: TuiInputTagOptions;
+/**
+ * Default parameters for InputTag component
+ */
+export declare const TUI_INPUT_TAG_OPTIONS: import("@angular/core").InjectionToken<TuiInputTagOptions>;
+export declare function tuiInputTagOptionsProvider(options: Partial<TuiInputTagOptions>): Provider;

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

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

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

@@ -0,0 +1,60 @@
+import type { MaskitoOptions } from '@maskito/core';
+import type { TuiTimeMode } from '@taiga-ui/cdk/date-time';
+import { TuiTime } from '@taiga-ui/cdk/date-time';
+import type { TuiBooleanHandler } 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 { AbstractTuiNullableControl } from '@taiga-ui/legacy/classes';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import type { Observable } from 'rxjs';
+import type { TuiInputTimeOptions } from './input-time.options';
+import * as i0 from "@angular/core";
+export declare class TuiInputTimeComponent extends AbstractTuiNullableControl<TuiTime> implements TuiFocusableElementAccessor, TuiDataListHost<TuiTime> {
+    private readonly textfield?;
+    private readonly timeTexts$;
+    private readonly options;
+    private readonly isMobile;
+    private readonly isIOS;
+    private readonly textfieldSize;
+    protected open: boolean;
+    disabledItemHandler: TuiBooleanHandler<TuiTime>;
+    items: readonly TuiTime[];
+    itemSize: TuiInputTimeOptions['itemSize'];
+    strict: boolean;
+    mode: TuiInputTimeOptions['mode'];
+    get size(): TuiSizeL | TuiSizeS;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    get focused(): boolean;
+    get computedValue(): string;
+    get nativeValue(): string;
+    set nativeValue(value: string);
+    handleOption(item: TuiTime): void;
+    writeValue(value: TuiTime | null): void;
+    onValueChange(value: string): void;
+    protected get canOpen(): boolean;
+    protected get filtered(): readonly TuiTime[];
+    protected get showNativePicker(): boolean;
+    protected get nativeDatalist(): boolean;
+    protected get maskOptions(): MaskitoOptions;
+    protected get computedSearch(): string;
+    protected get innerPseudoFocused(): boolean | null;
+    protected get icon(): TuiInputTimeOptions['icon'];
+    protected getFiller$(mode: TuiTimeMode): Observable<string>;
+    protected onClick(): void;
+    protected onFocused(focused: boolean): void;
+    protected onArrowUp(event: Event): void;
+    protected onArrowDown(event: Event): void;
+    protected onOpen(open: boolean): void;
+    private get nativePicker();
+    private calculateMask;
+    private filter;
+    private findNearestTimeFromItems;
+    private getMatch;
+    private close;
+    private processArrow;
+    private calculateShift;
+    private shiftTime;
+    private focusInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputTimeComponent, "tui-input-time", never, { "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "items": { "alias": "items"; "required": false; }; "itemSize": { "alias": "itemSize"; "required": false; }; "strict": { "alias": "strict"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,13 @@
+import type { TuiTime, TuiTimeMode } from '@taiga-ui/cdk/date-time';
+import { AbstractTuiTextfieldHost } from '@taiga-ui/legacy/classes';
+import type { TuiInputTimeComponent } from './input-time.component';
+import * as i0 from "@angular/core";
+export declare class TuiInputTimeDirective extends AbstractTuiTextfieldHost<TuiInputTimeComponent> {
+    get value(): string;
+    get mode(): TuiTimeMode;
+    get items(): readonly TuiTime[];
+    onValueChange(value: string): void;
+    process(input: HTMLInputElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputTimeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiInputTimeDirective, "tui-input-time", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-time.component";
+import * as i2 from "./native-time/native-time.component";
+import * as i3 from "./input-time.directive";
+import * as i4 from "@angular/common";
+import * as i5 from "@maskito/angular";
+import * as i6 from "@taiga-ui/legacy/components/select-option";
+import * as i7 from "@taiga-ui/legacy/components/primitive-textfield";
+import * as i8 from "@taiga-ui/legacy/directives";
+import * as i9 from "@taiga-ui/polymorpheus";
+import * as i10 from "@taiga-ui/core/components/icon";
+import * as i11 from "@taiga-ui/core/directives/appearance";
+import * as i12 from "@taiga-ui/core/directives/dropdown";
+import * as i13 from "@taiga-ui/core/components/data-list";
+export declare class TuiInputTimeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputTimeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputTimeModule, [typeof i1.TuiInputTimeComponent, typeof i2.TuiNativeTimeComponent, typeof i3.TuiInputTimeDirective], [typeof i4.CommonModule, typeof i5.MaskitoDirective, typeof i6.TuiSelectOptionModule, typeof i7.TuiPrimitiveTextfieldModule, typeof i8.TuiValueAccessorModule, typeof i8.TuiTextfieldControllerModule, typeof i9.PolymorpheusOutlet, typeof i9.PolymorpheusTemplate, typeof i8.TuiLegacyDropdownOpenMonitorDirective, typeof i10.TuiIcon, typeof i11.TuiAppearance, typeof i12.TuiDropdownOptionsDirective, typeof i12.TuiDropdownDriverDirective, typeof i12.TuiDropdownDirective, typeof i12.TuiDropdownComponent, typeof i12.TuiDropdownOpen, typeof i12.TuiDropdownPortal, typeof i12.TuiDropdownManual, typeof i12.TuiDropdownHover, typeof i12.TuiDropdownContext, typeof i12.TuiDropdownPosition, typeof i12.TuiDropdownPositionSided, typeof i12.TuiDropdownSelection, typeof i13.TuiDataListComponent, typeof i13.TuiDataListDirective, typeof i13.TuiOption, typeof i13.TuiOptGroup], [typeof i1.TuiInputTimeComponent, typeof i3.TuiInputTimeDirective, typeof i12.TuiDropdownOptionsDirective, typeof i12.TuiDropdownDriverDirective, typeof i12.TuiDropdownDirective, typeof i12.TuiDropdownComponent, typeof i12.TuiDropdownOpen, typeof i12.TuiDropdownPortal, typeof i12.TuiDropdownManual, typeof i12.TuiDropdownHover, typeof i12.TuiDropdownContext, typeof i12.TuiDropdownPosition, typeof i12.TuiDropdownPositionSided, typeof i12.TuiDropdownSelection, typeof i13.TuiDataListComponent, typeof i13.TuiDataListDirective, typeof i13.TuiOption, typeof i13.TuiOptGroup]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputTimeModule>;
+}

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

@@ -0,0 +1,20 @@
+import type { Provider } from '@angular/core';
+import type { TuiTimeMode } from '@taiga-ui/cdk/date-time';
+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 TuiInputTimeOptions {
+    readonly icon: PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeS>>;
+    readonly itemSize: TuiSizeL | TuiSizeS;
+    readonly maxValues: Record<TuiTimeFormatParts, number>;
+    readonly mode: TuiTimeMode;
+    readonly nativePicker?: boolean;
+}
+export type TuiTimeFormatParts = 'HH' | 'MM' | 'MS' | 'SS';
+export declare const MAX_TIME_VALUES: Record<TuiTimeFormatParts, number>;
+export declare const TUI_INPUT_TIME_DEFAULT_OPTIONS: TuiInputTimeOptions;
+/**
+ * Default parameters for InputTime component
+ */
+export declare const TUI_INPUT_TIME_OPTIONS: import("@angular/core").InjectionToken<TuiInputTimeOptions>;
+export declare function tuiInputTimeOptionsProvider(options: Partial<TuiInputTimeOptions>): Provider;

package/components/input-time/native-time/native-time.component.d.ts

@@ -0,0 +1,12 @@
+import type { TuiInputTimeDirective } from '../input-time.directive';
+import * as i0 from "@angular/core";
+export declare class TuiNativeTimeComponent {
+    protected readonly host: TuiInputTimeDirective;
+    protected readonly autoIdString: string;
+    protected get items(): string[];
+    protected get value(): string;
+    protected get step(): number;
+    protected onChange(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNativeTimeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiNativeTimeComponent, "input[tuiTime]", never, {}, {}, never, never, false, never>;
+}

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

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

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

@@ -0,0 +1,32 @@
+import type { MaskitoOptions } from '@maskito/core';
+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 TuiInputYearComponent extends AbstractTuiNullableControl<number> implements TuiFocusableElementAccessor {
+    private readonly textfield?;
+    private readonly options;
+    private readonly textfieldSize;
+    protected open: boolean;
+    protected readonly initialItem: number;
+    min: number | null;
+    max: number | null;
+    disabledItemHandler: TuiBooleanHandler<number>;
+    nativeValue: string;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    get focused(): boolean;
+    onValueChange(value: string): void;
+    writeValue(value: number | null): void;
+    protected get size(): TuiSizeL | TuiSizeS;
+    protected get calendarIcon(): TuiInputDateOptions['icon'];
+    protected getMaskOptions(min: number | null, max: number | null): MaskitoOptions;
+    protected onYearClick(year: number): void;
+    protected onFocused(focused: boolean): void;
+    protected onOpenChange(open: boolean): void;
+    protected toggle(): void;
+    private updateNativeValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputYearComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiInputYearComponent, "tui-input-year", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; }, {}, never, ["*", "input"], false, never>;
+}

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

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

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

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./input-year.component";
+import * as i2 from "./input-year.directive";
+import * as i3 from "@maskito/angular";
+import * as i4 from "@taiga-ui/core/directives/dropdown";
+import * as i5 from "@taiga-ui/legacy/components/primitive-textfield";
+import * as i6 from "@taiga-ui/core/components/scrollbar";
+import * as i7 from "@taiga-ui/core/components/calendar";
+import * as i8 from "@taiga-ui/legacy/directives";
+export declare class TuiInputYearModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiInputYearModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiInputYearModule, [typeof i1.TuiInputYearComponent, typeof i2.TuiInputYearDirective], [typeof i3.MaskitoDirective, typeof i4.TuiDropdownOpen, typeof i5.TuiPrimitiveTextfieldModule, typeof i6.TuiScrollbar, typeof i7.TuiCalendarYear, typeof i8.TuiTextfieldControllerModule, typeof i4.TuiDropdownOptionsDirective, typeof i4.TuiDropdownDriverDirective, typeof i4.TuiDropdownDirective, typeof i4.TuiDropdownComponent, typeof i4.TuiDropdownOpen, typeof i4.TuiDropdownPortal, typeof i4.TuiDropdownManual, typeof i4.TuiDropdownHover, typeof i4.TuiDropdownContext, typeof i4.TuiDropdownPosition, typeof i4.TuiDropdownPositionSided, typeof i4.TuiDropdownSelection], [typeof i1.TuiInputYearComponent, typeof i2.TuiInputYearDirective, typeof i5.TuiTextfieldComponent, typeof i4.TuiDropdownOptionsDirective, typeof i4.TuiDropdownDriverDirective, typeof i4.TuiDropdownDirective, typeof i4.TuiDropdownComponent, typeof i4.TuiDropdownOpen, typeof i4.TuiDropdownPortal, typeof i4.TuiDropdownManual, typeof i4.TuiDropdownHover, typeof i4.TuiDropdownContext, typeof i4.TuiDropdownPosition, typeof i4.TuiDropdownPositionSided, typeof i4.TuiDropdownSelection]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiInputYearModule>;
+}

package/components/island/index.d.ts

@@ -0,0 +1 @@
+export * from './island.directive';

package/components/island/island.directive.d.ts

@@ -0,0 +1,16 @@
+import type { TuiSizeL, TuiSizeS } from '@taiga-ui/core/types';
+import * as i0 from "@angular/core";
+export declare class TuiIslandDirective {
+    size: TuiSizeL | TuiSizeS;
+    textAlign: 'center' | 'left' | 'right';
+    hoverable: boolean;
+    transparent: boolean;
+    protected get sizeS(): boolean;
+    protected get sizeM(): boolean;
+    protected get sizeL(): boolean;
+    protected get textAlignLeft(): boolean;
+    protected get textAlignCenter(): boolean;
+    protected get textAlignRight(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiIslandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiIslandDirective, "tui-island, a[tuiIsland]", never, { "size": { "alias": "size"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "hoverable": { "alias": "hoverable"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; }, {}, never, never, true, never>;
+}

package/components/multi-select/hide-selected.pipe.d.ts

@@ -0,0 +1,11 @@
+import type { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TuiHideSelectedPipe implements PipeTransform {
+    private readonly component;
+    transform<T>(items: readonly T[] | null): readonly T[] | null;
+    transform<T>(items: ReadonlyArray<readonly T[]> | null): ReadonlyArray<readonly T[]> | null;
+    private filter2d;
+    private filter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiHideSelectedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TuiHideSelectedPipe, "tuiHideSelected", false>;
+}

package/components/multi-select/index.d.ts

@@ -0,0 +1,10 @@
+export * from './hide-selected.pipe';
+export * from './multi-select.component';
+export * from './multi-select.directive';
+export * from './multi-select.module';
+export * from './multi-select.options';
+export * from './multi-select-group/multi-select-group.component';
+export * from './multi-select-group/multi-select-group.directive';
+export * from './native-multi-select/native-multi-select';
+export * from './native-multi-select/native-multi-select.component';
+export * from './native-multi-select/native-multi-select-group.component';

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

@@ -0,0 +1,23 @@
+import type { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class TuiMultiSelectGroupComponent<T> {
+    private readonly options;
+    private readonly host;
+    private readonly control;
+    protected readonly multiSelectTexts$: Observable<{
+        all: string;
+        none: string;
+    }>;
+    label: string;
+    protected get empty$(): Observable<boolean>;
+    protected get disabled$(): Observable<boolean>;
+    protected get value$(): Observable<boolean | null>;
+    protected onClick(checked: boolean | null): void;
+    private get items$();
+    private get valueChanges$();
+    private get values();
+    private get matcher();
+    private filter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectGroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiMultiSelectGroupComponent<any>, "tui-opt-group[tuiMultiSelectGroup]", never, { "label": { "alias": "label"; "required": false; }; }, {}, ["options"], ["*"], false, never>;
+}

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

@@ -0,0 +1,8 @@
+import { TuiMultiSelectOptionComponent } from '@taiga-ui/legacy/components/multi-select-option';
+import { PolymorpheusComponent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare const TUI_MULTI_SELECT_OPTION: PolymorpheusComponent<TuiMultiSelectOptionComponent<any[]>>;
+export declare class TuiMultiSelectGroupDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiMultiSelectGroupDirective, "[tuiMultiSelectGroup]", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,65 @@
+import { EventEmitter } from '@angular/core';
+import type { TuiActiveZone } from '@taiga-ui/cdk/directives/active-zone';
+import type { TuiBooleanHandler, TuiContext, TuiMapper, TuiStringHandler } from '@taiga-ui/cdk/types';
+import type { TuiDataListHost } from '@taiga-ui/core/components/data-list';
+import type { TuiSizeL, TuiSizeM, TuiSizeS } from '@taiga-ui/core/types';
+import type { TuiItemsHandlers } from '@taiga-ui/kit/tokens';
+import { AbstractTuiMultipleControl, TuiStringifiableItem } from '@taiga-ui/legacy/classes';
+import { TuiInputTagComponent } from '@taiga-ui/legacy/components/input-tag';
+import type { TuiFocusableElementAccessor } from '@taiga-ui/legacy/tokens';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import type { TuiMultiSelectOptions } from './multi-select.options';
+import * as i0 from "@angular/core";
+export declare class TuiMultiSelectComponent<T> extends AbstractTuiMultipleControl<T> implements TuiFocusableElementAccessor, TuiDataListHost<T> {
+    private readonly accessor?;
+    private readonly nativeSelect?;
+    private readonly dropdown?;
+    private readonly input?;
+    private readonly arrowMode;
+    private readonly itemsHandlers;
+    private readonly options;
+    protected readonly datalist: PolymorpheusContent<TuiContext<TuiActiveZone>>;
+    protected open: boolean;
+    protected readonly controller: import("@taiga-ui/legacy/directives").TuiTextfieldController;
+    protected readonly isMobile: boolean;
+    stringify: TuiItemsHandlers<T>['stringify'];
+    identityMatcher: TuiItemsHandlers<T>['identityMatcher'];
+    search: string | null;
+    placeholder: string;
+    editable: boolean;
+    disabledItemHandler: TuiItemsHandlers<T>['disabledItemHandler'];
+    valueContent: TuiMultiSelectOptions<T>['valueContent'];
+    tagValidator: TuiBooleanHandler<T>;
+    rows: TuiMultiSelectOptions<T>['rows'];
+    readonly searchChange: EventEmitter<string | null>;
+    get size(): TuiSizeL | TuiSizeS;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    get focused(): boolean;
+    onValueChange(value: readonly T[]): void;
+    onSearch(search: string | null): void;
+    setDisabledState(): void;
+    handleOption(option: T): void;
+    protected get arrow(): PolymorpheusContent<TuiContext<TuiSizeL | TuiSizeM | TuiSizeS>>;
+    protected get nativeDropdownMode(): boolean;
+    protected get computedValue(): readonly T[];
+    protected get searchOrSpace(): string;
+    protected get searchString(): string;
+    protected get computedGroup(): boolean;
+    protected getStringifier(stringify: TuiStringHandler<T>): TuiStringHandler<TuiContext<T>>;
+    protected readonly valueMapper: TuiMapper<[
+        readonly T[],
+        TuiStringHandler<T>,
+        boolean?
+    ], ReadonlyArray<TuiStringifiableItem<T>>>;
+    protected readonly disabledItemHandlerWrapper: TuiMapper<[
+        TuiBooleanHandler<T>
+    ], TuiBooleanHandler<TuiStringifiableItem<T> | string>>;
+    protected onSpace(event: Event): void;
+    protected onEnter(event: Event): void;
+    protected onClick({ nativeFocusableElement }: TuiInputTagComponent): void;
+    protected onInput(value: ReadonlyArray<TuiStringifiableItem<T>>): void;
+    protected onActiveZone(active: boolean): void;
+    private updateSearch;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiMultiSelectComponent<any>, "tui-multi-select", never, { "stringify": { "alias": "stringify"; "required": false; }; "identityMatcher": { "alias": "identityMatcher"; "required": false; }; "search": { "alias": "search"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "valueContent": { "alias": "valueContent"; "required": false; }; "tagValidator": { "alias": "tagValidator"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; }, { "searchChange": "searchChange"; }, ["accessor", "nativeSelect", "datalist"], ["*", "select"], false, never>;
+}

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

@@ -0,0 +1,14 @@
+import type { TuiBooleanHandler } from '@taiga-ui/cdk/types';
+import type { TuiItemsHandlers } from '@taiga-ui/kit/tokens';
+import { AbstractTuiTextfieldHost } from '@taiga-ui/legacy/classes';
+import type { TuiMultiSelectComponent } from './multi-select.component';
+import * as i0 from "@angular/core";
+export declare class TuiMultiSelectDirective<T = string> extends AbstractTuiTextfieldHost<TuiMultiSelectComponent<T>> {
+    get readOnly(): boolean;
+    get stringify(): TuiItemsHandlers<T>['stringify'];
+    disableItemHandler: TuiBooleanHandler<T>;
+    onValueChange(): void;
+    onSelectionChange(value: T[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiMultiSelectDirective<any>, "tui-multi-select", never, {}, {}, never, never, false, never>;
+}

package/components/multi-select/multi-select.module.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./multi-select.component";
+import * as i2 from "./multi-select-group/multi-select-group.component";
+import * as i3 from "./multi-select-group/multi-select-group.directive";
+import * as i4 from "./hide-selected.pipe";
+import * as i5 from "./native-multi-select/native-multi-select.component";
+import * as i6 from "./native-multi-select/native-multi-select-group.component";
+import * as i7 from "./multi-select.directive";
+import * as i8 from "@angular/common";
+import * as i9 from "@angular/forms";
+import * as i10 from "@taiga-ui/polymorpheus";
+import * as i11 from "@taiga-ui/legacy/directives";
+import * as i12 from "@taiga-ui/legacy/components/arrow";
+import * as i13 from "@taiga-ui/cdk/directives/let";
+import * as i14 from "@taiga-ui/cdk/pipes/mapper";
+import * as i15 from "@taiga-ui/legacy/components/input-tag";
+import * as i16 from "@taiga-ui/legacy/components/multi-select-option";
+import * as i17 from "@taiga-ui/core/components/link";
+import * as i18 from "@taiga-ui/kit/pipes/stringify-content";
+import * as i19 from "@taiga-ui/core/directives/dropdown";
+import * as i20 from "@taiga-ui/core/components/data-list";
+import * as i21 from "@taiga-ui/kit/components/data-list-wrapper";
+export declare class TuiMultiSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiMultiSelectModule, [typeof i1.TuiMultiSelectComponent, typeof i2.TuiMultiSelectGroupComponent, typeof i3.TuiMultiSelectGroupDirective, typeof i4.TuiHideSelectedPipe, typeof i5.TuiNativeMultiSelectComponent, typeof i6.TuiNativeMultiSelectGroupComponent, typeof i7.TuiMultiSelectDirective], [typeof i8.CommonModule, typeof i9.FormsModule, typeof i10.PolymorpheusOutlet, typeof i10.PolymorpheusTemplate, typeof i11.TuiWrapperModule, typeof i12.TuiArrowComponent, typeof i13.TuiLet, typeof i14.TuiMapperPipe, typeof i15.TuiInputTagModule, typeof i16.TuiMultiSelectOptionModule, typeof i14.TuiMapperPipe, typeof i17.TuiLink, typeof i11.TuiTextfieldControllerModule, typeof i18.TuiStringifyContentPipe, typeof i11.TuiLegacyDropdownOpenMonitorDirective, typeof i19.TuiDropdownOptionsDirective, typeof i19.TuiDropdownDriverDirective, typeof i19.TuiDropdownDirective, typeof i19.TuiDropdownComponent, typeof i19.TuiDropdownOpen, typeof i19.TuiDropdownPortal, typeof i19.TuiDropdownManual, typeof i19.TuiDropdownHover, typeof i19.TuiDropdownContext, typeof i19.TuiDropdownPosition, typeof i19.TuiDropdownPositionSided, typeof i19.TuiDropdownSelection, typeof i20.TuiDataListComponent, typeof i20.TuiDataListDirective, typeof i20.TuiOption, typeof i20.TuiOptGroup, typeof i21.TuiDataListWrapperComponent, typeof i21.TuiDataListGroupWrapperComponent, typeof i20.TuiDataListDirective], [typeof i1.TuiMultiSelectComponent, typeof i2.TuiMultiSelectGroupComponent, typeof i3.TuiMultiSelectGroupDirective, typeof i4.TuiHideSelectedPipe, typeof i7.TuiMultiSelectDirective, typeof i5.TuiNativeMultiSelectComponent, typeof i6.TuiNativeMultiSelectGroupComponent, typeof i19.TuiDropdownOptionsDirective, typeof i19.TuiDropdownDriverDirective, typeof i19.TuiDropdownDirective, typeof i19.TuiDropdownComponent, typeof i19.TuiDropdownOpen, typeof i19.TuiDropdownPortal, typeof i19.TuiDropdownManual, typeof i19.TuiDropdownHover, typeof i19.TuiDropdownContext, typeof i19.TuiDropdownPosition, typeof i19.TuiDropdownPositionSided, typeof i19.TuiDropdownSelection, typeof i20.TuiDataListComponent, typeof i20.TuiDataListDirective, typeof i20.TuiOption, typeof i20.TuiOptGroup, typeof i21.TuiDataListWrapperComponent, typeof i21.TuiDataListGroupWrapperComponent, typeof i20.TuiDataListDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiMultiSelectModule>;
+}

package/components/multi-select/multi-select.options.d.ts

@@ -0,0 +1,13 @@
+import type { Provider } from '@angular/core';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+export interface TuiMultiSelectOptions<T> {
+    readonly rows: number;
+    readonly valueContent: PolymorpheusContent<TuiContext<readonly T[]>>;
+}
+export declare const TUI_MULTI_SELECT_DEFAULT_OPTIONS: TuiMultiSelectOptions<unknown>;
+/**
+ * Default parameters for MultiSelect component
+ */
+export declare const TUI_MULTI_SELECT_OPTIONS: import("@angular/core").InjectionToken<TuiMultiSelectOptions<unknown>>;
+export declare function tuiMultiSelectOptionsProvider<T>(options: Partial<TuiMultiSelectOptions<T>>): Provider;

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

@@ -0,0 +1,9 @@
+import { AbstractTuiNativeMultiSelect } from './native-multi-select';
+import * as i0 from "@angular/core";
+export declare class TuiNativeMultiSelectGroupComponent<T> extends AbstractTuiNativeMultiSelect<T> {
+    items: readonly T[][] | null;
+    labels: readonly string[];
+    protected onValueChange(selectedOptions: HTMLSelectElement['selectedOptions']): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNativeMultiSelectGroupComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiNativeMultiSelectGroupComponent<any>, "select[multiple][tuiSelect][labels]", never, { "items": { "alias": "items"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,8 @@
+import { AbstractTuiNativeMultiSelect } from './native-multi-select';
+import * as i0 from "@angular/core";
+export declare class TuiNativeMultiSelectComponent<T> extends AbstractTuiNativeMultiSelect<T> {
+    items: readonly T[] | null;
+    protected onValueChange(selectedOptions: HTMLSelectElement['selectedOptions']): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiNativeMultiSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiNativeMultiSelectComponent<any>, "select[multiple][tuiSelect]:not([labels])", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,11 @@
+import type { TuiMapper } from '@taiga-ui/cdk/types';
+import type { TuiItemsHandlers } from '@taiga-ui/kit/tokens';
+import { AbstractTuiNativeSelect } from '@taiga-ui/legacy/classes';
+import type { TuiMultiSelectDirective } from '../multi-select.directive';
+import * as i0 from "@angular/core";
+export declare abstract class AbstractTuiNativeMultiSelect<T> extends AbstractTuiNativeSelect<TuiMultiSelectDirective<T>, T> {
+    protected get stringify(): TuiItemsHandlers<T>['stringify'];
+    protected selectedMapper: TuiMapper<[T, ...any[]], boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTuiNativeMultiSelect<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractTuiNativeMultiSelect<any>, never, never, {}, {}, never, never, false, never>;
+}

package/components/multi-select-option/index.d.ts

@@ -0,0 +1,2 @@
+export * from './multi-select-option.component';
+export * from './multi-select-option.module';

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

@@ -0,0 +1,9 @@
+import type { TuiSizeS } from '@taiga-ui/core/types';
+import { TuiSelectOptionComponent } from '@taiga-ui/legacy/components/select-option';
+import * as i0 from "@angular/core";
+export declare class TuiMultiSelectOptionComponent<T extends any[]> extends TuiSelectOptionComponent<T> {
+    protected get size(): TuiSizeS;
+    protected get selected(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectOptionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiMultiSelectOptionComponent<any>, "tui-multi-select-option", never, {}, {}, never, never, false, never>;
+}

package/components/multi-select-option/multi-select-option.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./multi-select-option.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@taiga-ui/kit/components/checkbox";
+export declare class TuiMultiSelectOptionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiMultiSelectOptionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiMultiSelectOptionModule, [typeof i1.TuiMultiSelectOptionComponent], [typeof i2.CommonModule, typeof i3.TuiCheckbox], [typeof i1.TuiMultiSelectOptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TuiMultiSelectOptionModule>;
+}

package/components/primitive-textfield/index.d.ts

@@ -0,0 +1,7 @@
+export * from './primitive-textfield.component';
+export * from './primitive-textfield.directive';
+export * from './primitive-textfield.module';
+export * from './primitive-textfield-options';
+export * from './primitive-textfield-types';
+export * from './textfield/textfield.component';
+export * from './value-decoration/value-decoration.component';