@taiga-ui/addon-table 4.52.0-canary.e10b718 → 4.52.0-canary.e53e79e

package/README.md

@@ -16,13 +16,13 @@ consisting of multiple base libraries and several add-ons
 
 Install base packages:
 
-```
+```bash
 npm i @taiga-ui/{cdk,core}
 ```
 
 Install addon-table:
 
-```
+```bash
 npm i @taiga-ui/addon-table
 ```
 

package/components/reorder/reorder.component.d.ts

@@ -1,20 +1,17 @@
-import { EventEmitter } from '@angular/core';
 import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import * as i0 from "@angular/core";
 export declare class TuiReorder<T> {
     private dragging;
     protected order: Map<number, number>;
-    protected unsortedItems: readonly T[];
+    protected readonly unsortedItems: import("@angular/core").WritableSignal<readonly T[]>;
     protected readonly options: import("./reorder.options").TuiReorderOptions;
-    protected readonly showHideText$: import("rxjs").Observable<string>;
-    enabled: readonly T[];
-    readonly itemsChange: EventEmitter<T[]>;
-    readonly enabledChange: EventEmitter<T[]>;
-    set items(items: readonly T[]);
-    content: PolymorpheusContent<TuiContext<T> & {
+    protected readonly showHideText: import("@angular/core").Signal<string>;
+    readonly enabled: import("@angular/core").ModelSignal<readonly T[]>;
+    readonly items: import("@angular/core").ModelSignal<readonly T[]>;
+    readonly content: import("@angular/core").InputSignal<PolymorpheusContent<TuiContext<T> & {
         index: number;
-    }>;
+    }>>;
     protected onDrag(): void;
     protected onDrop(): void;
     protected isEnabled(item: T): boolean;
@@ -25,5 +22,5 @@ export declare class TuiReorder<T> {
     private updateItems;
     private updateEnabled;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiReorder<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiReorder<any>, "tui-reorder", never, { "enabled": { "alias": "enabled"; "required": false; }; "items": { "alias": "items"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, { "itemsChange": "itemsChange"; "enabledChange": "enabledChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiReorder<any>, "tui-reorder", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, { "enabled": "enabledChange"; "items": "itemsChange"; }, never, never, true, never>;
 }

package/components/reorder/reorder.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 export interface TuiReorderOptions {
     readonly icons: {
         readonly drag: string;
@@ -7,5 +6,4 @@ export interface TuiReorderOptions {
     };
 }
 export declare const TUI_REORDER_DEFAULT_OPTIONS: TuiReorderOptions;
-export declare const TUI_REORDER_OPTIONS: InjectionToken<TuiReorderOptions>;
-export declare function tuiReorderOptionsProvider(options: Partial<TuiReorderOptions>): Provider;
+export declare const TUI_REORDER_OPTIONS: import("@angular/core").InjectionToken<TuiReorderOptions>, tuiReorderOptionsProvider: (item: Partial<TuiReorderOptions> | (() => Partial<TuiReorderOptions>)) => import("@angular/core").FactoryProvider;

package/components/table/directives/cell.directive.d.ts

@@ -1,8 +1,8 @@
 import { TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiTableCell {
-    tuiCell: string;
+    readonly tuiCell: import("@angular/core").InputSignal<string>;
     readonly template: TemplateRef<any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableCell, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableCell, "ng-template[tuiCell]", never, { "tuiCell": { "alias": "tuiCell"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableCell, "ng-template[tuiCell]", never, { "tuiCell": { "alias": "tuiCell"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/table/directives/direction-order.directive.d.ts

@@ -1,11 +1,13 @@
 import * as i0 from "@angular/core";
 export declare class TuiTableDirectionOrder<T> {
     private readonly table;
+    private readonly directionOrderChange$;
     /**
      * @deprecated: use tuiSortChange
      */
-    readonly directionOrderChange: import("rxjs").Observable<"asc" | "desc">;
-    set directionOrder(order: 'asc' | 'desc');
+    readonly directionOrderChange: import("@angular/core").OutputRef<"asc" | "desc">;
+    readonly directionOrder: import("@angular/core").InputSignal<"asc" | "desc" | undefined>;
+    protected readonly setTableDirection: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableDirectionOrder<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableDirectionOrder<any>, "table[tuiTable][tuiDirectionOrder]", never, { "directionOrder": { "alias": "directionOrder"; "required": false; }; }, { "directionOrderChange": "directionOrderChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableDirectionOrder<any>, "table[tuiTable][tuiDirectionOrder]", never, { "directionOrder": { "alias": "directionOrder"; "required": false; "isSignal": true; }; }, { "directionOrderChange": "directionOrderChange"; }, never, never, true, never>;
 }

package/components/table/directives/head.directive.d.ts

@@ -1,8 +1,8 @@
 import { TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class TuiTableHead<T extends Partial<Record<keyof T, unknown>>> {
-    tuiHead: string | keyof T;
+    readonly tuiHead: import("@angular/core").InputSignal<string | keyof T>;
     readonly template: TemplateRef<any>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableHead<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableHead<any>, "[tuiHead]", never, { "tuiHead": { "alias": "tuiHead"; "required": true; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableHead<any>, "[tuiHead]", never, { "tuiHead": { "alias": "tuiHead"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/table/directives/resized.directive.d.ts

@@ -2,7 +2,8 @@ import * as i0 from "@angular/core";
 export declare class TuiTableResized {
     private readonly doc;
     private readonly el;
-    readonly tuiResized: import("rxjs").Observable<number>;
+    private readonly tuiResized$;
+    readonly tuiResized: import("@angular/core").OutputRef<number>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableResized, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableResized, "[tuiResized]", never, {}, { "tuiResized": "tuiResized"; }, never, never, true, never>;
 }

package/components/table/directives/sort-by.directive.d.ts

@@ -4,15 +4,19 @@ import * as i0 from "@angular/core";
 export declare class TuiTableSortBy<T extends Partial<Record<keyof T, unknown>>> {
     private readonly sortables;
     private readonly table;
+    /**
+     * @deprecated
+     */
+    private readonly tuiSortByChange$;
     /**
      * @deprecated: use tuiSortChange
      */
-    readonly tuiSortByChange: Observable<keyof T | null>;
-    readonly tuiSortChange: Observable<TuiSortChange<T>>;
-    tuiSortBy: string | keyof T | null;
-    set sortBy(sortBy: string | keyof T | null);
-    protected checkSortables(): void;
+    readonly tuiSortByChange: import("@angular/core").OutputRef<keyof T | null>;
+    readonly tuiSortChange$: Observable<TuiSortChange<T>>;
+    readonly tuiSortChange: import("@angular/core").OutputRef<TuiSortChange<T>>;
+    readonly tuiSortBy: import("@angular/core").InputSignal<string | keyof T | null>;
+    protected readonly checkSortables: import("@angular/core").EffectRef;
     private getKey;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableSortBy<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableSortBy<any>, "table[tuiTable][tuiSortBy]", never, { "sortBy": { "alias": "tuiSortBy"; "required": false; }; }, { "tuiSortByChange": "tuiSortByChange"; "tuiSortChange": "tuiSortChange"; }, ["sortables"], never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableSortBy<any>, "table[tuiTable][tuiSortBy]", never, { "tuiSortBy": { "alias": "tuiSortBy"; "required": false; "isSignal": true; }; }, { "tuiSortByChange": "tuiSortByChange"; "tuiSortChange": "tuiSortChange"; }, ["sortables"], never, true, never>;
 }

package/components/table/directives/sortable.directive.d.ts

@@ -1,18 +1,16 @@
 import { type BooleanInput } from '@angular/cdk/coercion';
-import { type OnChanges } from '@angular/core';
 import { type TuiComparator } from '@taiga-ui/addon-table/types';
 import * as i0 from "@angular/core";
-export declare class TuiTableSortable<T extends Partial<Record<keyof T, unknown>>> implements OnChanges {
+export declare class TuiTableSortable<T extends Partial<Record<keyof T, unknown>>> {
     private readonly table;
     private readonly th;
     private readonly sortBy;
-    sortable: BooleanInput;
+    readonly sortable: import("@angular/core").InputSignalWithTransform<BooleanInput, any>;
+    protected readonly setSorter: import("@angular/core").EffectRef;
+    readonly sorter: import("@angular/core").Signal<TuiComparator<T>>;
     get key(): keyof T;
-    sorter: TuiComparator<T>;
-    ngOnChanges(): void;
     check(): void;
     private get match();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableSortable<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableSortable<any>, "th[tuiTh][tuiSortable]", never, { "sortable": { "alias": "tuiSortable"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_sortable: any;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableSortable<any>, "th[tuiTh][tuiSortable]", never, { "sortable": { "alias": "tuiSortable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/table/directives/table.directive.d.ts

@@ -1,7 +1,6 @@
-import { type AfterViewInit, EventEmitter, type OnChanges } from '@angular/core';
+import { type AfterViewInit, type OnChanges } from '@angular/core';
 import { type TuiComparator } from '@taiga-ui/addon-table/types';
 import { type TuiTextfieldOptions } from '@taiga-ui/core/components/textfield';
-import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 import { type Observable, Subject } from 'rxjs';
 import { TuiSortDirection, type TuiTableSortChange } from '../table.options';
 import * as i0 from "@angular/core";
@@ -10,27 +9,32 @@ export declare class TuiTableDirective<T extends Partial<Record<keyof T, unknown
     private readonly options;
     private readonly cdr;
     protected readonly nothing: undefined;
-    columns: ReadonlyArray<string | keyof T>;
-    direction: TuiSortDirection;
+    readonly columns: import("@angular/core").InputSignal<readonly (string | keyof T)[]>;
+    readonly direction: import("@angular/core").InputSignal<TuiSortDirection>;
     sorter: TuiComparator<T>;
     /**
      * @deprecated: use sortChange
      */
-    readonly directionChange: EventEmitter<TuiSortDirection>;
+    readonly directionChange: import("@angular/core").OutputEmitterRef<TuiSortDirection>;
     /**
      * @deprecated: use sortChange
      */
-    readonly sorterChange: EventEmitter<TuiComparator<T> | null>;
-    readonly sortChange: Observable<TuiTableSortChange<T>>;
+    readonly directionChange$: Observable<TuiSortDirection>;
+    /**
+     * @deprecated: use sortChange
+     */
+    readonly sorterChange: import("@angular/core").OutputEmitterRef<TuiComparator<T> | null>;
+    readonly sorterChange$: Observable<TuiComparator<T> | null>;
+    protected readonly sortChange$: Observable<TuiTableSortChange<T>>;
+    readonly sortChange: import("@angular/core").OutputRef<TuiTableSortChange<T>>;
     readonly appearance: import("@angular/core").WritableSignal<string>;
-    readonly size: import("@angular/core").WritableSignal<"m" | "l" | "s">;
+    readonly size: import("@angular/core").InputSignal<"m" | "l" | "s">;
     readonly cleaner: import("@angular/core").WritableSignal<boolean>;
     readonly change$: Subject<void>;
-    set sizeSetter(size: TuiSizeL | TuiSizeS);
     updateSorterAndDirection(sorter: TuiComparator<T> | null): void;
     ngOnChanges(): void;
     ngAfterViewInit(): void;
     updateSorter(sorter: TuiComparator<T> | null, direction?: TuiSortDirection): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableDirective<any>, "table[tuiTable]", never, { "columns": { "alias": "columns"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "sorter": { "alias": "sorter"; "required": false; }; "sizeSetter": { "alias": "size"; "required": false; }; }, { "directionChange": "directionChange"; "sorterChange": "sorterChange"; "sortChange": "sortChange"; }, never, never, true, [{ directive: typeof i1.TuiStuck; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableDirective<any>, "table[tuiTable]", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "sorter": { "alias": "sorter"; "required": false; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "directionChange": "directionChange"; "sorterChange": "sorterChange"; "sortChange": "sortChange"; }, never, never, true, [{ directive: typeof i1.TuiStuck; inputs: {}; outputs: {}; }]>;
 }

package/components/table/pipes/table-sort.pipe.d.ts

@@ -1,9 +1,9 @@
 import { type PipeTransform } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class TuiTableSortPipe<K> implements PipeTransform {
+export declare class TuiTableSortPipe implements PipeTransform {
     private readonly table;
-    transform<T extends K>(data?: readonly T[] | null): readonly T[];
+    transform<T>(data?: readonly T[] | null): readonly T[];
     private sort;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableSortPipe<any>, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<TuiTableSortPipe<any>, "tuiTableSort", true>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableSortPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TuiTableSortPipe, "tuiTableSort", true>;
 }

package/components/table/table-expand/table-expand.component.d.ts

@@ -1,20 +1,18 @@
-import { EventEmitter } from '@angular/core';
 import { Subject } from 'rxjs';
 import * as i0 from "@angular/core";
 import * as i1 from "@taiga-ui/kit/directives/present";
 export declare class TuiTableExpand {
-    private readonly content?;
+    private readonly content;
     private readonly el;
     private readonly server;
     protected readonly transitioning: import("@angular/core").WritableSignal<boolean>;
     protected readonly contentHeight: import("@angular/core").Signal<number>;
     protected readonly visible$: Subject<boolean>;
     protected readonly sub: import("rxjs").Subscription;
-    readonly expandedChange: EventEmitter<boolean>;
-    readonly expanded: import("@angular/core").WritableSignal<boolean>;
-    set expandedSetter(open: boolean);
+    readonly expanded: import("@angular/core").ModelSignal<boolean>;
+    protected readonly transitioningEffect: import("@angular/core").EffectRef;
     toggle(): void;
     private update;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableExpand, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableExpand, "tui-table-expand", never, { "expandedSetter": { "alias": "expanded"; "required": false; }; }, { "expandedChange": "expandedChange"; }, never, ["*"], true, [{ directive: typeof i1.TuiPresent; inputs: {}; outputs: { "tuiPresentChange": "tuiPresentChange"; }; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableExpand, "tui-table-expand", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, [{ directive: typeof i1.TuiPresent; inputs: {}; outputs: { "tuiPresentChange": "tuiPresentChange"; }; }]>;
 }

package/components/table/table.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiComparator } from '@taiga-ui/addon-table/types';
 import { type TuiSizeL, type TuiSizeS } from '@taiga-ui/core/types';
 export declare const TuiSortDirection: {
@@ -44,5 +43,4 @@ export interface TuiTableOptions {
     readonly sticky: boolean;
 }
 export declare const TUI_TABLE_DEFAULT_OPTIONS: TuiTableOptions;
-export declare const TUI_TABLE_OPTIONS: InjectionToken<TuiTableOptions>;
-export declare function tuiTableOptionsProvider(options: Partial<TuiTableOptions>): Provider;
+export declare const TUI_TABLE_OPTIONS: import("@angular/core").InjectionToken<TuiTableOptions>, tuiTableOptionsProvider: (item: Partial<TuiTableOptions> | (() => Partial<TuiTableOptions>)) => import("@angular/core").FactoryProvider;

package/components/table/tbody/tbody.component.d.ts

@@ -1,4 +1,3 @@
-import { EventEmitter, type QueryList } from '@angular/core';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 import { TuiTableDirective } from '../directives/table.directive';
 import { TuiTableTr } from '../tr/tr.component';
@@ -6,16 +5,14 @@ import * as i0 from "@angular/core";
 export declare class TuiTableTbody<T extends Partial<Record<keyof T, unknown>>> {
     private readonly options;
     protected readonly table: TuiTableDirective<T>;
-    readonly rows: QueryList<TuiTableTr<T>>;
-    data: readonly T[];
+    readonly rows: import("@angular/core").Signal<readonly TuiTableTr<T>[]>;
+    readonly data: import("@angular/core").InputSignal<readonly T[]>;
     /** @deprecated: drop in v5.0, use TuiTableExpand */
-    heading: PolymorpheusContent;
+    readonly heading: import("@angular/core").InputSignal<PolymorpheusContent>;
     /** @deprecated: drop in v5.0, use TuiTableExpand */
-    open: boolean;
-    /** @deprecated: drop in v5.0, use TuiTableExpand */
-    readonly openChange: EventEmitter<boolean>;
+    readonly open: import("@angular/core").ModelSignal<boolean>;
     /** @deprecated: drop in v5.0, use TuiTableExpand */
     protected onClick: () => void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableTbody<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableTbody<any>, "tbody[tuiTbody]", never, { "data": { "alias": "data"; "required": false; }; "heading": { "alias": "heading"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, ["rows"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableTbody<any>, "tbody[tuiTbody]", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, ["rows"], ["*"], true, never>;
 }

package/components/table/td/td.component.d.ts

@@ -1,8 +1,9 @@
+import { TuiControl } from '@taiga-ui/cdk/classes';
 import { TuiTextfieldComponent } from '@taiga-ui/core/components/textfield';
 import * as i0 from "@angular/core";
 export declare class TuiTableTd {
-    protected readonly control: unknown;
-    protected readonly textfield?: TuiTextfieldComponent<unknown>;
+    protected readonly control: import("@angular/core").Signal<TuiControl<any> | undefined>;
+    protected readonly textfield: import("@angular/core").Signal<TuiTextfieldComponent<any> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableTd, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableTd, "th[tuiTd], td[tuiTd]", never, {}, {}, ["control", "textfield"], ["*"], true, never>;
 }

package/components/table/th/th.component.d.ts

@@ -4,14 +4,14 @@ import * as i0 from "@angular/core";
 export declare class TuiTableTh<T extends Partial<Record<keyof T, unknown>>> {
     private readonly options;
     private readonly head;
-    protected width: number | null;
+    protected readonly width: import("@angular/core").WritableSignal<number | null>;
     protected readonly table: TuiTableDirective<T> | null;
-    minWidth: number;
-    maxWidth: number;
+    readonly minWidth: import("@angular/core").InputSignal<number>;
+    readonly maxWidth: import("@angular/core").InputSignal<number>;
     sorter: TuiComparator<T> | null;
-    resizable: boolean;
-    sticky: boolean;
-    requiredSort: boolean;
+    readonly resizable: import("@angular/core").InputSignal<boolean>;
+    readonly sticky: import("@angular/core").InputSignal<boolean>;
+    readonly requiredSort: import("@angular/core").InputSignal<boolean>;
     get key(): keyof T;
     protected get isCurrent(): boolean;
     protected get icon(): string;
@@ -19,7 +19,7 @@ export declare class TuiTableTh<T extends Partial<Record<keyof T, unknown>>> {
     protected onResized(width: number): void;
     private get isCurrentAndDescDirection();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableTh<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableTh<any>, "th[tuiTh]", never, { "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "sorter": { "alias": "sorter"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "sticky": { "alias": "sticky"; "required": false; }; "requiredSort": { "alias": "requiredSort"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableTh<any>, "th[tuiTh]", never, { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "sorter": { "alias": "sorter"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "requiredSort": { "alias": "requiredSort"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 export declare class TuiTableSortKeyException extends Error {
     constructor();

package/components/table/th-group/th-group.component.d.ts

@@ -1,15 +1,12 @@
-import { type AfterContentInit, type QueryList } from '@angular/core';
-import { type Observable } from 'rxjs';
 import { TuiTableHead } from '../directives/head.directive';
 import { TuiTableDirective } from '../directives/table.directive';
 import { TuiTableTh } from '../th/th.component';
 import * as i0 from "@angular/core";
-export declare class TuiTableThGroup<T extends Partial<Record<keyof T, unknown>>> implements AfterContentInit {
-    protected readonly th: TuiTableTh<T>;
-    protected readonly heads: QueryList<TuiTableHead<T>>;
-    protected heads$: Observable<Record<string | keyof T, TuiTableHead<T>>> | null;
+export declare class TuiTableThGroup<T extends Partial<Record<keyof T, unknown>>> {
+    protected readonly th: import("@angular/core").Signal<TuiTableTh<T> | undefined>;
+    protected readonly heads: import("@angular/core").Signal<readonly TuiTableHead<T>[]>;
+    protected readonly computedHeads: import("@angular/core").Signal<Record<string | keyof T, TuiTableHead<T>>>;
     protected readonly table: TuiTableDirective<T>;
-    ngAfterContentInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableThGroup<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableThGroup<any>, "tr[tuiThGroup]", never, {}, {}, ["th", "heads"], ["*"], true, never>;
 }

package/components/table/tr/tr.component.d.ts

@@ -6,6 +6,8 @@ export declare class TuiTableTr<T extends Partial<Record<keyof T, unknown>>> imp
     private readonly cells;
     private readonly body;
     private readonly contentReady$;
+    private readonly rows$;
+    private readonly contentCells$;
     protected readonly table: TuiTableDirective<T>;
     protected readonly height: import("@angular/core").Signal<number>;
     protected readonly cells$: import("rxjs").Observable<Record<string | keyof T, TuiTableCell>>;

package/components/table-pagination/table-pagination.component.d.ts

@@ -1,4 +1,3 @@
-import { EventEmitter } from '@angular/core';
 import { type TuiTablePaginationOptions } from './table-pagination.options';
 import * as i0 from "@angular/core";
 export interface TuiTablePaginationEvent {
@@ -7,31 +6,28 @@ export interface TuiTablePaginationEvent {
 }
 export declare class TuiTablePagination {
     private readonly options;
-    protected open: boolean;
-    protected readonly icons: import("@taiga-ui/core/tokens").TuiSpinIcons;
-    protected readonly spinTexts$: import("rxjs").Observable<readonly [previous: string, next: string]>;
-    protected readonly texts$: import("rxjs").Observable<{
+    protected readonly icons: import("@taiga-ui/core/tokens").TuiCommonIcons;
+    protected readonly spinTexts: import("@angular/core").Signal<readonly [previous: string, next: string]>;
+    protected readonly texts: import("@angular/core").Signal<{
         linesPerPage: string;
         of: string;
         pages: string;
     }>;
-    protected readonly commonIcons: import("@taiga-ui/core/tokens").TuiCommonIcons;
-    items: readonly number[];
-    total: number;
-    page: number;
-    size: number;
-    readonly paginationChange: EventEmitter<TuiTablePaginationEvent>;
+    protected readonly pages: import("@angular/core").Signal<number>;
+    protected readonly end: import("@angular/core").Signal<number>;
+    protected readonly rightDisabled: import("@angular/core").Signal<boolean>;
+    protected readonly pagination: import("@angular/core").Signal<TuiTablePaginationEvent>;
+    readonly items: import("@angular/core").InputSignal<readonly number[]>;
+    readonly total: import("@angular/core").InputSignal<number>;
+    readonly page: import("@angular/core").InputSignal<number>;
+    readonly size: import("@angular/core").InputSignal<number>;
+    readonly paginationChange: import("@angular/core").OutputEmitterRef<TuiTablePaginationEvent>;
     onItem(size: number): void;
-    protected get pages(): number;
     protected get showPages(): boolean;
     protected get sizeOptionContent(): TuiTablePaginationOptions['sizeOptionContent'];
     protected get start(): number;
-    protected get end(): number;
-    protected get leftDisabled(): boolean;
-    protected get rightDisabled(): boolean;
-    protected get pagination(): TuiTablePaginationEvent;
     protected back(): void;
     protected forth(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTablePagination, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTablePagination, "tui-table-pagination", never, { "items": { "alias": "items"; "required": false; }; "total": { "alias": "total"; "required": false; }; "page": { "alias": "page"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "paginationChange": "paginationChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TuiTablePagination, "tui-table-pagination", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "paginationChange": "paginationChange"; }, never, never, true, never>;
 }

package/components/table-pagination/table-pagination.options.d.ts

@@ -1,4 +1,3 @@
-import { InjectionToken, type Provider } from '@angular/core';
 import { type TuiContext } from '@taiga-ui/cdk/types';
 import { type PolymorpheusContent } from '@taiga-ui/polymorpheus';
 export interface TuiTablePaginationOptions {
@@ -13,5 +12,4 @@ export declare const TUI_TABLE_PAGINATION_DEFAULT_OPTIONS: TuiTablePaginationOpt
 /**
  * Default parameters for TablePagination component
  */
-export declare const TUI_TABLE_PAGINATION_OPTIONS: InjectionToken<TuiTablePaginationOptions>;
-export declare function tuiTablePaginationOptionsProvider(options: Partial<TuiTablePaginationOptions>): Provider;
+export declare const TUI_TABLE_PAGINATION_OPTIONS: import("@angular/core").InjectionToken<TuiTablePaginationOptions>, tuiTablePaginationOptionsProvider: (item: Partial<TuiTablePaginationOptions> | (() => Partial<TuiTablePaginationOptions>)) => import("@angular/core").FactoryProvider;

package/directives/table-control/checkbox-row.directive.d.ts

@@ -4,10 +4,10 @@ export declare class TuiCheckboxRowDirective<T> implements OnInit, OnDestroy {
     private readonly control;
     private readonly parent;
     protected readonly checked: import("@angular/core").Signal<boolean>;
-    tuiCheckboxRow: T;
+    readonly tuiCheckboxRow: import("@angular/core").InputSignal<T>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     protected onChange(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiCheckboxRowDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCheckboxRowDirective<any>, "[tuiCheckbox][tuiCheckboxRow]", never, { "tuiCheckboxRow": { "alias": "tuiCheckboxRow"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiCheckboxRowDirective<any>, "[tuiCheckbox][tuiCheckboxRow]", never, { "tuiCheckboxRow": { "alias": "tuiCheckboxRow"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/table-filters/generic-filter.directive.d.ts

@@ -1,7 +1,8 @@
 import { AbstractTuiTableFilter } from './abstract-table-filter';
 import * as i0 from "@angular/core";
 export declare class TuiGenericFilter<T, G> extends AbstractTuiTableFilter<T, G> {
+    readonly tuiGenericFilter: import("@angular/core").InputSignal<(item: T, value: G) => boolean>;
     filter: (item: T, value: G) => boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiGenericFilter<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiGenericFilter<any, any>, "[tuiGenericFilter]", never, { "filter": { "alias": "tuiGenericFilter"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiGenericFilter<any, any>, "[tuiGenericFilter]", never, { "tuiGenericFilter": { "alias": "tuiGenericFilter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/directives/table-filters/table-filter.directive.d.ts

@@ -7,12 +7,12 @@ export declare class TuiTableFilterDirective<T> implements OnInit, OnDestroy, Tu
     private readonly delegate;
     private readonly control;
     protected readonly filters: TuiTableFiltersDirective<any>;
-    tuiTableFilter?: keyof T;
+    protected readonly key: import("@angular/core").Signal<string | keyof T | undefined>;
+    readonly tuiTableFilter: import("@angular/core").InputSignal<keyof T | undefined>;
     readonly refresh$: import("rxjs").Observable<any>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     filter(item: T): boolean;
-    private get key();
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableFilterDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableFilterDirective<any>, "[tuiTableFilter]", never, { "tuiTableFilter": { "alias": "tuiTableFilter"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TuiTableFilterDirective<any>, "[tuiTableFilter]", never, { "tuiTableFilter": { "alias": "tuiTableFilter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }