@taiga-ui/kit 3.491.1-canary.a08581f → 4.0.0-alpha.0

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

@@ -1,26 +1,21 @@
-import { ChangeDetectorRef, ElementRef, Injector } from '@angular/core';
-import { NgControl } from '@angular/forms';
-import { TuiSizeS } from '@taiga-ui/core';
-import { TuiSliderOptions } from './slider.options';
+import type { TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiSliderComponent {
-    private readonly control;
-    readonly options: TuiSliderOptions;
-    readonly el: ElementRef<HTMLInputElement>;
-    private readonly userAgent;
     private readonly injector;
+    private readonly control;
+    protected readonly options: import("./slider.options").TuiSliderOptions;
     size: TuiSizeS;
     segments: number;
+    readonly el: HTMLInputElement;
+    constructor();
+    get valueRatio(): number;
     get min(): number;
     get max(): number;
-    get step(): number;
     get value(): number;
     set value(newValue: number);
-    get valuePercentage(): number;
-    get segmentWidth(): number;
-    get isOldEdge(): boolean;
-    get hasKeySteps(): boolean;
-    constructor(control: NgControl | null, cdr: ChangeDetectorRef, options: TuiSliderOptions, el: ElementRef<HTMLInputElement>, userAgent: string, injector: Injector);
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderComponent, [{ optional: true; self: true; }, null, null, null, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSliderComponent, "input[type=range][tuiSlider]", never, { "size": "size"; "segments": "segments"; }, {}, never, never>;
+    protected get segmentWidth(): number;
+    protected get hasKeySteps(): boolean;
+    protected get step(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSliderComponent, "input[type=range][tuiSlider]", never, { "size": { "alias": "size"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/slider/slider.d.ts

@@ -0,0 +1,5 @@
+import { TuiSliderKeySteps } from './helpers/slider-key-steps.directive';
+import { TuiSliderReadonly } from './helpers/slider-readonly.directive';
+import { TuiSliderThumbLabel } from './helpers/slider-thumb-label.component';
+import { TuiSliderComponent } from './slider.component';
+export declare const TuiSlider: readonly [typeof TuiSliderComponent, typeof TuiSliderThumbLabel, typeof TuiSliderKeySteps, typeof TuiSliderReadonly];

package/components/slider/slider.options.d.ts

@@ -1,5 +1,5 @@
-import { Provider } from '@angular/core';
-import { TuiSizeS } from '@taiga-ui/core';
+import type { Provider } from '@angular/core';
+import type { TuiSizeS } from '@taiga-ui/core/types';
 export interface TuiSliderOptions {
     readonly size: TuiSizeS;
     readonly trackColor: string;

package/components/stepper/index.d.ts

@@ -1,3 +1,3 @@
-export * from './step/step.component';
+export * from './step.component';
+export * from './stepper';
 export * from './stepper.component';
-export * from './stepper.module';

package/components/stepper/step.component.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+export declare class TuiStep {
+    private readonly stepper;
+    private readonly el;
+    private readonly routerLinkActive$;
+    protected focusVisible: boolean;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    stepState: 'error' | 'normal' | 'pass';
+    icon: string;
+    constructor();
+    protected get isActive(): boolean;
+    protected get isVertical(): boolean;
+    protected get tabIndex(): number;
+    protected get index(): number;
+    protected activate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiStep, "button[tuiStep], a[tuiStep]:not([routerLink]), a[tuiStep][routerLink][routerLinkActive]", never, { "stepState": { "alias": "stepState"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/components/stepper/stepper.component.d.ts

@@ -1,28 +1,28 @@
-import { ChangeDetectorRef, ElementRef, EventEmitter } from '@angular/core';
-import { TuiScrollService } from '@taiga-ui/cdk';
-import { TuiOrientation } from '@taiga-ui/core';
-import { Observable } from 'rxjs';
+import { EventEmitter } from '@angular/core';
+import type { TuiOrientation } from '@taiga-ui/core/types';
+import type { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiStepperComponent {
+    private readonly steps;
     private readonly cdr;
     private readonly el;
     private readonly scrollService;
-    private readonly duration;
-    private readonly steps;
+    private readonly resize$;
+    private readonly speed;
+    private readonly destroyRef;
+    protected activeItemIndex: number;
     orientation: TuiOrientation;
-    set activeIndex(index: number);
     readonly activeItemIndexChange: EventEmitter<number>;
-    activeItemIndex: number;
-    constructor(cdr: ChangeDetectorRef, el: ElementRef<HTMLElement>, scrollService: TuiScrollService, resize$: Observable<void>, duration: number);
-    get changes$(): Observable<unknown>;
-    onHorizontal(event: Event, step: number): void;
-    onVertical(event: Event, step: number): void;
+    constructor();
+    set activeIndex(index: number);
     indexOf(step: HTMLElement): number;
     isActive(index: number): boolean;
     activate(index: number): void;
-    private getNativeElements;
+    protected get changes$(): Observable<unknown>;
+    protected onHorizontal(event: Event, step: number): void;
+    protected onVertical(event: Event, step: number): void;
     private moveFocus;
     private scrollIntoView;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiStepperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiStepperComponent, "tui-stepper, nav[tuiStepper]", never, { "orientation": "orientation"; "activeIndex": "activeItemIndex"; }, { "activeItemIndexChange": "activeItemIndexChange"; }, ["steps"], ["*"]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiStepperComponent, "tui-stepper, nav[tuiStepper]", never, { "orientation": { "alias": "orientation"; "required": false; }; "activeIndex": { "alias": "activeItemIndex"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, ["steps"], ["*"], true, never>;
 }

package/components/stepper/stepper.d.ts

@@ -0,0 +1,3 @@
+import { TuiStep } from './step.component';
+import { TuiStepperComponent } from './stepper.component';
+export declare const TuiStepper: readonly [typeof TuiStepperComponent, typeof TuiStep];

package/components/switch/index.d.ts

@@ -0,0 +1,2 @@
+export * from './switch.component';
+export * from './switch.options';

package/components/switch/switch.component.d.ts

@@ -0,0 +1,19 @@
+import type { DoCheck } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import type { TuiSizeS } from '@taiga-ui/core/types';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/appearance";
+import * as i2 from "@taiga-ui/cdk/directives/native-validator";
+export declare class TuiSwitch implements DoCheck {
+    private readonly appearance;
+    private readonly resolver;
+    private readonly options;
+    private readonly el;
+    protected readonly control: NgControl | null;
+    size: TuiSizeS;
+    showIcons: boolean;
+    ngDoCheck(): void;
+    protected get icon(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiSwitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiSwitch, "input[type=\"checkbox\"][tuiSwitch]", never, { "size": { "alias": "size"; "required": false; }; "showIcons": { "alias": "showIcons"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiNativeValidator; inputs: {}; outputs: {}; }]>;
+}

package/components/switch/switch.options.d.ts

@@ -0,0 +1,12 @@
+import type { Provider } from '@angular/core';
+import type { TuiStringHandler } from '@taiga-ui/cdk/types';
+import type { TuiSizeS } from '@taiga-ui/core/types';
+export interface TuiSwitchOptions {
+    readonly showIcons: boolean;
+    readonly size: TuiSizeS;
+    readonly icon: TuiStringHandler<TuiSizeS> | string;
+    readonly appearance: TuiStringHandler<HTMLInputElement>;
+}
+export declare const TUI_SWITCH_DEFAULT_OPTIONS: TuiSwitchOptions;
+export declare const TUI_SWITCH_OPTIONS: import("@angular/core").InjectionToken<TuiSwitchOptions>;
+export declare function tuiSwitchOptionsProvider(options: Partial<TuiSwitchOptions>): Provider;

package/components/tabs/index.d.ts

@@ -1,10 +1,8 @@
-export * from './tab/tab.component';
-export * from './tab/tab.providers';
+export * from './tab.directive';
+export * from './tabs';
 export * from './tabs.directive';
-export * from './tabs.module';
 export * from './tabs.options';
-export * from './tabs/tabs.component';
-export * from './tabs-vertical/tabs-vertical.component';
-export * from './tabs-with-more/tabs-with-more.component';
-export * from './tabs-with-more/tabs-with-more.providers';
-export * from './underline/underline.component';
+export * from './tabs.providers';
+export * from './tabs-horizontal.directive';
+export * from './tabs-vertical.directive';
+export * from './tabs-with-more.component';

package/components/tabs/tab.directive.d.ts

@@ -0,0 +1,13 @@
+import type { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/icons";
+export declare const TUI_TAB_ACTIVATE = "tui-tab-activate";
+export declare class TuiTab implements OnDestroy {
+    private readonly el;
+    private readonly rla;
+    private readonly observer;
+    protected readonly sub: import("rxjs").Subscription;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTab, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTab, "a[tuiTab]:not([routerLink]), a[tuiTab][routerLink][routerLinkActive], button[tuiTab]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+}

package/components/tabs/tabs-horizontal.directive.d.ts

@@ -0,0 +1,17 @@
+import type { AfterViewChecked, QueryList } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./tabs.directive";
+export declare class TuiTabsHorizontal implements AfterViewChecked {
+    private readonly el;
+    private readonly options;
+    private readonly tabs;
+    protected readonly children: QueryList<unknown>;
+    protected readonly sub: import("rxjs").Subscription;
+    underline: string | boolean;
+    ngAfterViewChecked(): void;
+    protected onKeyDownArrow(current: HTMLElement, step: number): void;
+    protected refresh(): void;
+    private scrollTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsHorizontal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsHorizontal, "tui-tabs:not([vertical]), nav[tuiTabs]:not([vertical])", never, { "underline": { "alias": "underline"; "required": false; }; }, {}, ["children"], never, true, [{ directive: typeof i1.TuiTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
+}

package/components/tabs/tabs-vertical.directive.d.ts

@@ -0,0 +1,10 @@
+import type { TuiHorizontalDirection } from '@taiga-ui/core/types';
+import * as i0 from "@angular/core";
+import * as i1 from "./tabs.directive";
+export declare class TuiTabsVertical {
+    private readonly tabs;
+    vertical: TuiHorizontalDirection;
+    protected onKeyDownArrow(current: HTMLElement, step: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsVertical, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsVertical, "tui-tabs[vertical], nav[tuiTabs][vertical]", never, { "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
+}

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

@@ -0,0 +1,50 @@
+import type { AfterViewChecked, AfterViewInit, QueryList } from '@angular/core';
+import { EventEmitter, TemplateRef } from '@angular/core';
+import type { TuiActiveZone } from '@taiga-ui/cdk/directives/active-zone';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { TuiSizeL } from '@taiga-ui/core/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export declare class TuiTabsWithMore implements AfterViewChecked, AfterViewInit {
+    private readonly moreButton?;
+    private readonly dir?;
+    private readonly options;
+    private readonly refresh$;
+    private readonly el;
+    private readonly cdr;
+    private maxIndex;
+    protected readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
+    protected readonly moreWord$: import("rxjs").Observable<string>;
+    protected open: boolean;
+    size: TuiSizeL;
+    moreContent: PolymorpheusContent;
+    dropdownContent: PolymorpheusContent<TuiContext<TuiActiveZone>>;
+    underline: string | boolean;
+    itemsLimit: number;
+    readonly activeItemIndexChange: EventEmitter<number>;
+    activeItemIndex: number;
+    set itemIndex(activeItemIndex: number);
+    get lastVisibleIndex(): number;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    protected get tabs(): readonly HTMLElement[];
+    protected get activeElement(): HTMLElement | null;
+    protected get isMoreAlone(): boolean;
+    protected get isMoreVisible(): boolean;
+    protected get isMoreFocusable(): boolean;
+    protected get isMoreActive(): boolean;
+    protected onActiveItemIndexChange(activeItemIndex: number): void;
+    protected onClick(index: number): void;
+    protected onArrowRight(event: Event): void;
+    protected onArrowLeft(): void;
+    protected onWrapperArrow(event: Event, wrapper: HTMLElement, previous: boolean): void;
+    protected isOverflown(index: number): boolean;
+    protected shouldShow(index: number): boolean;
+    private get margin();
+    private focusMore;
+    private getMaxIndex;
+    private updateActiveItemIndex;
+    private refresh;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsWithMore, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTabsWithMore, "tui-tabs-with-more, nav[tuiTabsWithMore]", never, { "size": { "alias": "size"; "required": false; }; "moreContent": { "alias": "moreContent"; "required": false; }; "dropdownContent": { "alias": "dropdownContent"; "required": false; }; "underline": { "alias": "underline"; "required": false; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; }; "itemIndex": { "alias": "activeItemIndex"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, ["items"], never, true, never>;
+}

package/components/tabs/tabs.d.ts

@@ -0,0 +1,7 @@
+import { TuiItem } from '@taiga-ui/cdk/directives/item';
+import { TuiTab } from './tab.directive';
+import { TuiTabsDirective } from './tabs.directive';
+import { TuiTabsHorizontal } from './tabs-horizontal.directive';
+import { TuiTabsVertical } from './tabs-vertical.directive';
+import { TuiTabsWithMore } from './tabs-with-more.component';
+export declare const TuiTabs: readonly [typeof TuiItem, typeof TuiTab, typeof TuiTabsDirective, typeof TuiTabsHorizontal, typeof TuiTabsVertical, typeof TuiTabsWithMore];

package/components/tabs/tabs.directive.d.ts

@@ -1,15 +1,20 @@
-import { AfterViewChecked, ElementRef, EventEmitter } from '@angular/core';
+import type { AfterViewChecked } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import type { TuiSizeL } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiTabsDirective implements AfterViewChecked {
     private readonly el;
+    private readonly injector;
+    protected readonly nothing: undefined;
+    size: TuiSizeL;
     activeItemIndex: number;
     readonly activeItemIndexChange: EventEmitter<number>;
-    constructor(el: ElementRef<HTMLElement>);
     get tabs(): readonly HTMLElement[];
     get activeElement(): HTMLElement | null;
-    onActivate(event: Event, element: HTMLElement): void;
     moveFocus(current: HTMLElement, step: number): void;
     ngAfterViewChecked(): void;
+    protected onActivate(event: Event, element: HTMLElement): void;
+    protected markTabAsActive(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTabsDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsDirective, "tui-tabs, nav[tuiTabs]", never, { "activeItemIndex": "activeItemIndex"; }, { "activeItemIndexChange": "activeItemIndexChange"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTabsDirective, "tui-tabs:is(never)", never, { "size": { "alias": "size"; "required": false; }; "activeItemIndex": { "alias": "activeItemIndex"; "required": false; }; }, { "activeItemIndexChange": "activeItemIndexChange"; }, never, never, true, never>;
 }

package/components/tabs/tabs.options.d.ts

@@ -1,9 +1,11 @@
-import { Provider } from '@angular/core';
+import type { Provider } from '@angular/core';
+import type { TuiSizeL } from '@taiga-ui/core/types';
 export interface TuiTabsOptions {
     readonly exposeActive: boolean;
     readonly itemsLimit: number;
     readonly minMoreWidth: number;
-    readonly underline: boolean;
+    readonly underline: boolean | string;
+    readonly size: TuiSizeL;
 }
 export declare const TUI_TABS_DEFAULT_OPTIONS: TuiTabsOptions;
 /**

package/components/tabs/tabs.providers.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { Observable } from 'rxjs';
+export declare const TUI_TABS_REFRESH: InjectionToken<Observable<unknown>>;
+export declare const TUI_TABS_PROVIDERS: Provider[];

package/components/tiles/index.d.ts

@@ -1,5 +1,5 @@
 export * from './tile.component';
 export * from './tile.service';
 export * from './tile-handle.directive';
+export * from './tiles';
 export * from './tiles.component';
-export * from './tiles.module';

package/components/tiles/tile-handle.directive.d.ts

@@ -1,13 +1,11 @@
-import { TuiTileComponent } from './tile.component';
 import * as i0 from "@angular/core";
-export declare class TuiTileHandleDirective {
+export declare class TuiTileHandle {
     private readonly tile;
     private x;
     private y;
-    constructor(tile: TuiTileComponent);
-    onStart(event: PointerEvent): void;
-    onPointer(x?: number, y?: number): void;
-    onMove(x: number, y: number): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTileHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTileHandleDirective, "[tuiTileHandle]", never, {}, {}, never>;
+    protected onStart(event: PointerEvent): void;
+    protected onPointer(x?: number, y?: number): void;
+    protected onMove(x: number, y: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTileHandle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTileHandle, "[tuiTileHandle]", never, {}, {}, never, never, true, never>;
 }

package/components/tiles/tile.component.d.ts

@@ -1,24 +1,20 @@
-import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
-import { TuiTileService } from './tile.service';
-import { TuiTilesComponent } from './tiles.component';
+import type { AfterViewInit, OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class TuiTileComponent implements OnDestroy, AfterViewInit {
+export declare class TuiTile implements OnDestroy, AfterViewInit {
+    private readonly wrapper?;
     private readonly service;
-    private readonly el;
     private readonly tiles;
-    private readonly wrapper?;
+    protected dragged: boolean;
     width: number;
     height: number;
-    dragged: boolean;
-    constructor(service: TuiTileService, el: ElementRef<HTMLElement>, tiles: TuiTilesComponent);
-    get column(): string;
-    get row(): string;
-    get element(): HTMLElement;
-    onEnter(): void;
+    readonly element: HTMLElement;
     onDrag(offset: readonly [number, number]): void;
-    onTransitionEnd(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTileComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTileComponent, "tui-tile", never, { "width": "width"; "height": "height"; }, {}, never, ["*"]>;
+    protected get column(): string;
+    protected get row(): string;
+    protected onEnter(): void;
+    protected onTransitionEnd(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTile, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTile, "tui-tile", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/components/tiles/tile.service.d.ts

@@ -1,16 +1,12 @@
-import { ElementRef, OnDestroy } from '@angular/core';
-import { Observable } from 'rxjs';
-import { TuiTilesComponent } from './tiles.component';
+import type { OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiTileService implements OnDestroy {
+    private readonly isBrowser;
     private readonly el;
     private readonly tiles;
-    private readonly resize$;
-    private readonly mutation$;
     private readonly sub;
     private readonly offset$;
     private readonly position$;
-    constructor(el: ElementRef<HTMLElement>, tiles: TuiTilesComponent, resize$: Observable<unknown>, mutation$: Observable<unknown>);
     init(element: HTMLElement): void;
     setOffset(offset: readonly [number, number]): void;
     ngOnDestroy(): void;

package/components/tiles/tiles.component.d.ts

@@ -1,19 +1,17 @@
-import { ElementRef } from '@angular/core';
 import { BehaviorSubject } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiTilesComponent {
     private readonly el;
     private readonly el$;
     debounce: number;
-    set order(map: Map<number, number>);
-    get order(): Map<number, number>;
     readonly orderChange: import("rxjs").Observable<Map<number, number>>;
     element: Element | null;
     readonly order$: BehaviorSubject<Map<number, number>>;
-    constructor(el: ElementRef<Element>);
+    set order(map: Map<number, number>);
+    get order(): Map<number, number>;
     rearrange(element?: Element): void;
     private filter;
     private reorder;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTilesComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTilesComponent, "tui-tiles", never, { "debounce": "debounce"; "order": "order"; }, { "orderChange": "orderChange"; }, never, ["*"]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTilesComponent, "tui-tiles", never, { "debounce": { "alias": "debounce"; "required": false; }; "order": { "alias": "order"; "required": false; }; }, { "orderChange": "orderChange"; }, never, ["*"], true, never>;
 }

package/components/tiles/tiles.d.ts

@@ -0,0 +1,4 @@
+import { TuiTile } from './tile.component';
+import { TuiTileHandle } from './tile-handle.directive';
+import { TuiTilesComponent } from './tiles.component';
+export declare const TuiTiles: readonly [typeof TuiTilesComponent, typeof TuiTile, typeof TuiTileHandle];

package/components/tree/components/tree/tree.component.d.ts

@@ -1,22 +1,21 @@
-import { DoCheck, TrackByFunction } from '@angular/core';
-import { PolymorpheusContent } from '@tinkoff/ng-polymorpheus';
-import { TuiTreeChildrenDirective } from '../../directives/tree-children.directive';
-import { TuiTreeContext } from '../../misc/tree.interfaces';
-import { TuiTreeItemComponent } from '../tree-item/tree-item.component';
+import type { DoCheck, TrackByFunction } from '@angular/core';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { TuiTreeChildren } from '../../directives/tree-children.directive';
+import type { TuiTreeContext } from '../../misc/tree.interfaces';
+import { TuiTreeItem } from '../tree-item/tree-item.component';
 import * as i0 from "@angular/core";
 export declare class TuiTreeComponent<T> implements DoCheck {
-    readonly directive: TuiTreeChildrenDirective<T> | null;
     private readonly check$;
+    protected readonly item?: TuiTreeItem;
+    protected readonly child?: TuiTreeComponent<T>;
+    protected readonly children$: import("rxjs").Observable<readonly T[]>;
+    protected readonly directive: TuiTreeChildren<T> | null;
     value: T;
-    readonly item?: TuiTreeItemComponent;
-    readonly child?: TuiTreeComponent<T>;
-    readonly children$: import("rxjs").Observable<readonly T[]>;
-    constructor(directive: TuiTreeChildrenDirective<T> | null);
     trackBy: TrackByFunction<T>;
     content: PolymorpheusContent<TuiTreeContext<T>>;
     ngDoCheck(): void;
-    checkChanges(): void;
+    protected checkChanges(): void;
     private get handler();
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeComponent<any>, [{ optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeComponent<any>, "tui-tree[value]", never, { "value": "value"; "trackBy": "trackBy"; "content": "content"; }, {}, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeComponent<any>, "tui-tree", never, { "value": { "alias": "value"; "required": true; }; "trackBy": { "alias": "trackBy"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/tree/components/tree-item/tree-item.component.d.ts

@@ -1,21 +1,20 @@
-import { DoCheck, ElementRef } from '@angular/core';
-import { PolymorpheusContent } from '@tinkoff/ng-polymorpheus';
-import type { TuiTreeController, TuiTreeItemContext } from '../../misc/tree.interfaces';
+import type { DoCheck } from '@angular/core';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import type { TuiTreeItemContext } from '../../misc/tree.interfaces';
 import * as i0 from "@angular/core";
-export declare class TuiTreeItemComponent implements DoCheck {
+export declare class TuiTreeItem implements DoCheck {
+    private readonly nested;
     private readonly el;
     private readonly controller;
-    readonly level: number;
-    readonly content: PolymorpheusContent<TuiTreeItemContext>;
-    private readonly nested;
     private readonly change$;
-    readonly expanded$: import("rxjs").Observable<boolean>;
-    readonly attached$: import("rxjs").Observable<boolean>;
-    constructor(el: ElementRef<HTMLElement>, controller: TuiTreeController, level: number, content: PolymorpheusContent<TuiTreeItemContext>);
+    protected readonly level: number;
+    protected readonly content: PolymorpheusContent<TuiTreeItemContext>;
+    protected readonly expanded$: import("rxjs").Observable<boolean>;
+    protected readonly attached$: import("rxjs").Observable<boolean>;
     get isExpandable(): boolean;
     get isExpanded(): boolean;
     ngDoCheck(): void;
     checkChanges(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeItemComponent, "tui-tree-item", never, {}, {}, ["nested"], ["*", "tui-tree-item", "tui-tree"]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeItem, "tui-tree-item", never, {}, {}, ["nested"], ["*", "tui-tree-item", "tui-tree"], true, never>;
 }

package/components/tree/components/tree-item-content/tree-item-content.component.d.ts

@@ -1,14 +1,16 @@
-import { TuiCommonIcons } from '@taiga-ui/core';
-import type { TuiTreeController, TuiTreeItemContext } from '../../misc/tree.interfaces';
+import type { DoCheck } from '@angular/core';
+import type { TuiTreeItemContext } from '../../misc/tree.interfaces';
 import * as i0 from "@angular/core";
-export declare class TuiTreeItemContentComponent {
-    readonly icons: TuiCommonIcons;
-    readonly context: TuiTreeItemContext;
+export declare class TuiTreeItemContent implements DoCheck {
     private readonly controller;
-    constructor(icons: TuiCommonIcons, context: TuiTreeItemContext, controller: TuiTreeController);
-    get isExpanded(): boolean;
-    get isExpandable(): boolean;
-    onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeItemContentComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeItemContentComponent, "tui-tree-item-content", never, {}, {}, never, never>;
+    private readonly change$;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly context: TuiTreeItemContext;
+    protected readonly expanded$: import("rxjs").Observable<boolean>;
+    ngDoCheck(): void;
+    protected get isExpandable(): boolean;
+    protected get isExpanded(): boolean;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeItemContent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTreeItemContent, "ng-component", never, {}, {}, never, never, true, never>;
 }

package/components/tree/directives/tree-children.directive.d.ts

@@ -1,8 +1,8 @@
-import { TuiHandler } from '@taiga-ui/cdk';
+import type { TuiHandler } from '@taiga-ui/cdk/types';
 import * as i0 from "@angular/core";
-export declare class TuiTreeChildrenDirective<T> {
+export declare class TuiTreeChildren<T> {
     childrenHandler: TuiHandler<T, readonly T[]>;
     static defaultHandler<G>(item: G): readonly G[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeChildrenDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeChildrenDirective<any>, "tui-tree[childrenHandler]", never, { "childrenHandler": "childrenHandler"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeChildren<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeChildren<any>, "tui-tree[childrenHandler]", never, { "childrenHandler": { "alias": "childrenHandler"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/tree/directives/tree-controller.directive.d.ts

@@ -1,16 +1,16 @@
 import { EventEmitter } from '@angular/core';
-import { TuiTreeItemComponent } from '../components/tree-item/tree-item.component';
-import { TuiTreeAccessor, TuiTreeController } from '../misc/tree.interfaces';
+import type { TuiTreeItem } from '../components/tree-item/tree-item.component';
+import type { TuiTreeAccessor, TuiTreeController } from '../misc/tree.interfaces';
 import * as i0 from "@angular/core";
 export declare class TuiTreeControllerDirective<T> implements TuiTreeController, TuiTreeAccessor<T> {
+    protected readonly items: Map<TuiTreeItem, T>;
     fallback: boolean;
     map: Map<T, boolean>;
     readonly toggled: EventEmitter<T>;
-    readonly items: Map<TuiTreeItemComponent, T>;
-    register(item: TuiTreeItemComponent, value: T): void;
-    unregister(item: TuiTreeItemComponent): void;
-    isExpanded(item: TuiTreeItemComponent): boolean;
-    toggle(item: TuiTreeItemComponent): void;
+    register(item: TuiTreeItem, value: T): void;
+    unregister(item: TuiTreeItem): void;
+    isExpanded(item: TuiTreeItem): boolean;
+    toggle(item: TuiTreeItem): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTreeControllerDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeControllerDirective<any>, "[tuiTreeController][map]", ["tuiTreeController"], { "fallback": "tuiTreeController"; "map": "map"; }, { "toggled": "toggled"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTreeControllerDirective<any>, "[tuiTreeController][map]", ["tuiTreeController"], { "fallback": { "alias": "tuiTreeController"; "required": false; }; "map": { "alias": "map"; "required": false; }; }, { "toggled": "toggled"; }, never, never, true, never>;
 }