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

package/components/calendar-month/calendar-month.component.d.ts

@@ -1,46 +1,41 @@
 import { EventEmitter } from '@angular/core';
-import { TuiMonth, TuiMonthRange, TuiYear } from '@taiga-ui/cdk';
-import { TuiInteractiveState, TuiRangeState, TuiWithOptionalMinMax } from '@taiga-ui/core';
-import { TuiMonthContext } from '@taiga-ui/kit/interfaces';
-import { TuiBooleanHandlerWithContext } from '@taiga-ui/kit/types';
-import { Observable } from 'rxjs';
+import { TuiMonth, TuiMonthRange, TuiYear } from '@taiga-ui/cdk/date-time';
+import type { TuiBooleanHandler } from '@taiga-ui/cdk/types';
+import type { TuiRangeState } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
-export declare class TuiCalendarMonthComponent implements TuiWithOptionalMinMax<TuiMonth> {
-    readonly months$: Observable<readonly string[]>;
+export declare class TuiCalendarMonth {
+    protected isYearPickerShown: boolean;
+    protected readonly months$: import("rxjs").Observable<[string, string, string, string, string, string, string, string, string, string, string, string]>;
     value: TuiMonth | TuiMonthRange | null;
     year: TuiYear;
-    disabledItemHandler: TuiBooleanHandlerWithContext<TuiMonth, TuiMonthContext>;
+    disabledItemHandler: TuiBooleanHandler<TuiMonth>;
+    minLength: number | null;
+    maxLength: number | null;
     min: TuiMonth | null;
     max: TuiMonth | null;
     readonly monthClick: EventEmitter<TuiMonth>;
     readonly hoveredItemChange: EventEmitter<TuiMonth | null>;
     readonly yearChange: EventEmitter<TuiYear>;
-    isYearPickerShown: boolean;
     hoveredItem: TuiMonth | null;
-    pressedItem: TuiMonth | null;
-    constructor(months$: Observable<readonly string[]>);
     get isSingle(): boolean;
-    get computedMin(): TuiMonth;
-    get computedMax(): TuiMonth;
-    get previousYearDisabled(): boolean;
-    get nextYearDisabled(): boolean;
-    getItemState(item: TuiMonth): TuiInteractiveState | null;
-    getItemRange(item: TuiMonth): TuiRangeState | null;
-    getTuiMonth(monthNumber: number, yearNumber: number): TuiMonth;
-    isItemToday(item: TuiMonth): boolean;
-    isItemInsideRange(month: TuiMonth): boolean;
-    onPickerYearClick(year: TuiYear): void;
-    onItemClick(month: TuiMonth): void;
-    onYearClick(): void;
     onNextYear(): void;
     onPreviousYear(): void;
-    onItemHovered(hovered: boolean, item: TuiMonth): void;
-    onItemPressed(pressed: boolean, item: TuiMonth): void;
+    isItemInsideRange(month: TuiMonth): boolean;
+    getItemRange(item: TuiMonth): TuiRangeState | null;
+    protected get computedMin(): TuiMonth;
+    protected get computedMax(): TuiMonth;
+    protected get previousYearDisabled(): boolean;
+    protected get nextYearDisabled(): boolean;
+    protected get disabledItemHandlerWithMinMax(): TuiBooleanHandler<TuiMonth>;
+    protected getTuiMonth(monthNumber: number, yearNumber: number): TuiMonth;
+    protected isItemToday(item: TuiMonth): boolean;
+    protected onPickerYearClick(year: number): void;
+    protected onItemClick(month: TuiMonth): void;
+    protected onYearClick(): void;
+    protected onItemHovered(hovered: boolean, item: TuiMonth): void;
     private calculateDisabledItemHandlerWithMinMax;
-    private get disabledItemHandlerWithMinMax();
     private updateHoveredItem;
-    private updatePressedItem;
     private updateActiveYear;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCalendarMonthComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCalendarMonthComponent, "tui-calendar-month", never, { "value": "value"; "year": "year"; "disabledItemHandler": "disabledItemHandler"; "min": "min"; "max": "max"; }, { "monthClick": "monthClick"; "hoveredItemChange": "hoveredItemChange"; "yearChange": "yearChange"; }, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCalendarMonth, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCalendarMonth, "tui-calendar-month", never, { "value": { "alias": "value"; "required": false; }; "year": { "alias": "year"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "monthClick": "monthClick"; "hoveredItemChange": "hoveredItemChange"; "yearChange": "yearChange"; }, never, never, true, never>;
 }

package/components/calendar-month/index.d.ts

@@ -1,2 +1 @@
 export * from './calendar-month.component';
-export * from './calendar-month.module';

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

@@ -1,15 +1,23 @@
+import type { OnChanges } from '@angular/core';
 import { ChangeDetectorRef, EventEmitter } from '@angular/core';
-import { TuiBooleanHandler, TuiDay, TuiDayLike, TuiDayRange, TuiDestroyService, TuiMonth, TuiTypedMapper } from '@taiga-ui/cdk';
-import { TuiCommonIcons, TuiMarkerHandler, TuiWithOptionalMinMax } from '@taiga-ui/core';
-import { TuiDayRangePeriod } from '@taiga-ui/kit/classes';
-import { Observable } from 'rxjs';
+import type { TuiDay, TuiDayLike } from '@taiga-ui/cdk/date-time';
+import { TuiDayRange, TuiMonth } from '@taiga-ui/cdk/date-time';
+import type { TuiBooleanHandler, TuiMapper } from '@taiga-ui/cdk/types';
+import type { TuiMarkerHandler } from '@taiga-ui/core/components/calendar';
+import type { Observable } from 'rxjs';
+import type { TuiDayRangePeriod } from './day-range-period';
 import * as i0 from "@angular/core";
-export declare class TuiCalendarRangeComponent implements TuiWithOptionalMinMax<TuiDay> {
-    readonly otherDateText$: Observable<string>;
-    readonly icons: TuiCommonIcons;
+export declare class TuiCalendarRange implements OnChanges {
+    protected readonly otherDateText$: Observable<string>;
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly cdr: ChangeDetectorRef;
+    protected previousValue: TuiDayRange | null;
+    protected hoveredItem: TuiDay | null;
+    protected selectedActivePeriod: TuiDayRangePeriod | null;
+    protected readonly capsMapper: TuiMapper<[TuiDay | null, TuiDayRange | null, TuiDayLike | null, boolean], TuiDay>;
     defaultViewedMonth: TuiMonth;
     disabledItemHandler: TuiBooleanHandler<TuiDay>;
-    markerHandler: TuiMarkerHandler;
+    markerHandler: TuiMarkerHandler | null;
     items: readonly TuiDayRangePeriod[];
     min: TuiDay | null;
     max: TuiDay | null;
@@ -17,28 +25,25 @@ export declare class TuiCalendarRangeComponent implements TuiWithOptionalMinMax<
     maxLength: TuiDayLike | null;
     value: TuiDayRange | null;
     readonly valueChange: EventEmitter<TuiDayRange | null>;
-    previousValue: TuiDayRange | null;
-    readonly maxLengthMapper: TuiTypedMapper<[TuiDay, TuiDayRange | null, TuiDayLike | null, boolean], TuiDay>;
-    get computedMin(): TuiDay;
-    get computedMax(): TuiDay;
-    constructor(valueChanges: Observable<TuiDayRange | null> | null, cdr: ChangeDetectorRef, destroy$: TuiDestroyService, otherDateText$: Observable<string>, icons: TuiCommonIcons);
-    onEsc(event: KeyboardEvent): void;
-    readonly mapper: TuiTypedMapper<[
+    constructor();
+    ngOnChanges(): void;
+    protected get calculatedDisabledItemHandler(): TuiBooleanHandler<TuiDay>;
+    protected onEsc(event: KeyboardEvent): void;
+    protected readonly monthOffset: TuiMapper<[TuiMonth, number], TuiMonth>;
+    protected readonly mapper: TuiMapper<[
         readonly TuiDayRangePeriod[],
         TuiDay | null,
         TuiDay | null,
         TuiDayLike | null,
-        string?
+        string | null | undefined
     ], ReadonlyArray<TuiDayRangePeriod | string>>;
-    get calculatedDisabledItemHandler(): TuiBooleanHandler<TuiDay>;
-    get computedMonth(): TuiMonth;
-    isItemActive(item: TuiDayRangePeriod | string): boolean;
-    onRangeChange(dayRange: TuiDayRange): void;
-    onDayClick(day: TuiDay): void;
-    onItemSelect(item: TuiDayRangePeriod | string): void;
-    updateValue(value: TuiDayRange | null): void;
+    protected isItemActive(item: TuiDayRangePeriod | string): boolean;
+    protected onItemSelect(item: TuiDayRangePeriod | string): void;
+    protected onMonthChange(month: TuiMonth): void;
+    protected onDayClick(day: TuiDay): void;
+    protected updateValue(value: TuiDayRange | null): void;
     private get activePeriod();
     private calculateDisabledItemHandler;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCalendarRangeComponent, [{ optional: true; }, null, { self: true; }, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCalendarRangeComponent, "tui-calendar-range", never, { "defaultViewedMonth": "defaultViewedMonth"; "disabledItemHandler": "disabledItemHandler"; "markerHandler": "markerHandler"; "items": "items"; "min": "min"; "max": "max"; "minLength": "minLength"; "maxLength": "maxLength"; "value": "value"; }, { "valueChange": "valueChange"; }, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCalendarRange, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCalendarRange, "tui-calendar-range", never, { "defaultViewedMonth": { "alias": "defaultViewedMonth"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "markerHandler": { "alias": "markerHandler"; "required": false; }; "items": { "alias": "items"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }

package/components/calendar-range/day-caps-mapper.d.ts

@@ -0,0 +1,8 @@
+import type { TuiDay, TuiDayLike, TuiDayRange } from '@taiga-ui/cdk/date-time';
+import type { TuiMapper } from '@taiga-ui/cdk/types';
+export declare const TUI_DAY_CAPS_MAPPER: TuiMapper<[
+    TuiDay | null,
+    TuiDayRange | null,
+    TuiDayLike | null,
+    boolean
+], TuiDay>;

package/components/calendar-range/day-range-period.d.ts

@@ -0,0 +1,11 @@
+import { TuiDayRange } from '@taiga-ui/cdk/date-time';
+import type { TuiContext } from '@taiga-ui/cdk/types';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+export declare class TuiDayRangePeriod {
+    readonly range: TuiDayRange;
+    private readonly name;
+    readonly content?: PolymorpheusContent<TuiContext<TuiDayRange>>;
+    constructor(range: TuiDayRange, name: string, content?: PolymorpheusContent<TuiContext<TuiDayRange>>);
+    toString(): string;
+}
+export declare function tuiCreateDefaultDayRangePeriods(periodTitles?: [string, string, string, string, string, string]): readonly TuiDayRangePeriod[];

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

@@ -1,2 +1,3 @@
 export * from './calendar-range.component';
-export * from './calendar-range.module';
+export * from './day-caps-mapper';
+export * from './day-range-period';

package/components/carousel/carousel-autoscroll.directive.d.ts

@@ -1,8 +1,7 @@
-import { Observable } from 'rxjs';
+import { TuiCarouselDirective } from './carousel.directive';
 import * as i0 from "@angular/core";
-export declare class TuiCarouselAutoscrollDirective {
-    readonly tuiCarouselAutoscroll: Observable<unknown>;
-    constructor(tuiCarouselAutoscroll: Observable<unknown>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselAutoscrollDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselAutoscrollDirective, "[tuiCarouselAutoscroll]", never, {}, { "tuiCarouselAutoscroll": "tuiCarouselAutoscroll"; }, never>;
+export declare class TuiCarouselAutoscroll {
+    readonly tuiCarouselAutoscroll: TuiCarouselDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselAutoscroll, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselAutoscroll, "[tuiCarouselAutoscroll]", never, {}, { "tuiCarouselAutoscroll": "tuiCarouselAutoscroll"; }, never, never, true, never>;
 }

package/components/carousel/carousel-buttons.directive.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from "@angular/core";
-export declare class TuiCarouselButtonsDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselButtonsDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselButtonsDirective, "[tuiCarouselButtons]", never, {}, {}, never>;
+export declare class TuiCarouselButtons {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselButtons, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselButtons, "[tuiCarouselButtons]", never, {}, {}, never, never, true, never>;
 }

package/components/carousel/carousel-scroll.directive.d.ts

@@ -1,9 +1,7 @@
-import { ElementRef } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class TuiCarouselScrollDirective {
+export declare class TuiCarouselScroll {
     private readonly el;
     readonly tuiCarouselScroll: import("rxjs").Observable<number>;
-    constructor(el: ElementRef<HTMLElement>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselScrollDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselScrollDirective, "[tuiCarouselScroll]", never, {}, { "tuiCarouselScroll": "tuiCarouselScroll"; }, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselScroll, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselScroll, "[tuiCarouselScroll]", never, {}, { "tuiCarouselScroll": "tuiCarouselScroll"; }, never, never, true, never>;
 }

package/components/carousel/carousel.component.d.ts

@@ -1,32 +1,35 @@
-import { ChangeDetectorRef, ElementRef, EventEmitter, QueryList, TemplateRef } from '@angular/core';
-import { TuiSwipeDirection } from '@taiga-ui/cdk';
+import type { QueryList } from '@angular/core';
+import { EventEmitter, TemplateRef } from '@angular/core';
+import type { TuiSwipeDirection } from '@taiga-ui/cdk/directives/swipe';
 import * as i0 from "@angular/core";
+import * as i1 from "./carousel.directive";
 export declare class TuiCarouselComponent {
-    private readonly cdr;
     private readonly el;
+    private readonly cdr;
     private readonly isMobile;
+    private readonly directive;
     private translate;
+    protected readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
+    protected transitioned: boolean;
+    protected index: number;
     draggable: boolean;
     itemsCount: number;
-    index: number;
     readonly indexChange: EventEmitter<number>;
-    readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
-    transitioned: boolean;
-    constructor(cdr: ChangeDetectorRef, el: ElementRef<HTMLElement>, isMobile: boolean);
-    get transform(): string;
-    onTransitioned(transitioned: boolean): void;
-    getStyle(itemsCount: number): Partial<CSSStyleDeclaration>;
+    set indexSetter(index: number);
     next(): void;
     prev(): void;
-    isDisabled(index: number): boolean;
-    onIntersection({ intersectionRatio }: IntersectionObserverEntry, index: number): void;
-    onScroll(delta: number): void;
-    onPan(x: number): void;
-    onSwipe(direction: TuiSwipeDirection): void;
-    onAutoscroll(): void;
+    protected get transform(): string;
+    protected onTransitioned(transitioned: boolean): void;
+    protected getStyle(itemsCount: number): Partial<CSSStyleDeclaration>;
+    protected isDisabled(index: number): boolean;
+    protected onIntersection({ intersectionRatio }: IntersectionObserverEntry, index: number): void;
+    protected onScroll(delta: number): void;
+    protected onPan(x: number): void;
+    protected onSwipe(direction: TuiSwipeDirection): void;
+    protected onAutoscroll(): void;
     private get computedTranslate();
     private get computedDraggable();
     private updateIndex;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCarouselComponent, "tui-carousel", never, { "draggable": "draggable"; "itemsCount": "itemsCount"; "index": "index"; }, { "indexChange": "indexChange"; }, ["items"], never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCarouselComponent, "tui-carousel", never, { "draggable": { "alias": "draggable"; "required": false; }; "itemsCount": { "alias": "itemsCount"; "required": false; }; "indexSetter": { "alias": "index"; "required": false; }; }, { "indexChange": "indexChange"; }, ["items"], never, true, [{ directive: typeof i1.TuiCarouselDirective; inputs: { "duration": "duration"; }; outputs: {}; }]>;
 }

package/components/carousel/carousel.d.ts

@@ -0,0 +1,7 @@
+import { TuiItem } from '@taiga-ui/cdk/directives/item';
+import { TuiCarouselComponent } from './carousel.component';
+import { TuiCarouselDirective } from './carousel.directive';
+import { TuiCarouselAutoscroll } from './carousel-autoscroll.directive';
+import { TuiCarouselButtons } from './carousel-buttons.directive';
+import { TuiCarouselScroll } from './carousel-scroll.directive';
+export declare const TuiCarousel: readonly [typeof TuiItem, typeof TuiCarouselComponent, typeof TuiCarouselDirective, typeof TuiCarouselAutoscroll, typeof TuiCarouselButtons, typeof TuiCarouselScroll];

package/components/carousel/carousel.directive.d.ts

@@ -1,4 +1,3 @@
-import { ElementRef } from '@angular/core';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiCarouselDirective extends Observable<unknown> {
@@ -7,9 +6,8 @@ export declare class TuiCarouselDirective extends Observable<unknown> {
     private readonly duration$;
     private readonly running$;
     private readonly output$;
+    constructor();
     set duration(duration: number);
-    set index(_: number);
-    constructor(el: ElementRef<HTMLElement>, visible$: Observable<boolean>);
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselDirective, "tui-carousel", never, { "duration": "duration"; "index": "index"; }, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselDirective, "tui-carousel:is(never)", never, { "duration": { "alias": "duration"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/carousel/index.d.ts

@@ -1,6 +1,6 @@
+export * from './carousel';
 export * from './carousel.component';
 export * from './carousel.directive';
-export * from './carousel.module';
 export * from './carousel-autoscroll.directive';
 export * from './carousel-buttons.directive';
 export * from './carousel-scroll.directive';

package/components/checkbox/checkbox.component.d.ts

@@ -1,20 +1,20 @@
-import { ChangeDetectorRef } from '@angular/core';
+import type { DoCheck, OnInit } from '@angular/core';
 import { NgControl } from '@angular/forms';
-import { AbstractTuiNullableControl, TuiFocusableElementAccessor } from '@taiga-ui/cdk';
-import { TuiCheckboxOptions, TuiSizeL } from '@taiga-ui/core';
+import type { TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
-export declare class TuiCheckboxComponent extends AbstractTuiNullableControl<boolean> implements TuiFocusableElementAccessor {
+import * as i1 from "@taiga-ui/core/directives/appearance";
+import * as i2 from "@taiga-ui/cdk/directives/native-validator";
+export declare class TuiCheckbox implements OnInit, DoCheck {
+    private readonly appearance;
     private readonly options;
-    private readonly focusableElement?;
-    size: TuiSizeL;
-    constructor(control: NgControl | null, options: TuiCheckboxOptions, cdr: ChangeDetectorRef);
-    get nativeFocusableElement(): HTMLInputElement | null;
-    get focused(): boolean;
-    get computedFocusable(): boolean;
-    /** @deprecated use 'value' setter */
-    onChecked(checked: boolean): void;
-    onFocused(focused: boolean): void;
-    onFocusVisible(focusVisible: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCheckboxComponent, [{ optional: true; self: true; }, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCheckboxComponent, "tui-checkbox", never, { "size": "size"; }, {}, never, never>;
+    private readonly resolver;
+    private readonly destroyRef;
+    private readonly el;
+    size: TuiSizeS;
+    readonly control: NgControl | null;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    protected getIcon(state: 'checked' | 'indeterminate'): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCheckbox, "input[type=\"checkbox\"][tuiCheckbox]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiNativeValidator; inputs: {}; outputs: {}; }]>;
 }

package/components/checkbox/checkbox.options.d.ts

@@ -0,0 +1,14 @@
+import type { Provider } from '@angular/core';
+import type { TuiStringHandler } from '@taiga-ui/cdk/types';
+import type { TuiSizeS } from '@taiga-ui/core/types';
+export interface TuiCheckboxOptions {
+    readonly size: TuiSizeS;
+    readonly appearance: TuiStringHandler<HTMLInputElement>;
+    readonly icons: Readonly<{
+        checked: TuiStringHandler<TuiSizeS> | string;
+        indeterminate: TuiStringHandler<TuiSizeS> | string;
+    }>;
+}
+export declare const TUI_CHECKBOX_DEFAULT_OPTIONS: TuiCheckboxOptions;
+export declare const TUI_CHECKBOX_OPTIONS: import("@angular/core").InjectionToken<TuiCheckboxOptions>;
+export declare function tuiCheckboxOptionsProvider(options: Partial<TuiCheckboxOptions>): Provider;

package/components/checkbox/index.d.ts

@@ -1,2 +1,2 @@
 export * from './checkbox.component';
-export * from './checkbox.module';
+export * from './checkbox.options';

package/components/chip/chip.directive.d.ts

@@ -0,0 +1,11 @@
+import type { TuiSizeXXS } 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/core/directives/icons";
+export declare class TuiChip {
+    private readonly options;
+    protected readonly nothing: undefined;
+    size: TuiSizeXXS;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiChip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiChip, "tui-chip,[tuiChip]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+}

package/components/chip/chip.options.d.ts

@@ -0,0 +1,9 @@
+import type { Provider } from '@angular/core';
+import type { TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
+import type { TuiSizeXXS } from '@taiga-ui/core/types';
+export interface TuiChipOptions extends TuiAppearanceOptions {
+    readonly size: TuiSizeXXS;
+}
+export declare const TUI_CHIP_DEFAULT_OPTIONS: TuiChipOptions;
+export declare const TUI_CHIP_OPTIONS: import("@angular/core").InjectionToken<TuiChipOptions>;
+export declare function tuiChipOptionsProvider(options: Partial<TuiChipOptions>): Provider;

package/components/chip/index.d.ts

@@ -0,0 +1,2 @@
+export * from './chip.directive';
+export * from './chip.options';

package/components/compass/compass.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class TuiCompass {
+    degrees: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiCompass, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCompass, "tui-compass", never, { "degrees": { "alias": "degrees"; "required": false; }; }, {}, never, never, true, never>;
+}

package/components/compass/index.d.ts

@@ -0,0 +1 @@
+export * from './compass.component';

package/components/confirm/confirm.component.d.ts

@@ -0,0 +1,22 @@
+import type { TuiDialogContext } from '@taiga-ui/core/components/dialog';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
+import { PolymorpheusComponent } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+export interface TuiConfirmData {
+    readonly content?: PolymorpheusContent;
+    readonly no?: string;
+    readonly yes?: string;
+    readonly appearance?: string;
+}
+export declare class TuiConfirm {
+    private readonly isMobile;
+    protected readonly words$: import("rxjs").Observable<{
+        no: string;
+        yes: string;
+    }>;
+    protected readonly context: TuiDialogContext<boolean, TuiConfirmData | undefined>;
+    protected get appearance(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiConfirm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiConfirm, "tui-confirm", never, {}, {}, never, never, true, never>;
+}
+export declare const TUI_CONFIRM: PolymorpheusComponent<TuiConfirm>;

package/components/confirm/confirm.service.d.ts

@@ -0,0 +1,13 @@
+import type { TuiDialogOptions } from '@taiga-ui/core/components/dialog';
+import type { Observable } from 'rxjs';
+import type { TuiConfirmData } from './confirm.component';
+import * as i0 from "@angular/core";
+export declare class TuiConfirmService {
+    private readonly dialogs;
+    private dirty;
+    markAsDirty(): void;
+    markAsPristine(): void;
+    withConfirm(options: Partial<TuiDialogOptions<TuiConfirmData>>): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiConfirmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TuiConfirmService>;
+}

package/components/confirm/index.d.ts

@@ -0,0 +1,2 @@
+export * from './confirm.component';
+export * from './confirm.service';

package/components/data-list-wrapper/data-list-group-wrapper.component.d.ts

@@ -1,11 +1,8 @@
-import { TuiTextfieldSizeDirective } from '@taiga-ui/core';
-import { TuiItemsHandlers } from '@taiga-ui/kit/tokens';
-import { AbstractTuiDataListWrapper } from './data-list-wrapper';
+import { TuiDataListWrapperComponent } from './data-list-wrapper.component';
 import * as i0 from "@angular/core";
-export declare class TuiDataListGroupWrapperComponent<T> extends AbstractTuiDataListWrapper<T> {
+export declare class TuiDataListGroupWrapperComponent<T> extends TuiDataListWrapperComponent<T> {
     items: readonly T[][] | null;
     labels: readonly string[];
-    constructor(itemsHandlers: TuiItemsHandlers<T>, controller: TuiTextfieldSizeDirective | null);
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDataListGroupWrapperComponent<any>, [null, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiDataListGroupWrapperComponent<any>, "tui-data-list-wrapper[labels]", never, { "items": "items"; "labels": "labels"; }, {}, never, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDataListGroupWrapperComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiDataListGroupWrapperComponent<any>, "tui-data-list-wrapper[labels]", never, { "items": { "alias": "items"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; }, {}, never, never, true, never>;
 }

package/components/data-list-wrapper/data-list-wrapper.component.d.ts

@@ -1,10 +1,21 @@
-import { TuiTextfieldController } from '@taiga-ui/core';
-import { TuiItemsHandlers } from '@taiga-ui/kit/tokens';
-import { AbstractTuiDataListWrapper } from './data-list-wrapper';
+import type { ElementRef, QueryList } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { TuiOption } from '@taiga-ui/core/components/data-list';
+import type { TuiValueContentContext } from '@taiga-ui/core/types';
+import type { TuiItemsHandlers } from '@taiga-ui/kit/tokens';
+import type { PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
-export declare class TuiDataListWrapperComponent<T> extends AbstractTuiDataListWrapper<T> {
+export declare class TuiDataListWrapperComponent<T> {
+    private readonly itemsHandlers;
+    protected readonly optionsQuery: QueryList<TuiOption<T>>;
     items: readonly T[] | null;
-    constructor(itemsHandlers: TuiItemsHandlers<T>, controller: TuiTextfieldController | null);
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDataListWrapperComponent<any>, [null, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiDataListWrapperComponent<any>, "tui-data-list-wrapper:not([labels])", never, { "items": "items"; }, {}, never, never>;
+    disabledItemHandler: TuiItemsHandlers<T>['disabledItemHandler'];
+    emptyContent: PolymorpheusContent;
+    size: "m" | "l" | "s";
+    readonly itemClick: EventEmitter<T>;
+    itemContent: PolymorpheusContent<TuiValueContentContext<T>>;
+    getContext($implicit: T, { nativeElement }: ElementRef<HTMLElement>): TuiValueContentContext<T>;
+    getOptions(includeDisabled?: boolean): readonly T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDataListWrapperComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiDataListWrapperComponent<any>, "tui-data-list-wrapper:not([labels])", never, { "items": { "alias": "items"; "required": false; }; "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; }; "emptyContent": { "alias": "emptyContent"; "required": false; }; "size": { "alias": "size"; "required": false; }; "itemContent": { "alias": "itemContent"; "required": false; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
 }

package/components/data-list-wrapper/data-list-wrapper.module.d.ts

@@ -1,12 +1,4 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./data-list-wrapper.component";
-import * as i2 from "./data-list-group-wrapper.component";
-import * as i3 from "@angular/common";
-import * as i4 from "@tinkoff/ng-polymorpheus";
-import * as i5 from "@taiga-ui/cdk";
-import * as i6 from "@taiga-ui/core";
-export declare class TuiDataListWrapperModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiDataListWrapperModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<TuiDataListWrapperModule, [typeof i1.TuiDataListWrapperComponent, typeof i2.TuiDataListGroupWrapperComponent], [typeof i3.CommonModule, typeof i4.PolymorpheusModule, typeof i5.TuiElementModule, typeof i6.TuiDataListModule, typeof i6.TuiLoaderModule], [typeof i1.TuiDataListWrapperComponent, typeof i2.TuiDataListGroupWrapperComponent, typeof i6.TuiDataListDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<TuiDataListWrapperModule>;
-}
+import { TuiDataListDirective } from '@taiga-ui/core/components/data-list';
+import { TuiDataListGroupWrapperComponent } from './data-list-group-wrapper.component';
+import { TuiDataListWrapperComponent } from './data-list-wrapper.component';
+export declare const TuiDataListWrapper: readonly [typeof TuiDataListWrapperComponent, typeof TuiDataListGroupWrapperComponent, typeof TuiDataListDirective];

package/components/data-list-wrapper/index.d.ts

@@ -1,4 +1,3 @@
 export * from './data-list-group-wrapper.component';
-export * from './data-list-wrapper';
 export * from './data-list-wrapper.component';
 export * from './data-list-wrapper.module';

package/components/elastic-container/elastic-container.component.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from "@angular/core";
-export declare class TuiElasticContainerComponent {
-    height: number;
-    transitions: number;
-    onAnimation(_name: string, count: number): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiElasticContainerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiElasticContainerComponent, "tui-elastic-container", never, {}, {}, never, ["*"]>;
+export declare class TuiElasticContainer {
+    protected height: number;
+    protected transitions: number;
+    protected onAnimation(_name: string, count: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiElasticContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiElasticContainer, "tui-elastic-container", never, {}, {}, never, ["*"], true, never>;
 }

package/components/elastic-container/elastic-container.directive.d.ts

@@ -1,12 +1,9 @@
-import { ElementRef } from '@angular/core';
-import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class TuiElasticContainerDirective {
     private readonly el;
     private readonly resize$;
     private readonly mutation$;
-    readonly tuiElasticContainer: Observable<number>;
-    constructor(el: ElementRef<HTMLElement>, resize$: Observable<unknown>, mutation$: Observable<unknown>);
+    readonly tuiElasticContainer: import("rxjs").Observable<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiElasticContainerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiElasticContainerDirective, "[tuiElasticContainer]", never, {}, { "tuiElasticContainer": "tuiElasticContainer"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiElasticContainerDirective, "[tuiElasticContainer]", never, {}, { "tuiElasticContainer": "tuiElasticContainer"; }, never, never, true, never>;
 }

package/components/elastic-container/index.d.ts

@@ -1,3 +1,2 @@
 export * from './elastic-container.component';
 export * from './elastic-container.directive';
-export * from './elastic-container.module';