@taiga-ui/kit 4.52.0-canary.216e347 → 4.52.0-canary.217a686

package/README.md

@@ -14,7 +14,7 @@ consisting of multiple base libraries and several add-ons
 
 ## How to install
 
-```
+```bash
 npm i @taiga-ui/{cdk,core,kit}
 ```
 

package/components/accordion/accordion.component.d.ts

@@ -0,0 +1,13 @@
+import { TuiExpand } from '@taiga-ui/core/components/expand';
+import { TuiAccordionDirective } from './accordion.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/group";
+export declare class TuiAccordionComponent {
+    protected readonly expands: import("@angular/core").Signal<readonly TuiExpand[]>;
+    protected readonly directives: import("@angular/core").Signal<readonly TuiAccordionDirective[]>;
+    readonly closeOthers: import("@angular/core").InputSignal<boolean>;
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "l">;
+    toggle(directive: TuiAccordionDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAccordionComponent, "tui-accordion", never, { "closeOthers": { "alias": "closeOthers"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["expands", "directives"], ["*"], true, [{ directive: typeof i1.TuiGroup; inputs: {}; outputs: {}; }]>;
+}

package/components/accordion/accordion.d.ts

@@ -1,5 +1,5 @@
+import { TuiItem } from '@taiga-ui/cdk/directives/item';
+import { TuiExpand } from '@taiga-ui/core/components/expand';
+import { TuiAccordionComponent } from './accordion.component';
 import { TuiAccordionDirective } from './accordion.directive';
-import { TuiAccordionItem } from './accordion-item.component';
-import { TuiAccordionItemContent } from './accordion-item-content.directive';
-import { TuiAccordionItemEagerContent } from './accordion-item-eager-content.directive';
-export declare const TuiAccordion: readonly [typeof TuiAccordionItem, typeof TuiAccordionDirective, typeof TuiAccordionItemContent, typeof TuiAccordionItemEagerContent];
+export declare const TuiAccordion: readonly [typeof TuiAccordionComponent, typeof TuiAccordionDirective, typeof TuiExpand, typeof TuiItem];

package/components/accordion/accordion.directive.d.ts

@@ -1,13 +1,14 @@
-import { type AfterContentInit, type QueryList } from '@angular/core';
-import { TuiAccordionItem } from './accordion-item.component';
+import { type OnChanges } from '@angular/core';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/directives/group";
-export declare class TuiAccordionDirective implements AfterContentInit {
-    private readonly destroyRef;
-    protected readonly accordionItems: QueryList<TuiAccordionItem>;
-    closeOthers: boolean;
-    constructor();
-    ngAfterContentInit(): void;
+import * as i1 from "@taiga-ui/core/components/button";
+import * as i2 from "@taiga-ui/kit/directives/chevron";
+export declare class TuiAccordionDirective implements OnChanges {
+    private readonly accordion;
+    readonly open: import("@angular/core").ModelSignal<boolean | "">;
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "l">;
+    readonly chevron: import("@angular/core").ModelSignal<boolean | "">;
+    ngOnChanges(): void;
+    toggle(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAccordionDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAccordionDirective, "tui-accordion", never, { "closeOthers": { "alias": "closeOthers"; "required": false; }; }, {}, ["accordionItems"], never, true, [{ directive: typeof i1.TuiGroup; inputs: { "rounded": "rounded"; }; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAccordionDirective, "button[tuiAccordion]", never, { "open": { "alias": "tuiAccordion"; "required": false; "isSignal": true; }; }, { "open": "tuiAccordionChange"; }, never, never, true, [{ directive: typeof i1.TuiButton; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiChevron; inputs: {}; outputs: {}; }]>;
 }

package/components/accordion/index.d.ts

@@ -1,5 +1,3 @@
 export * from './accordion';
+export * from './accordion.component';
 export * from './accordion.directive';
-export * from './accordion-item.component';
-export * from './accordion-item-content.directive';
-export * from './accordion-item-eager-content.directive';

package/components/action-bar/action-bar.component.d.ts

@@ -1,11 +1,9 @@
-import { type TuiButtonOptions } from '@taiga-ui/core/components/button';
 import { type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
-export declare class TuiActionBarComponent implements TuiButtonOptions {
-    expanded: boolean;
-    size: TuiSizeS;
-    readonly appearance = "secondary-grayscale";
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiActionBarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiActionBarComponent, "tui-action-bar", never, { "expanded": { "alias": "expanded"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["tui-data-list,[tuiMenu]", "*", "a,button,[tuiAction]"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+export declare class TuiActionBar {
+    readonly expanded: import("@angular/core").InputSignal<boolean>;
+    readonly size: import("@angular/core").InputSignal<TuiSizeS>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiActionBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiActionBar, "tui-action-bar", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["tui-data-list,[tuiMenu]", "*", "a,button,[tuiAction]"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
 }

package/components/action-bar/index.d.ts

@@ -1,3 +1 @@
-export * from './action-bar';
 export * from './action-bar.component';
-export * from './action-bar.directive';

package/components/avatar/avatar-labeled.component.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 export declare class TuiAvatarLabeled {
-    label: string;
-    protected split(label: string): readonly string[];
+    readonly label: import("@angular/core").InputSignal<string>;
+    protected readonly words: import("@angular/core").Signal<string[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAvatarLabeled, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarLabeled, "tui-avatar-labeled", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarLabeled, "tui-avatar-labeled", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/avatar/avatar-outline.directive.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from "@angular/core";
 export declare class TuiAvatarOutline {
     protected readonly nothing: undefined;
-    tuiAvatarOutline: string | null;
-    protected get value(): string | null;
+    protected readonly value: import("@angular/core").Signal<string | null>;
+    readonly tuiAvatarOutline: import("@angular/core").InputSignal<string | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAvatarOutline, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAvatarOutline, "[tuiAvatarOutline]", never, { "tuiAvatarOutline": { "alias": "tuiAvatarOutline"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAvatarOutline, "[tuiAvatarOutline]", never, { "tuiAvatarOutline": { "alias": "tuiAvatarOutline"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/avatar/avatar-stack.component.d.ts

@@ -1,7 +1,7 @@
 import { type TuiHorizontalDirection } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiAvatarStack {
-    direction: TuiHorizontalDirection;
+    readonly direction: import("@angular/core").InputSignal<TuiHorizontalDirection>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiAvatarStack, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarStack, "tui-avatar-stack", never, { "direction": { "alias": "direction"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiAvatarStack, "tui-avatar-stack", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/components/avatar/avatar.directive.d.ts

@@ -0,0 +1,15 @@
+import { TuiIcons } from '@taiga-ui/core/directives/icons';
+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 TuiAvatar {
+    private readonly options;
+    protected readonly nothing: undefined;
+    protected readonly icons: TuiIcons;
+    protected readonly fallback: import("@angular/core").WritableSignal<boolean>;
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "xs" | "l" | "xl" | "xxl">;
+    readonly round: import("@angular/core").InputSignal<boolean>;
+    readonly badge: import("@angular/core").InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiAvatar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiAvatar, "[tuiAvatar]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "round": { "alias": "round"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiIcons; inputs: { "iconStart": "tuiAvatar"; }; outputs: {}; }]>;
+}

package/components/avatar/avatar.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import { type TuiSizeXS, type TuiSizeXXL } from '@taiga-ui/core/types';
 export interface TuiAvatarOptions extends TuiAppearanceOptions {
@@ -6,6 +5,4 @@ export interface TuiAvatarOptions extends TuiAppearanceOptions {
     readonly round: boolean;
     readonly size: TuiSizeXS | TuiSizeXXL;
 }
-export declare const TUI_AVATAR_DEFAULT_OPTIONS: TuiAvatarOptions;
-export declare const TUI_AVATAR_OPTIONS: InjectionToken<TuiAvatarOptions>;
-export declare function tuiAvatarOptionsProvider(options: Partial<TuiAvatarOptions>): Provider;
+export declare const TUI_AVATAR_OPTIONS: import("@angular/core").InjectionToken<TuiAvatarOptions>, tuiAvatarOptionsProvider: (item: Partial<TuiAvatarOptions> | (() => Partial<TuiAvatarOptions>)) => import("@angular/core").FactoryProvider;

package/components/avatar/index.d.ts

@@ -1,4 +1,4 @@
-export * from './avatar.component';
+export * from './avatar.directive';
 export * from './avatar.options';
 export * from './avatar-labeled.component';
 export * from './avatar-outline.directive';

package/components/badge/badge.directive.d.ts

@@ -3,7 +3,7 @@ import * as i1 from "@taiga-ui/core/directives/appearance";
 import * as i2 from "@taiga-ui/core/directives/icons";
 export declare class TuiBadge {
     protected readonly nothing: undefined;
-    size: "m" | "s" | "l" | "xl";
+    readonly size: import("@angular/core").InputSignal<"m" | "s" | "l" | "xl">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBadge, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadge, "tui-badge,[tuiBadge]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadge, "tui-badge,[tuiBadge],tui-icon[tuiBadge]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
 }

package/components/badge/badge.options.d.ts

@@ -1,9 +1,7 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import { type TuiSizeS, type TuiSizeXL } from '@taiga-ui/core/types';
 export interface TuiBadgeOptions extends TuiAppearanceOptions {
     readonly size: TuiSizeS | TuiSizeXL;
 }
 export declare const TUI_BADGE_DEFAULT_OPTIONS: TuiBadgeOptions;
-export declare const TUI_BADGE_OPTIONS: InjectionToken<TuiBadgeOptions>;
-export declare function tuiBadgeOptionsProvider(options: Partial<TuiBadgeOptions>): Provider;
+export declare const TUI_BADGE_OPTIONS: import("@angular/core").InjectionToken<TuiBadgeOptions>, tuiBadgeOptionsProvider: (item: Partial<TuiBadgeOptions> | (() => Partial<TuiBadgeOptions>)) => import("@angular/core").FactoryProvider;

package/components/badge-notification/badge-notification.component.d.ts

@@ -1,8 +1,7 @@
-import { type TuiSizeL, type TuiSizeXS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/animated";
 export declare class TuiBadgeNotification {
-    size: TuiSizeL | TuiSizeXS;
+    readonly size: import("@angular/core").InputSignal<"m" | "l" | "s" | "xs">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBadgeNotification, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBadgeNotification, "tui-badge-notification", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBadgeNotification, "tui-badge-notification", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.TuiAnimated; inputs: {}; outputs: {}; }]>;
 }

package/components/badge-notification/badge-notification.options.d.ts

@@ -1,8 +1,6 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiSizeL, type TuiSizeXS } from '@taiga-ui/core/types';
 export interface TuiBadgeNotificationOptions {
     readonly size: TuiSizeL | TuiSizeXS;
 }
 export declare const TUI_BADGE_NOTIFICATION_DEFAULT_OPTIONS: TuiBadgeNotificationOptions;
-export declare const TUI_BADGE_NOTIFICATION_OPTIONS: InjectionToken<TuiBadgeNotificationOptions>;
-export declare function tuiBadgeNotificationOptionsProvider(options: Partial<TuiBadgeNotificationOptions>): Provider;
+export declare const TUI_BADGE_NOTIFICATION_OPTIONS: import("@angular/core").InjectionToken<TuiBadgeNotificationOptions>, tuiBadgeNotificationOptionsProvider: (item: Partial<TuiBadgeNotificationOptions> | (() => Partial<TuiBadgeNotificationOptions>)) => import("@angular/core").FactoryProvider;

package/components/badged-content/badged-content.directive.d.ts

@@ -1,7 +1,7 @@
 import { type TuiLooseUnion } from '@taiga-ui/cdk/types';
 import * as i0 from "@angular/core";
 export declare class TuiBadgedContentDirective {
-    tuiSlot: TuiLooseUnion<'bottom' | 'top'>;
+    readonly tuiSlot: import("@angular/core").InputSignal<TuiLooseUnion<"bottom" | "top">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBadgedContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadgedContentDirective, "[tuiSlot]", never, { "tuiSlot": { "alias": "tuiSlot"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBadgedContentDirective, "[tuiSlot]", never, { "tuiSlot": { "alias": "tuiSlot"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/block/block.directive.d.ts

@@ -1,13 +1,13 @@
 import { NgControl } from '@angular/forms';
-import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/directives/native-validator";
 import * as i2 from "@taiga-ui/core/directives/appearance";
 import * as i3 from "@taiga-ui/core/directives/icons";
 export declare class TuiBlock {
-    protected readonly control?: NgControl;
     protected readonly nothing: undefined;
-    size: TuiSizeL | TuiSizeS | '';
+    protected readonly options: import("./block.options").TuiBlockOptions;
+    protected readonly control: import("@angular/core").Signal<NgControl | undefined>;
+    readonly size: import("@angular/core").InputSignal<"" | "m" | "l" | "s">;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBlock, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBlock, "label[tuiBlock],input[tuiBlock]", never, { "size": { "alias": "tuiBlock"; "required": false; }; }, {}, ["control"], never, true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithIcons; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiBlock, "label[tuiBlock],input[tuiBlock]", never, { "size": { "alias": "tuiBlock"; "required": false; "isSignal": true; }; }, {}, ["control"], never, true, [{ directive: typeof i1.TuiNativeValidator; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i3.TuiWithIcons; inputs: {}; outputs: {}; }]>;
 }

package/components/block/block.options.d.ts

@@ -1,9 +1,7 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiAppearanceOptions } from '@taiga-ui/core/directives/appearance';
 import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 export interface TuiBlockOptions extends TuiAppearanceOptions {
-    readonly size: TuiSizeL | TuiSizeS;
+    readonly size: TuiSizeL | TuiSizeS | '';
 }
 export declare const TUI_BLOCK_DEFAULT_OPTIONS: TuiBlockOptions;
-export declare const TUI_BLOCK_OPTIONS: InjectionToken<TuiBlockOptions>;
-export declare function tuiBlockOptionsProvider(options: Partial<TuiBlockOptions>): Provider;
+export declare const TUI_BLOCK_OPTIONS: import("@angular/core").InjectionToken<TuiBlockOptions>, tuiBlockOptionsProvider: (item: Partial<TuiBlockOptions> | (() => Partial<TuiBlockOptions>)) => import("@angular/core").FactoryProvider;

package/components/breadcrumbs/breadcrumbs.component.d.ts

@@ -1,15 +1,14 @@
-import { type QueryList, TemplateRef } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { type TuiBreadcrumbsOptions } from './breadcrumbs.options';
 import * as i0 from "@angular/core";
 export declare class TuiBreadcrumbs {
-    protected readonly items: QueryList<TemplateRef<Record<string, unknown>>>;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
     protected readonly options: TuiBreadcrumbsOptions;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     protected readonly more: import("@angular/core").Signal<string>;
-    size: TuiBreadcrumbsOptions['size'];
-    itemsLimit: number;
-    protected get limit(): number;
-    protected get offset(): number;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").TuiSizeL>;
+    readonly itemsLimit: import("@angular/core").InputSignal<number>;
+    protected readonly offset: import("@angular/core").Signal<0 | 1>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiBreadcrumbs, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBreadcrumbs, "tui-breadcrumbs", never, { "size": { "alias": "size"; "required": false; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; }; }, {}, ["items"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiBreadcrumbs, "tui-breadcrumbs", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; "isSignal": true; }; }, {}, ["items"], never, true, never>;
 }

package/components/breadcrumbs/breadcrumbs.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiSizeL } from '@taiga-ui/core/types';
 export interface TuiBreadcrumbsOptions {
     readonly icon: string;
@@ -6,5 +5,4 @@ export interface TuiBreadcrumbsOptions {
     readonly itemsLimit: number;
 }
 export declare const TUI_BREADCRUMBS_DEFAULT_OPTIONS: TuiBreadcrumbsOptions;
-export declare const TUI_BREADCRUMBS_OPTIONS: InjectionToken<TuiBreadcrumbsOptions>;
-export declare function tuiBreadcrumbsOptionsProvider(options: Partial<TuiBreadcrumbsOptions>): Provider;
+export declare const TUI_BREADCRUMBS_OPTIONS: import("@angular/core").InjectionToken<TuiBreadcrumbsOptions>, tuiBreadcrumbsOptionsProvider: (item: Partial<TuiBreadcrumbsOptions> | (() => Partial<TuiBreadcrumbsOptions>)) => import("@angular/core").FactoryProvider;

package/components/button-loading/button-loading.component.d.ts

@@ -2,11 +2,11 @@ import { type TuiSizeS } from '@taiga-ui/core/types';
 import * as i0 from "@angular/core";
 export declare class TuiButtonLoading {
     private readonly options;
-    size: "m" | "l" | "xl" | "s" | "xs";
-    loading: boolean | string | null;
-    protected get loaderSize(): TuiSizeS;
-    protected get label(): string;
+    readonly size: import("@angular/core").InputSignal<"m" | "l" | "xl" | "s" | "xs">;
+    readonly loading: import("@angular/core").InputSignal<string | boolean | null>;
+    protected readonly loaderSize: import("@angular/core").Signal<TuiSizeS>;
+    protected readonly label: import("@angular/core").Signal<string | boolean | null>;
     protected onClick(event: MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiButtonLoading, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiButtonLoading, "[tuiButton][loading],[tuiIconButton][loading]", never, { "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiButtonLoading, "[tuiButton][loading],[tuiIconButton][loading]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

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

@@ -5,7 +5,7 @@ import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/cdk/date-time";
 export declare class TuiCalendarMonth {
     protected isYearPickerShown: boolean;
-    protected readonly months: import("@angular/core").Signal<readonly [January: string, February: string, March: string, April: string, May: string, June: string, July: string, August: string, September: string, October: string, November: string, December: string] | undefined>;
+    protected readonly months: import("@angular/core").Signal<readonly [January: string, February: string, March: string, April: string, May: string, June: string, July: string, August: string, September: string, October: string, November: string, December: string]>;
     protected readonly isRangePicking: import("@angular/core").Signal<boolean>;
     year: TuiYear;
     disabledItemHandler: TuiBooleanHandler<TuiMonth>;

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

@@ -2,4 +2,4 @@ export interface TuiCalendarMonthOptions {
     rangeMode: boolean;
 }
 export declare const TUI_CALENDAR_MONTH_DEFAULT_OPTIONS: TuiCalendarMonthOptions;
-export declare const TUI_CALENDAR_MONTH_OPTIONS: import("@angular/core").InjectionToken<TuiCalendarMonthOptions>, tuiCalendarMonthOptionsProvider: (item: Partial<TuiCalendarMonthOptions> | import("@angular/core").ProviderToken<Partial<TuiCalendarMonthOptions>> | (() => Partial<TuiCalendarMonthOptions>)) => import("@angular/core").FactoryProvider;
+export declare const TUI_CALENDAR_MONTH_OPTIONS: import("@angular/core").InjectionToken<TuiCalendarMonthOptions>, tuiCalendarMonthOptionsProvider: (item: Partial<TuiCalendarMonthOptions> | (() => Partial<TuiCalendarMonthOptions>)) => import("@angular/core").FactoryProvider;

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

@@ -2,7 +2,6 @@ import { EventEmitter, type OnChanges, type OnInit } from '@angular/core';
 import { TuiDay, type TuiDayLike, TuiDayRange, TuiMonth } from '@taiga-ui/cdk/date-time';
 import { type TuiBooleanHandler, type 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 TuiCalendarRange implements OnInit, OnChanges {
@@ -15,7 +14,7 @@ export declare class TuiCalendarRange implements OnInit, OnChanges {
     protected previousValue: TuiDay | TuiDayRange | null;
     protected hoveredItem: TuiDay | null;
     protected month: TuiMonth;
-    protected readonly otherDateText$: Observable<string>;
+    protected readonly otherDateText: import("@angular/core").Signal<string>;
     protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
     protected readonly capsMapper: TuiMapper<[TuiDay | null, TuiDay | TuiDayRange | null, TuiDayLike | null, boolean], TuiDay>;
     protected readonly mobile: boolean;
@@ -29,7 +28,6 @@ export declare class TuiCalendarRange implements OnInit, OnChanges {
     item: TuiDayRangePeriod | null;
     readonly valueChange: EventEmitter<TuiDayRange | null>;
     readonly itemChange: EventEmitter<TuiDayRangePeriod | null>;
-    constructor();
     set valueSetter(value: TuiDayRange | null);
     set defaultViewedMonth(month: TuiMonth);
     set value(value: TuiDayRange | null);

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

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

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

@@ -1,37 +1,34 @@
-import { EventEmitter, type QueryList, TemplateRef } from '@angular/core';
+import { 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 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;
-    readonly indexChange: EventEmitter<number>;
-    readonly shift: EventEmitter<number>;
-    set indexSetter(index: number);
+    private readonly translate;
+    protected readonly transitioned: import("@angular/core").WritableSignal<boolean>;
+    protected readonly transform: import("@angular/core").Signal<string>;
+    protected readonly items: import("@angular/core").Signal<readonly TemplateRef<any>[]>;
+    protected readonly computedDraggable: import("@angular/core").Signal<boolean>;
+    protected readonly computedTranslate: import("@angular/core").Signal<number>;
+    protected readonly x: import("@angular/core").Signal<number>;
+    protected readonly resetDuration: import("@angular/core").EffectRef;
+    readonly draggable: import("@angular/core").InputSignal<boolean>;
+    readonly itemsCount: import("@angular/core").InputSignal<number>;
+    readonly index: import("@angular/core").ModelSignal<number>;
+    readonly shift: import("@angular/core").OutputEmitterRef<number>;
     next(): void;
     prev(): void;
-    protected get transform(): string;
-    protected getStyle(itemsCount: number): Partial<CSSStyleDeclaration>;
     protected onTransitioned(transitioned: boolean): void;
     protected isDisabled(index: number): boolean;
-    protected onIntersection({ intersectionRatio }: IntersectionObserverEntry, index: number): void;
+    protected onIntersection(ratio: number, index: number): void;
     protected onScroll(delta: number): void;
     protected onPan(x: number): void;
     protected onSwipe(direction: TuiSwipeDirection): void;
     protected onAutoscroll(): void;
     protected onShift(): void;
-    private get x();
-    private get computedTranslate();
-    private get computedDraggable();
     private updateIndex;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselComponent, 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"; "shift": "shift"; }, ["items"], never, true, [{ directive: typeof i1.TuiCarouselDirective; inputs: { "duration": "duration"; }; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCarouselComponent, "tui-carousel", never, { "draggable": { "alias": "draggable"; "required": false; "isSignal": true; }; "itemsCount": { "alias": "itemsCount"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, { "index": "indexChange"; "shift": "shift"; }, ["items"], never, true, [{ directive: typeof i1.TuiCarouselDirective; inputs: { "duration": "duration"; }; outputs: {}; }]>;
 }

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

@@ -5,11 +5,12 @@ export declare class TuiCarouselDirective extends Observable<unknown> {
     private readonly platform;
     private readonly visible$;
     private readonly zone;
-    private readonly duration$;
+    private readonly trigger$;
     private readonly running$;
-    private readonly output$;
+    readonly duration: import("@angular/core").InputSignal<number>;
+    protected readonly output$: Observable<number>;
     constructor();
-    set duration(duration: number);
+    restart(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCarouselDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselDirective, never, never, { "duration": { "alias": "duration"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCarouselDirective, never, never, { "duration": { "alias": "duration"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,21 +1,10 @@
-import { type DoCheck, type OnInit } from '@angular/core';
-import { NgControl } from '@angular/forms';
-import { type TuiSizeS } from '@taiga-ui/core/types';
+import { TuiRadioComponent } from '@taiga-ui/kit/components/radio';
+import { type TuiCheckboxOptions } from './checkbox.options';
 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 TuiCheckbox implements OnInit, DoCheck {
-    private readonly appearance;
-    private readonly options;
-    private readonly cdr;
-    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;
+import * as i1 from "@taiga-ui/core/directives/icons";
+export declare class TuiCheckbox extends TuiRadioComponent<TuiCheckboxOptions> {
+    protected readonly check: import("@angular/core").Signal<string>;
+    protected readonly indeterminate: import("@angular/core").Signal<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.TuiAppearance; inputs: { "tuiAppearanceState": "tuiAppearanceState"; "tuiAppearanceFocus": "tuiAppearanceFocus"; "tuiAppearanceMode": "tuiAppearanceMode"; }; outputs: {}; }, { directive: typeof i2.TuiNativeValidator; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiCheckbox, "input[type=\"checkbox\"][tuiCheckbox]", never, {}, {}, never, never, true, [{ directive: typeof i1.TuiIcons; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,14 +1,10 @@
-import { InjectionToken, 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> | string;
+import { type TuiRadioOptions } from '@taiga-ui/kit/components/radio';
+export interface TuiCheckboxOptions extends TuiRadioOptions {
     readonly icons: Readonly<{
-        checked: TuiStringHandler<TuiSizeS> | string;
-        indeterminate: TuiStringHandler<TuiSizeS> | string;
+        checked: TuiStringHandler<TuiSizeS>;
+        indeterminate: TuiStringHandler<TuiSizeS>;
     }>;
 }
-export declare const TUI_CHECKBOX_DEFAULT_OPTIONS: TuiCheckboxOptions;
-export declare const TUI_CHECKBOX_OPTIONS: InjectionToken<TuiCheckboxOptions>;
-export declare function tuiCheckboxOptionsProvider(options: Partial<TuiCheckboxOptions>): Provider;
+export declare const TUI_CHECKBOX_OPTIONS: import("@angular/core").InjectionToken<TuiCheckboxOptions>, tuiCheckboxOptionsProvider: (item: Partial<TuiCheckboxOptions> | (() => Partial<TuiCheckboxOptions>)) => import("@angular/core").FactoryProvider;

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

@@ -1,11 +1,9 @@
-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;
+    readonly size: import("@angular/core").InputSignal<import("@taiga-ui/core/types").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: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiChip, "tui-chip,[tuiChip]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof i2.TuiWithIcons; inputs: {}; outputs: {}; }]>;
 }

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

@@ -1,9 +1,7 @@
-import { InjectionToken, 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: InjectionToken<TuiChipOptions>;
-export declare function tuiChipOptionsProvider(options: Partial<TuiChipOptions>): Provider;
+export declare const TUI_CHIP_OPTIONS: import("@angular/core").InjectionToken<TuiChipOptions>, tuiChipOptionsProvider: (item: Partial<TuiChipOptions> | (() => Partial<TuiChipOptions>)) => import("@angular/core").FactoryProvider;

package/components/combo-box/combo-box.d.ts

@@ -0,0 +1,5 @@
+import { TuiLabel } from '@taiga-ui/core/components/label';
+import { TuiTextfieldComponent, TuiTextfieldOptionsDirective } from '@taiga-ui/core/components/textfield';
+import { TuiDropdownContent } from '@taiga-ui/core/portals/dropdown';
+import { TuiComboBoxDirective } from './combo-box.directive';
+export declare const TuiComboBox: readonly [typeof TuiComboBoxDirective, typeof TuiLabel, typeof TuiTextfieldComponent, typeof TuiTextfieldOptionsDirective, typeof TuiDropdownContent];

package/components/combo-box/combo-box.directive.d.ts

@@ -2,29 +2,27 @@ import { TuiControl } from '@taiga-ui/cdk/classes';
 import { type TuiStringMatcher } from '@taiga-ui/cdk/types';
 import { type TuiTextfieldAccessor } from '@taiga-ui/core/components/textfield';
 import * as i0 from "@angular/core";
-import * as i1 from "@taiga-ui/core/components/textfield";
-export declare class TuiComboBox<T> extends TuiControl<T | string | null> implements TuiTextfieldAccessor<T> {
+import * as i1 from "@taiga-ui/core/components/input";
+export declare class TuiComboBoxDirective<T> extends TuiControl<T | string | null> implements TuiTextfieldAccessor<T> {
     private readonly host;
-    private readonly textfield;
+    private readonly input;
     private readonly open;
     private readonly dropdownEnabled;
     private readonly dropdown;
     private readonly handlers;
-    private readonly matcher;
-    private readonly strict;
     private readonly datalist;
     private readonly options;
     protected readonly nonStrictControlEffect: import("@angular/core").EffectRef;
     protected readonly matchingEffect: import("@angular/core").EffectRef;
     protected readonly newValueEffect: import("@angular/core").EffectRef;
     protected readonly blurEffect: import("@angular/core").EffectRef;
-    set strictSetter(x: boolean);
-    set matcherSetter(x: TuiStringMatcher<T> | null);
+    readonly strict: import("@angular/core").InputSignal<boolean>;
+    readonly matcher: import("@angular/core").InputSignal<TuiStringMatcher<T> | null>;
     setValue(value: T | null): void;
     writeValue(value: T | string | null): void;
     protected toggleDropdown(open?: boolean): void;
     protected keydownEnter(event: KeyboardEvent): void;
     private stringify;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiComboBox<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiComboBox<any>, "input[tuiComboBox]", never, { "strictSetter": { "alias": "strict"; "required": false; }; "matcherSetter": { "alias": "matcher"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithTextfield; inputs: {}; outputs: {}; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiComboBoxDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiComboBoxDirective<any>, "input[tuiComboBox]", never, { "strict": { "alias": "strict"; "required": false; "isSignal": true; }; "matcher": { "alias": "matcher"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TuiWithInput; inputs: {}; outputs: {}; }]>;
 }

package/components/combo-box/index.d.ts

@@ -1 +1,2 @@
+export * from './combo-box';
 export * from './combo-box.directive';