@taiga-ui/addon-table 4.52.0-canary.ec0802b → 4.52.0-canary.efbd0d4

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("@angular/core").Signal<string>;
-    enabled: readonly T[];
-    readonly itemsChange: EventEmitter<T[]>;
-    readonly enabledChange: EventEmitter<T[]>;
-    set items(items: readonly T[]);
-    content: PolymorpheusContent<TuiContext<T> & {
+    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/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/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

@@ -1,18 +1,13 @@
-import { type Observable } from 'rxjs';
 import { type TuiSortChange } from '../table.options';
 import * as i0 from "@angular/core";
 export declare class TuiTableSortBy<T extends Partial<Record<keyof T, unknown>>> {
-    private readonly sortables;
     private readonly table;
-    /**
-     * @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;
+    private readonly sortables;
+    private readonly sortChange;
+    protected readonly sortOutput: import("@angular/core").EffectRef;
+    readonly tuiSortChange: import("@angular/core").OutputEmitterRef<TuiSortChange<T>>;
+    readonly tuiSortBy: import("@angular/core").InputSignal<string | keyof T | null>;
     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; }; }, { "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 setThSorter: import("@angular/core").EffectRef;
+    protected readonly setTableSorter: 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,36 +1,22 @@
-import { type AfterViewInit, EventEmitter, 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";
 import * as i1 from "./stuck.directive";
-export declare class TuiTableDirective<T extends Partial<Record<keyof T, unknown>>> implements AfterViewInit, TuiTextfieldOptions, OnChanges {
+export declare class TuiTableDirective<T extends Partial<Record<keyof T, unknown>>> implements TuiTextfieldOptions {
     private readonly options;
-    private readonly cdr;
     protected readonly nothing: undefined;
-    columns: ReadonlyArray<string | keyof T>;
-    direction: TuiSortDirection;
-    sorter: TuiComparator<T>;
-    /**
-     * @deprecated: use sortChange
-     */
-    readonly directionChange: EventEmitter<TuiSortDirection>;
-    /**
-     * @deprecated: use sortChange
-     */
-    readonly sorterChange: EventEmitter<TuiComparator<T> | null>;
-    readonly sortChange: Observable<TuiTableSortChange<T>>;
+    protected readonly computedSortChange: import("@angular/core").Signal<TuiTableSortChange<T>>;
+    protected readonly sortChangeOutput: import("@angular/core").EffectRef;
+    readonly columns: import("@angular/core").InputSignal<readonly (string | keyof T)[]>;
+    readonly size: import("@angular/core").InputSignal<"s" | "m" | "l">;
+    readonly direction: import("@angular/core").ModelSignal<TuiSortDirection>;
+    readonly sorter: import("@angular/core").ModelSignal<TuiComparator<T>>;
+    readonly sortChange: import("@angular/core").OutputEmitterRef<TuiTableSortChange<T>>;
     readonly appearance: import("@angular/core").WritableSignal<string>;
-    readonly size: import("@angular/core").WritableSignal<"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; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "sorter": { "alias": "sorter"; "required": false; "isSignal": true; }; }, { "direction": "directionChange"; "sorter": "sorterChange"; "sortChange": "sortChange"; }, never, never, true, [{ directive: typeof i1.TuiStuck; inputs: {}; outputs: {}; }]>;
 }

package/components/table/index.d.ts

@@ -1,6 +1,5 @@
 export * from './caption/caption.component';
 export * from './directives/cell.directive';
-export * from './directives/direction-order.directive';
 export * from './directives/head.directive';
 export * from './directives/resized.directive';
 export * from './directives/sort-by.directive';
@@ -9,7 +8,6 @@ export * from './directives/stuck.directive';
 export * from './directives/table.directive';
 export * from './directives/thead.directive';
 export * from './pipes/table-sort.pipe';
-export * from './providers/table.provider';
 export * from './table';
 export * from './table.options';
 export * from './table-expand/table-expand.component';

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

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

package/components/table/table.d.ts

@@ -1,6 +1,5 @@
 import { TuiTableCaption } from './caption/caption.component';
 import { TuiTableCell } from './directives/cell.directive';
-import { TuiTableDirectionOrder } from './directives/direction-order.directive';
 import { TuiTableHead } from './directives/head.directive';
 import { TuiTableResized } from './directives/resized.directive';
 import { TuiTableSortBy } from './directives/sort-by.directive';
@@ -14,4 +13,4 @@ import { TuiTableTd } from './td/td.component';
 import { TuiTableTh } from './th/th.component';
 import { TuiTableThGroup } from './th-group/th-group.component';
 import { TuiTableTr } from './tr/tr.component';
-export declare const TuiTable: readonly [typeof TuiTableDirective, typeof TuiTableCaption, typeof TuiTableTbody, typeof TuiTableThGroup, typeof TuiTableTh, typeof TuiTableTd, typeof TuiTableTr, typeof TuiTableCell, typeof TuiTableHead, typeof TuiTableSortBy, typeof TuiTableSortable, typeof TuiTableThead, typeof TuiTableResized, typeof TuiTableSortPipe, typeof TuiTableDirectionOrder, typeof TuiTableExpand];
+export declare const TuiTable: readonly [typeof TuiTableDirective, typeof TuiTableCaption, typeof TuiTableTbody, typeof TuiTableThGroup, typeof TuiTableTh, typeof TuiTableTd, typeof TuiTableTr, typeof TuiTableCell, typeof TuiTableHead, typeof TuiTableSortBy, typeof TuiTableSortable, typeof TuiTableThead, typeof TuiTableResized, typeof TuiTableSortPipe, typeof TuiTableExpand];

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

@@ -6,27 +6,11 @@ export declare const TuiSortDirection: {
 };
 export type TuiSortDirection = (typeof TuiSortDirection)[keyof typeof TuiSortDirection];
 export interface TuiSortChange<T> {
-    /**
-     * @deprecated use sortKey
-     */
-    sortBy: keyof T | null;
     sortKey: keyof T | null;
-    /**
-     * @deprecated use sortDirection
-     */
-    orderBy: TuiSortDirection;
     sortDirection: TuiSortDirection;
 }
 export interface TuiTableSortChange<T> {
-    /**
-     * @deprecated use sortComparator
-     */
-    sortBy: TuiComparator<T> | null;
     sortComparator: TuiComparator<T> | null;
-    /**
-     * @deprecated use sortDirection
-     */
-    orderBy: TuiSortDirection;
     sortDirection: TuiSortDirection;
 }
 export interface TuiTableOptions {

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;
-    sorter: TuiComparator<T> | null;
-    resizable: boolean;
-    sticky: boolean;
-    requiredSort: boolean;
+    readonly minWidth: import("@angular/core").InputSignal<number>;
+    readonly maxWidth: import("@angular/core").InputSignal<number>;
+    sorter: import("@angular/core").ModelSignal<TuiComparator<T> | null>;
+    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; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "requiredSort": { "alias": "requiredSort"; "required": false; "isSignal": true; }; }, { "sorter": "sorterChange"; }, 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

@@ -1,16 +1,12 @@
-import { type AfterContentInit } from '@angular/core';
 import { TuiTableCell } from '../directives/cell.directive';
 import { TuiTableDirective } from '../directives/table.directive';
 import * as i0 from "@angular/core";
-export declare class TuiTableTr<T extends Partial<Record<keyof T, unknown>>> implements AfterContentInit {
+export declare class TuiTableTr<T extends Partial<Record<keyof T, unknown>>> {
     private readonly cells;
     private readonly body;
-    private readonly contentReady$;
     protected readonly table: TuiTableDirective<T>;
-    protected readonly height: import("@angular/core").Signal<number>;
-    protected readonly cells$: import("rxjs").Observable<Record<string | keyof T, TuiTableCell>>;
-    protected readonly item$: import("rxjs").Observable<Record<string | keyof T, unknown>>;
-    ngAfterContentInit(): void;
+    protected readonly items: import("@angular/core").Signal<Record<string | keyof T, TuiTableCell>>;
+    protected readonly item: import("@angular/core").Signal<Record<string | keyof T, unknown>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<TuiTableTr<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<TuiTableTr<any>, "tr[tuiTr]", never, {}, {}, ["cells"], ["*"], true, never>;
 }

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 {
@@ -6,31 +5,28 @@ export interface TuiTablePaginationEvent {
     readonly size: number;
 }
 export declare class TuiTablePagination {
-    private readonly options;
-    protected readonly icons: import("@taiga-ui/core/tokens").TuiSpinIcons;
+    protected readonly options: TuiTablePaginationOptions;
+    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").ModelSignal<number>;
+    readonly size: import("@angular/core").ModelSignal<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; }; }, { "page": "pageChange"; "size": "sizeChange"; "paginationChange": "paginationChange"; }, never, never, true, never>;
 }

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/abstract-table-filter.d.ts

@@ -1,3 +1,4 @@
+import { type Signal } from '@angular/core';
 export declare abstract class AbstractTuiTableFilter<T, G> {
-    abstract filter(item: T, value: G): boolean;
+    abstract filter: Signal<(item: T, value: G) => boolean>;
 }

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

@@ -1,7 +1,7 @@
 import { AbstractTuiTableFilter } from './abstract-table-filter';
 import * as i0 from "@angular/core";
 export declare class TuiGenericFilter<T, G> extends AbstractTuiTableFilter<T, G> {
-    filter: (item: T, value: G) => boolean;
+    readonly filter: import("@angular/core").InputSignal<(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, { "filter": { "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>;
 }