@taiga-ui/addon-table 4.52.0-canary.6ee9658 → 4.52.0-canary.811ffeb

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/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/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/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 {
@@ -15,22 +14,22 @@ export declare class TuiTablePagination {
         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/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>;
 }

package/fesm2022/taiga-ui-addon-table-components-reorder.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { inject, EventEmitter, Input, Output, ChangeDetectionStrategy, Component } from '@angular/core';
+import { linkedSignal, inject, model, input, ChangeDetectionStrategy, Component } from '@angular/core';
 import { TUI_TABLE_SHOW_HIDE_MESSAGE } from '@taiga-ui/addon-table/tokens';
 import { TuiButton } from '@taiga-ui/core/components/button';
 import { TuiIcon } from '@taiga-ui/core/components/icon';
@@ -21,19 +21,22 @@ class TuiReorder {
     constructor() {
         this.dragging = false;
         this.order = new Map();
-        this.unsortedItems = [];
+        this.unsortedItems = linkedSignal({
+            source: () => this.items(),
+            computation: (items, previous) => {
+                const previousUnsortedItems = previous?.value ?? [];
+                if (items.length !== previousUnsortedItems.length ||
+                    !items.every((item) => previousUnsortedItems.includes(item))) {
+                    return items;
+                }
+                return previousUnsortedItems;
+            },
+        });
         this.options = inject(TUI_REORDER_OPTIONS);
         this.showHideText = inject(TUI_TABLE_SHOW_HIDE_MESSAGE);
-        this.enabled = [];
-        this.itemsChange = new EventEmitter();
-        this.enabledChange = new EventEmitter();
-        this.content = ({ $implicit, }) => String($implicit);
-    }
-    set items(items) {
-        if (items.length !== this.unsortedItems.length ||
-            !items.every((item) => this.unsortedItems.includes(item))) {
-            this.unsortedItems = items;
-        }
+        this.enabled = model([]);
+        this.items = model([]);
+        this.content = input(({ $implicit }) => String($implicit));
     }
     onDrag() {
         this.dragging = true;
@@ -46,21 +49,21 @@ class TuiReorder {
         this.updateItems();
     }
     isEnabled(item) {
-        return this.enabled.includes(item);
+        return this.enabled().includes(item);
     }
     getIcon(item) {
         return this.isEnabled(item) ? this.options.icons.hide : this.options.icons.show;
     }
     toggle(toggled) {
-        this.enabled = this.isEnabled(toggled)
-            ? this.enabled.filter((item) => item !== toggled)
-            : this.enabled.concat(toggled);
+        this.enabled.update((enabled) => this.isEnabled(toggled)
+            ? enabled.filter((item) => item !== toggled)
+            : enabled.concat(toggled));
         this.updateEnabled();
     }
     move(index, direction) {
         const oldIndex = this.order.get(index) ?? index;
         if ((!oldIndex && direction < 0) ||
-            (oldIndex === this.unsortedItems.length - 1 && direction > 0)) {
+            (oldIndex === this.unsortedItems().length - 1 && direction > 0)) {
             return;
         }
         const newIndex = oldIndex + direction;
@@ -71,28 +74,27 @@ class TuiReorder {
         this.updateItems();
     }
     getSortedItems() {
-        const items = new Array(this.unsortedItems.length);
-        this.unsortedItems.forEach((item, index) => {
+        const unsortedItems = this.unsortedItems();
+        const items = Array.from({ length: unsortedItems.length });
+        unsortedItems.forEach((item, index) => {
             items[this.order.get(index) ?? index] = item;
         });
         return items;
     }
     updateItems() {
-        this.itemsChange.emit(this.getSortedItems());
+        this.items.set(this.getSortedItems());
         this.updateEnabled();
     }
     updateEnabled() {
-        const enabled = this.getSortedItems().filter((item) => this.isEnabled(item));
-        this.enabled = enabled;
-        this.enabledChange.emit(enabled);
+        this.enabled.set(this.getSortedItems().filter((item) => this.isEnabled(item)));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: TuiReorder, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.15", type: TuiReorder, isStandalone: true, selector: "tui-reorder", inputs: { enabled: "enabled", items: "items", content: "content" }, outputs: { itemsChange: "itemsChange", enabledChange: "enabledChange" }, host: { listeners: { "focusout.stop": "(0)", "pointerdown.zoneless": "onDrag()", "document:pointerup.zoneless": "onDrop()" } }, providers: [
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.15", type: TuiReorder, isStandalone: true, selector: "tui-reorder", inputs: { enabled: { classPropertyName: "enabled", publicName: "enabled", isSignal: true, isRequired: false, transformFunction: null }, items: { classPropertyName: "items", publicName: "items", isSignal: true, isRequired: false, transformFunction: null }, content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { enabled: "enabledChange", items: "itemsChange" }, host: { listeners: { "focusout.stop": "(0)", "pointerdown.zoneless": "onDrag()", "document:pointerup.zoneless": "onDrop()" } }, providers: [
             {
                 provide: TUI_TILES_REORDER,
                 useValue: tuiTilesShift,
             },
-        ], ngImport: i0, template: "<tui-tiles\n    class=\"t-wrapper\"\n    [(order)]=\"order\"\n>\n    @for (item of unsortedItems; track item) {\n        <tui-tile [style.order]=\"order.get($index)\">\n            <div\n                class=\"t-item\"\n                [class.t-item_disabled]=\"!isEnabled(item)\"\n            >\n                <div\n                    tuiTileHandle\n                    class=\"t-draggable\"\n                >\n                    <tui-icon\n                        class=\"t-icon\"\n                        [icon]=\"options.icons.drag\"\n                    />\n                    <ng-container *polymorpheusOutlet=\"content as template; context: {$implicit: item, index: $index}\">\n                        {{ template }}\n                    </ng-container>\n                </div>\n                <button\n                    appearance=\"icon\"\n                    size=\"xs\"\n                    tuiIconButton\n                    type=\"button\"\n                    class=\"t-button\"\n                    [iconStart]=\"getIcon(item)\"\n                    (click)=\"toggle(item)\"\n                    (keydown.arrowDown.prevent)=\"move($index, 1)\"\n                    (keydown.arrowUp.prevent)=\"move($index, -1)\"\n                >\n                    {{ showHideText() }}\n                </button>\n            </div>\n        </tui-tile>\n    }\n</tui-tiles>\n", styles: [":host{display:block;font:var(--tui-font-text-s);padding:.5rem 0;-webkit-user-select:none;user-select:none}.t-wrapper{grid-auto-rows:2rem}.t-draggable{cursor:ns-resize;flex:1 1 auto}.t-item{transition-property:background;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;display:flex;block-size:2rem;align-items:center;padding:0 .75rem;background:var(--tui-background-base)}.t-item_disabled{opacity:var(--tui-disabled-opacity)}.t-item_disabled .t-button{color:var(--tui-text-primary);opacity:1}.t-item:hover{background:var(--tui-background-base-alt)}.t-item:hover .t-button{opacity:1}.t-icon{margin-inline-end:.5rem;color:var(--tui-text-tertiary)}.t-icon:before{font-size:1rem}.t-button{transition-property:opacity;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;margin-inline-start:auto;opacity:0}.t-button:focus{opacity:1}\n"], dependencies: [{ kind: "directive", type: PolymorpheusOutlet, selector: "[polymorpheusOutlet]", inputs: ["polymorpheusOutlet", "polymorpheusOutletContext"] }, { kind: "directive", type: TuiButton, selector: "a[tuiButton],button[tuiButton],a[tuiIconButton],button[tuiIconButton]", inputs: ["size"] }, { kind: "component", type: TuiIcon, selector: "tui-icon:not([tuiBadge])", inputs: ["background"] }, { kind: "component", type: i1.TuiTilesComponent, selector: "tui-tiles", inputs: ["debounce", "order"], outputs: ["orderChange"] }, { kind: "component", type: i1.TuiTile, selector: "tui-tile", inputs: ["width", "height"] }, { kind: "directive", type: i1.TuiTileHandle, selector: "[tuiTileHandle]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+        ], ngImport: i0, template: "<tui-tiles\n    class=\"t-wrapper\"\n    [(order)]=\"order\"\n>\n    @for (item of unsortedItems(); track item) {\n        <tui-tile [style.order]=\"order.get($index)\">\n            <div\n                class=\"t-item\"\n                [class.t-item_disabled]=\"!isEnabled(item)\"\n            >\n                <div\n                    tuiTileHandle\n                    class=\"t-draggable\"\n                >\n                    <tui-icon\n                        class=\"t-icon\"\n                        [icon]=\"options.icons.drag\"\n                    />\n                    <ng-container\n                        *polymorpheusOutlet=\"content() as template; context: {$implicit: item, index: $index}\"\n                    >\n                        {{ template }}\n                    </ng-container>\n                </div>\n                <button\n                    appearance=\"icon\"\n                    size=\"xs\"\n                    tuiIconButton\n                    type=\"button\"\n                    class=\"t-button\"\n                    [iconStart]=\"getIcon(item)\"\n                    (click)=\"toggle(item)\"\n                    (keydown.arrowDown.prevent)=\"move($index, 1)\"\n                    (keydown.arrowUp.prevent)=\"move($index, -1)\"\n                >\n                    {{ showHideText() }}\n                </button>\n            </div>\n        </tui-tile>\n    }\n</tui-tiles>\n", styles: [":host{display:block;font:var(--tui-font-text-s);padding:.5rem 0;-webkit-user-select:none;user-select:none}.t-wrapper{grid-auto-rows:2rem}.t-draggable{cursor:ns-resize;flex:1 1 auto}.t-item{transition-property:background;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;display:flex;block-size:2rem;align-items:center;padding:0 .75rem;background:var(--tui-background-base)}.t-item_disabled{opacity:var(--tui-disabled-opacity)}.t-item_disabled .t-button{color:var(--tui-text-primary);opacity:1}.t-item:hover{background:var(--tui-background-base-alt)}.t-item:hover .t-button{opacity:1}.t-icon{margin-inline-end:.5rem;color:var(--tui-text-tertiary)}.t-icon:before{font-size:1rem}.t-button{transition-property:opacity;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;margin-inline-start:auto;opacity:0}.t-button:focus{opacity:1}\n"], dependencies: [{ kind: "directive", type: PolymorpheusOutlet, selector: "[polymorpheusOutlet]", inputs: ["polymorpheusOutlet", "polymorpheusOutletContext"] }, { kind: "directive", type: TuiButton, selector: "a[tuiButton],button[tuiButton],a[tuiIconButton],button[tuiIconButton]", inputs: ["size"] }, { kind: "component", type: TuiIcon, selector: "tui-icon:not([tuiBadge])", inputs: ["background"] }, { kind: "component", type: i1.TuiTilesComponent, selector: "tui-tiles", inputs: ["debounce", "order"], outputs: ["orderChange"] }, { kind: "component", type: i1.TuiTile, selector: "tui-tile", inputs: ["width", "height"] }, { kind: "directive", type: i1.TuiTileHandle, selector: "[tuiTileHandle]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: TuiReorder, decorators: [{
             type: Component,
@@ -105,18 +107,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", ngImpo
                         '(focusout.stop)': '(0)',
                         '(pointerdown.zoneless)': 'onDrag()',
                         '(document:pointerup.zoneless)': 'onDrop()',
-                    }, template: "<tui-tiles\n    class=\"t-wrapper\"\n    [(order)]=\"order\"\n>\n    @for (item of unsortedItems; track item) {\n        <tui-tile [style.order]=\"order.get($index)\">\n            <div\n                class=\"t-item\"\n                [class.t-item_disabled]=\"!isEnabled(item)\"\n            >\n                <div\n                    tuiTileHandle\n                    class=\"t-draggable\"\n                >\n                    <tui-icon\n                        class=\"t-icon\"\n                        [icon]=\"options.icons.drag\"\n                    />\n                    <ng-container *polymorpheusOutlet=\"content as template; context: {$implicit: item, index: $index}\">\n                        {{ template }}\n                    </ng-container>\n                </div>\n                <button\n                    appearance=\"icon\"\n                    size=\"xs\"\n                    tuiIconButton\n                    type=\"button\"\n                    class=\"t-button\"\n                    [iconStart]=\"getIcon(item)\"\n                    (click)=\"toggle(item)\"\n                    (keydown.arrowDown.prevent)=\"move($index, 1)\"\n                    (keydown.arrowUp.prevent)=\"move($index, -1)\"\n                >\n                    {{ showHideText() }}\n                </button>\n            </div>\n        </tui-tile>\n    }\n</tui-tiles>\n", styles: [":host{display:block;font:var(--tui-font-text-s);padding:.5rem 0;-webkit-user-select:none;user-select:none}.t-wrapper{grid-auto-rows:2rem}.t-draggable{cursor:ns-resize;flex:1 1 auto}.t-item{transition-property:background;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;display:flex;block-size:2rem;align-items:center;padding:0 .75rem;background:var(--tui-background-base)}.t-item_disabled{opacity:var(--tui-disabled-opacity)}.t-item_disabled .t-button{color:var(--tui-text-primary);opacity:1}.t-item:hover{background:var(--tui-background-base-alt)}.t-item:hover .t-button{opacity:1}.t-icon{margin-inline-end:.5rem;color:var(--tui-text-tertiary)}.t-icon:before{font-size:1rem}.t-button{transition-property:opacity;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;margin-inline-start:auto;opacity:0}.t-button:focus{opacity:1}\n"] }]
-        }], propDecorators: { enabled: [{
-                type: Input
-            }], itemsChange: [{
-                type: Output
-            }], enabledChange: [{
-                type: Output
-            }], items: [{
-                type: Input
-            }], content: [{
-                type: Input
-            }] } });
+                    }, template: "<tui-tiles\n    class=\"t-wrapper\"\n    [(order)]=\"order\"\n>\n    @for (item of unsortedItems(); track item) {\n        <tui-tile [style.order]=\"order.get($index)\">\n            <div\n                class=\"t-item\"\n                [class.t-item_disabled]=\"!isEnabled(item)\"\n            >\n                <div\n                    tuiTileHandle\n                    class=\"t-draggable\"\n                >\n                    <tui-icon\n                        class=\"t-icon\"\n                        [icon]=\"options.icons.drag\"\n                    />\n                    <ng-container\n                        *polymorpheusOutlet=\"content() as template; context: {$implicit: item, index: $index}\"\n                    >\n                        {{ template }}\n                    </ng-container>\n                </div>\n                <button\n                    appearance=\"icon\"\n                    size=\"xs\"\n                    tuiIconButton\n                    type=\"button\"\n                    class=\"t-button\"\n                    [iconStart]=\"getIcon(item)\"\n                    (click)=\"toggle(item)\"\n                    (keydown.arrowDown.prevent)=\"move($index, 1)\"\n                    (keydown.arrowUp.prevent)=\"move($index, -1)\"\n                >\n                    {{ showHideText() }}\n                </button>\n            </div>\n        </tui-tile>\n    }\n</tui-tiles>\n", styles: [":host{display:block;font:var(--tui-font-text-s);padding:.5rem 0;-webkit-user-select:none;user-select:none}.t-wrapper{grid-auto-rows:2rem}.t-draggable{cursor:ns-resize;flex:1 1 auto}.t-item{transition-property:background;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;display:flex;block-size:2rem;align-items:center;padding:0 .75rem;background:var(--tui-background-base)}.t-item_disabled{opacity:var(--tui-disabled-opacity)}.t-item_disabled .t-button{color:var(--tui-text-primary);opacity:1}.t-item:hover{background:var(--tui-background-base-alt)}.t-item:hover .t-button{opacity:1}.t-icon{margin-inline-end:.5rem;color:var(--tui-text-tertiary)}.t-icon:before{font-size:1rem}.t-button{transition-property:opacity;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;margin-inline-start:auto;opacity:0}.t-button:focus{opacity:1}\n"] }]
+        }] });
 
 /**
  * Generated bundle index. Do not edit.