@sd-angular/core 19.0.0-beta.8 → 19.0.0-beta.81

package/components/table/src/directives/sd-table-filter-def.directive.d.ts

@@ -4,13 +4,11 @@ interface Context {
     externalFilter?: Record<string, any>;
 }
 export declare class SdTableFilterDefDirective {
-    templateRef?: TemplateRef<any> | undefined;
     static ngTemplateContextGuard(dir: Context, ctx: unknown): ctx is Context;
-    sdTableFilterDef?: string;
-    defaultShowing?: boolean;
-    set _defaultShowing(val: boolean | '' | undefined);
-    constructor(templateRef?: TemplateRef<any> | undefined);
+    sdTableFilterDef: import("@angular/core").InputSignal<string | undefined>;
+    defaultShowing: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    templateRef: TemplateRef<any> | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<SdTableFilterDefDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableFilterDefDirective, "[sdTableFilterDef]", never, { "sdTableFilterDef": { "alias": "sdTableFilterDef"; "required": false; }; "_defaultShowing": { "alias": "defaultShowing"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableFilterDefDirective, "[sdTableFilterDef]", never, { "sdTableFilterDef": { "alias": "sdTableFilterDef"; "required": false; "isSignal": true; }; "defaultShowing": { "alias": "defaultShowing"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 export {};

package/components/table/src/directives/sd-table-footer-def.directive.d.ts

@@ -1,9 +1,8 @@
 import { TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class SdMaterialFooterDefDirective {
+    sdTableFooterDef: import("@angular/core").InputSignal<string | undefined>;
     templateRef: TemplateRef<any>;
-    sdTableFooterDef?: string;
-    constructor(templateRef: TemplateRef<any>);
     static ɵfac: i0.ɵɵFactoryDeclaration<SdMaterialFooterDefDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SdMaterialFooterDefDirective, "[sdTableFooterDef]", never, { "sdTableFooterDef": { "alias": "sdTableFooterDef"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdMaterialFooterDefDirective, "[sdTableFooterDef]", never, { "sdTableFooterDef": { "alias": "sdTableFooterDef"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/components/table/src/directives/sd-table-title-def.directive.d.ts

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

package/components/table/src/directives/sticky-shadow.directive.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+/**
+ * Directive thêm hiệu ứng đổ bóng (elevation-2) vào cột sticky cuối cùng bên trái
+ * và cột sticky đầu tiên bên phải, tạo ngăn cách trực quan với phần được scroll.
+ *
+ * Chỉ dùng nội bộ trong sd-table, không chìa ra ngoài.
+ *
+ * Gắn vào scroll container của table:
+ * @example
+ * <div class="c-table" stickyShadow>...</div>
+ */
+export declare class StickyShadowDirective {
+    #private;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<StickyShadowDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StickyShadowDirective, "[stickyShadow]", never, {}, {}, never, never, true, never>;
+}

package/components/table/src/models/table-column.model.d.ts

@@ -1,15 +1,35 @@
-import { TemplateRef } from '@angular/core';
+import { Signal, TemplateRef } from '@angular/core';
 import { SdBadge } from '@sd-angular/core/components/badge';
 import { SdSearch } from '@sd-angular/core/forms';
-import { SdColor, SdOperator } from '@sd-angular/core/utilities';
+import { SdNestedKeyOf, SdOperator } from '@sd-angular/core/utilities';
+import { SdUnwrapSignal } from '@sd-angular/core/utilities/models';
 export type SdTableColumn<T = any> = SdTableColumnText<T> | SdTableColumnNumber<T> | SdTableColumnBool<T> | SdTableColumnDate<T> | SdTableColumnValues<T> | SdTableColumnLazyValues<T> | SdTableColumnChildren<T>;
 export type SdTableColumnTransformFunc<T = any> = (value: any, rowData: T, args?: {
     isExport?: boolean;
 }) => string | Promise<string>;
-interface SdTableColumnBase<T = any> {
+interface Badge {
+    type?: SdUnwrapSignal<SdBadge['type']>;
+    color?: SdUnwrapSignal<SdBadge['color']>;
+    icon?: SdUnwrapSignal<SdBadge['icon']>;
+    title?: SdUnwrapSignal<SdBadge['title']>;
+}
+type UseBadgeFunc<T = any> = (value: any, rowData: T) => Badge;
+type UseBadgeValuesFunc<T = any, K = any> = (value: any, rowData: T, items: K[]) => Badge;
+interface ColumnTitleOption {
     title: string;
-    titleHtml?: string;
-    description?: string;
+    templateRef?: TemplateRef<any>;
+}
+interface ColumnCellOption {
+    templateRef?: TemplateRef<any>;
+    copiable?: boolean;
+    truncate?: {
+        enable?: boolean;
+        type?: 'more' | 'tooltip';
+    };
+}
+interface SdTableColumnBase<T = any> {
+    title: string | ColumnTitleOption;
+    cell?: ColumnCellOption;
     width?: string;
     minWidth?: string;
     maxWidth?: string;
@@ -17,13 +37,6 @@ interface SdTableColumnBase<T = any> {
     invisible?: boolean;
     fixed?: boolean;
     align?: 'right';
-    useBadge?: (value: any, rowData: T) => {
-        type?: SdBadge['type'];
-        color?: SdBadge['color'];
-        icon?: SdBadge['icon'];
-        title?: SdBadge['title'];
-    };
-    cellStyle?: (value: any, rowData: T) => Record<string, string>;
     htmlTemplate?: (value: any, rowData: T) => string;
     transform?: SdTableColumnTransformFunc<T>;
     tooltip?: (value: any, rowData: T) => string;
@@ -37,67 +50,63 @@ interface SdTableColumnBase<T = any> {
             enable?: boolean;
             list?: SdOperator[];
         };
+        filterDef?: TemplateRef<any>;
     };
     export?: {
         disabled?: boolean;
+        description?: string;
     };
-    cellDef?: TemplateRef<any>;
-    copiable?: boolean;
 }
 interface SdTableColumnText<T = any> extends SdTableColumnBase<T> {
-    field: Extract<keyof T, string>;
+    field: SdNestedKeyOf<T>;
     type: 'string';
-    badge?: (value: any, rowData: T) => SdColor;
-    badgeIcon?: (value: any, rowData: T) => string;
-    badgeType?: SdBadge['type'];
+    useBadge?: UseBadgeFunc<T>;
 }
 interface SdTableColumnNumber<T = any> extends SdTableColumnBase<T> {
-    field: Extract<keyof T, string>;
+    field: SdNestedKeyOf<T>;
     type: 'number';
-    badge?: (value: any, rowData: T) => SdColor;
-    badgeIcon?: (value: any, rowData: T) => string;
-    badgeType?: SdBadge['type'];
+    useBadge?: UseBadgeFunc<T>;
     filter?: SdTableColumnBase['filter'] & {
         type?: 'split-number';
     };
 }
 interface SdTableColumnBool<T = any> extends SdTableColumnBase<T> {
-    field: Extract<keyof T, string>;
+    field: SdNestedKeyOf<T>;
     type: 'boolean';
+    useBadge?: UseBadgeFunc<T>;
     option?: {
         displayOnTrue?: string;
         displayOnFalse?: string;
     };
 }
 interface SdTableColumnDate<T = any> extends SdTableColumnBase<T> {
-    field: Extract<keyof T, string>;
+    field: SdNestedKeyOf<T>;
     type: 'date' | 'datetime' | 'time';
+    useBadge?: UseBadgeFunc<T>;
     filter?: SdTableColumnBase['filter'] & {
         type?: 'daterange' | 'date' | 'split-date';
     };
 }
-export interface SdTableColumnValues<T = any> extends SdTableColumnBase<T> {
-    field: Extract<keyof T, string>;
+export interface SdTableColumnValues<T = any, K = Record<string, any>> extends SdTableColumnBase<T> {
+    field: SdNestedKeyOf<T>;
     type: 'values';
-    badge?: (value: any, rowData: T) => SdColor;
-    badgeIcon?: (value: any, rowData: T) => string;
-    badgeType?: SdBadge['type'];
+    useBadge?: UseBadgeValuesFunc<T, K>;
     option: {
-        valueField: string;
-        displayField: string;
-        items: any[] | (() => Promise<any[]>);
-        selection?: 'AUTOCOMPLETE' | 'MULTIPLE' | 'MULTIPLEAUTOCOMPLETE';
+        items: K[] | Signal<K[]> | (() => Promise<K[]>);
+        valueField: SdNestedKeyOf<K>;
+        displayField: SdNestedKeyOf<K>;
+        selection?: 'MULTIPLE';
     };
 }
-export interface SdTableColumnLazyValues<T = any> extends SdTableColumnBase<T> {
-    field: Extract<keyof T, string>;
+export interface SdTableColumnLazyValues<T = any, K = Record<string, any>> extends SdTableColumnBase<T> {
+    field: SdNestedKeyOf<T>;
     type: 'lazy-values';
+    useBadge?: UseBadgeFunc<T>;
     option: {
-        valueField: string;
-        displayField: string;
-        items: SdSearch;
-        views?: (values: string[]) => Promise<any[]>;
-        mapValue?: (value: any, rowData?: T) => string | string[];
+        items: SdSearch<K>;
+        valueField: SdNestedKeyOf<K>;
+        displayField: SdNestedKeyOf<K>;
+        views?: (values: string[]) => Promise<K[]>;
         selection?: 'MULTIPLE';
     };
 }

package/components/table/src/models/table-command.model.d.ts

@@ -1,9 +1,13 @@
-import { SdColor } from '@sd-angular/core/utilities/models';
+import { MaterialIconFontSet, SdColor } from '@sd-angular/core/utilities/models';
+export interface SdTableCommandOption<T = any> {
+    align?: 'left' | 'right';
+    commands?: SdTableCommand<T>[];
+}
 export type SdTableCommand<T = any> = SdTableCommandNormal<T> | SdTableCommandChildren<T>;
 export interface SdTableCommandNormal<T = any> {
     color?: SdColor;
     icon?: string | ((rowData: T) => string);
-    fontSet?: 'material-icons' | 'material-icons-outlined' | 'material-icons-round' | 'material-icons-sharp';
+    fontSet?: MaterialIconFontSet;
     title?: string | ((rowData: T) => string);
     disabled?: boolean | ((rowData: T) => boolean);
     hidden?: boolean | ((rowData: T) => boolean | Promise<boolean>);
@@ -12,7 +16,7 @@ export interface SdTableCommandNormal<T = any> {
 }
 export interface SdTableCommandChildren<T = any> {
     icon?: string | ((rowData: T) => string);
-    fontSet?: 'material-icons' | 'material-icons-outlined' | 'material-icons-round' | 'material-icons-sharp';
+    fontSet?: MaterialIconFontSet;
     title?: string | ((rowData: T) => string);
     disabled?: boolean | ((rowData: T) => boolean);
     hidden?: boolean | ((rowData: T) => boolean | Promise<boolean>);

package/components/table/src/models/table-item.model.d.ts

@@ -1,4 +1,5 @@
 import { SdBadge } from '@sd-angular/core/components/badge';
+import { SdUnwrapSignal } from '@sd-angular/core/utilities/models';
 export interface SdTableMetaSelector {
     selectable?: boolean;
     isSelected?: boolean;
@@ -12,10 +13,10 @@ export interface SdTableMetaExpand {
 export interface SdTableDisplay {
     tooltip?: string;
     badge?: {
-        type: SdBadge['type'] | undefined | null;
-        color: SdBadge['color'] | undefined | null;
-        icon?: string | undefined | null;
-        title?: string | number | null | undefined;
+        type: SdUnwrapSignal<SdBadge['type']>;
+        color: SdUnwrapSignal<SdBadge['color']>;
+        icon?: SdUnwrapSignal<SdBadge['icon']>;
+        title?: SdUnwrapSignal<SdBadge['title']>;
     };
     cellStyle?: Record<string, string>;
     data: string | number | undefined | null;

package/components/table/src/models/table-option-config.model.d.ts

@@ -7,6 +7,8 @@ export interface OriginColumn {
     title: string;
     width?: string;
     invisible?: boolean;
+    fixed?: boolean;
+    truncate?: boolean;
 }
 export interface ConfiguredColumn {
     origin: OriginColumn;
@@ -14,6 +16,7 @@ export interface ConfiguredColumn {
     width?: string;
     invisible?: boolean;
     fixed?: boolean;
+    truncate?: boolean;
 }
 export interface ConfiguredTable {
     columns?: ConfiguredColumn[];

package/components/table/src/models/table-option-export.model.d.ts

@@ -1,3 +1,4 @@
+import { SdNestedKeyOf } from '@sd-angular/core/utilities';
 import { SdTableFilterRequest } from '../services/table-filter/table-filter.model';
 export type SdTableOptionExport<T = any> = SdTableOptionExportDefault<T> | SdTableOptionExportCustom;
 export interface SdTableOptionExportDefault<T = any> {
@@ -22,7 +23,7 @@ export interface SdTableOptionExportCustom {
     onExport: (filterRequest: SdTableFilterRequest) => Promise<void>;
 }
 export interface SdTableOptionExportColumn<T = any> {
-    field: Extract<keyof T, string>;
+    field: SdNestedKeyOf<T>;
     title: string;
     description?: string;
     width?: string;
@@ -35,7 +36,7 @@ export interface SdTableOptionExportSheet<T = any> {
     name: string;
     items: T[] | (() => T[] | Promise<T[]>);
     headers: {
-        value: Extract<keyof T, string>;
+        value: SdNestedKeyOf<T>;
         display: string;
     }[];
 }

package/components/table/src/models/table-option-selector.model.d.ts

@@ -1,4 +1,5 @@
 import { SdButton } from '@sd-angular/core/components/button';
+import { SdUnwrapSignal } from '@sd-angular/core/utilities/models';
 export interface SdTableOptionSelector<T = any> {
     visible?: boolean;
     single?: boolean;
@@ -7,26 +8,32 @@ export interface SdTableOptionSelector<T = any> {
     onSelect?: (rowData?: T, selectedItems?: T[]) => void;
     onSelectAll?: (selectedItems: T[]) => void;
     disabled?: (rowData?: T, selectedItems?: T[]) => boolean;
+    /**
+     * Predicate để tự động pre-select item sau mỗi lần load.
+     * Table sẽ gọi hàm này cho từng item và set isSelected = true nếu trả về true.
+     * Dùng khi cần programmatically set selected items từ bên ngoài.
+     */
+    defaultSelected?: (rowData: T) => boolean;
 }
 export type SdTableAction<T = any> = SdTableActionNormal<T> | SdTableActionChildren<T>;
 export interface SdTableActionNormal<T = any> {
     icon?: string;
-    fontSet?: SdButton['fontSet'];
-    tooltip?: SdButton['tooltip'];
-    title?: SdButton['title'];
-    color?: SdButton['color'];
-    type?: SdButton['type'];
+    fontSet?: SdUnwrapSignal<SdButton['fontSet']>;
+    tooltip?: SdUnwrapSignal<SdButton['tooltip']>;
+    title?: SdUnwrapSignal<SdButton['title']>;
+    color?: SdUnwrapSignal<SdButton['color']>;
+    type?: SdUnwrapSignal<SdButton['type']>;
     hidden?: boolean | ((rowData?: T) => boolean);
     isGrouped?: boolean;
     click: (selectedItems?: T[]) => void;
 }
 interface SdTableActionChildren<T = any> {
     icon?: string;
-    fontSet?: SdButton['fontSet'];
-    tooltip?: SdButton['tooltip'];
-    title?: SdButton['title'];
-    color?: SdButton['color'];
-    type?: SdButton['type'];
+    fontSet?: SdUnwrapSignal<SdButton['fontSet']>;
+    tooltip?: SdUnwrapSignal<SdButton['tooltip']>;
+    title?: SdUnwrapSignal<SdButton['title']>;
+    color?: SdUnwrapSignal<SdButton['color']>;
+    type?: SdUnwrapSignal<SdButton['type']>;
     hidden?: boolean | ((rowData?: T) => boolean);
     isGrouped?: boolean;
     children: SdTableActionNormal<T>[];

package/components/table/src/models/table-option.model.d.ts

@@ -1,16 +1,16 @@
-import { SdTableColumn } from './table-column.model';
-import { SdTableCommand } from './table-command.model';
+import { SdPagingReq } from '@sd-angular/core/utilities';
 import { SdTableFilterRequest, SdTableOptionFilter } from '../services/table-filter/table-filter.model';
+import { SdTableColumn } from './table-column.model';
+import { SdTableCommand, SdTableCommandOption } from './table-command.model';
+import { TableOptionConfig } from './table-option-config.model';
+import { SdTableOptionExpand } from './table-option-expand.model';
 import { SdTableOptionExport } from './table-option-export.model';
+import { SdTableOptionGroup } from './table-option-group.model';
+import { SdTableOptionPaginate } from './table-option-paginate.model';
 import { SdTableOptionReload } from './table-option-reload.model';
-import { SdTableOptionExpand } from './table-option-expand.model';
 import { SdTableOptionSelector } from './table-option-selector.model';
-import { SdTableOptionStyle } from './table-option-style.model';
-import { SdTableOptionGroup } from './table-option-group.model';
 import { SdTableOptionSort } from './table-option-sort.model';
-import { SdTableOptionPaginate } from './table-option-paginate.model';
-import { TableOptionConfig } from './table-option-config.model';
-import { SdPagingReq } from '@sd-angular/core/utilities';
+import { SdTableOptionStyle } from './table-option-style.model';
 export type SdTableOption<T = any> = SdTableLocalOption<T> | SdTableServerOption<T>;
 interface SdTableBaseOption<T = any> {
     key?: string;
@@ -23,7 +23,14 @@ interface SdTableBaseOption<T = any> {
     export?: SdTableOptionExport<T>;
     group?: SdTableOptionGroup<T>;
     filter?: SdTableOptionFilter;
+    rowReorder?: {
+        enabled?: boolean;
+        onChange?: (newRows: T[], movedItem: T, fromIndex: number, toIndex: number) => void;
+        icon?: string;
+        disabled?: (row: T, index: number) => boolean;
+    };
     commands?: SdTableCommand<T>[];
+    command?: SdTableCommandOption<T>;
     columns: SdTableColumn<T>[];
     style?: SdTableOptionStyle<T>;
 }

package/components/table/src/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './table-export/table-export.service';
+export * from './table-format/table-format.service';
+export * from './config.service';

package/components/table/src/services/table-export/table-export.service.d.ts

@@ -0,0 +1,26 @@
+import { SdExcelColumn } from '@sd-angular/core/services';
+import { ConfiguredTableResult } from '../../models/table-option-config.model';
+import { SdTableOption } from '../../models/table-option.model';
+import { SdTableFilterRequest } from '../table-filter/table-filter.model';
+import * as i0 from "@angular/core";
+export interface SdTableExportContext<T = any> {
+    option: SdTableOption<T>;
+    configuration?: ConfiguredTableResult;
+    total: number;
+    cacheObjValues: Record<string, Record<string, string>>;
+    fetchChunk: (pageNumber: number, pageSize: number) => Promise<T[] | {
+        items: any[];
+        total: number;
+    }>;
+    getFilterInfo: () => SdTableFilterRequest;
+}
+export declare class TableExportService {
+    #private;
+    exporting: import("@angular/core").WritableSignal<boolean>;
+    exportTitle: import("@angular/core").WritableSignal<string>;
+    exportExcel: (context: SdTableExportContext, columns?: SdExcelColumn[]) => Promise<void>;
+    exportCSV: (context: SdTableExportContext, columns?: SdExcelColumn[]) => Promise<void>;
+    exportCustom: (context: SdTableExportContext) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableExportService>;
+}

package/components/table/src/services/table-filter/table-filter.model.d.ts

@@ -1,8 +1,8 @@
-import { Observable } from 'rxjs';
-import { SdTableColumn } from '../../models/table-column.model';
 import { TemplateRef } from '@angular/core';
 import { SdSearch } from '@sd-angular/core/forms';
-import { SdOperator, SdOrder, SdPagingReq } from '@sd-angular/core/utilities';
+import { SdNestedKeyOf, SdOperator, SdOrder, SdPagingReq } from '@sd-angular/core/utilities';
+import { Observable } from 'rxjs';
+import { SdTableColumn } from '../../models/table-column.model';
 export interface SdTableQuickFilter {
     code: string;
     columnFilter: Record<string, any>;
@@ -19,8 +19,8 @@ export interface TableFilterValue {
     filtered?: boolean;
 }
 export interface SdTableFilterRequest<T = any> {
-    columnOperator: Record<string, SdOperator>;
-    rawColumnFilter: Record<keyof T, any>;
+    columnOperator: Record<SdNestedKeyOf<T>, SdOperator>;
+    rawColumnFilter: Record<SdNestedKeyOf<T>, any>;
     rawExternalFilter: Record<string, any>;
     pageNumber: number;
     pageSize: number;
@@ -68,6 +68,7 @@ interface BaseFilter<TData = any> {
     hidden?: boolean;
     defaultOperator?: SdOperator;
     data?: TData;
+    onChange?: (value: any) => void;
 }
 interface TextFilter<TData = any> extends BaseFilter<TData> {
     type: 'string';

package/components/table/src/services/table-format/table-format.service.d.ts

@@ -0,0 +1,16 @@
+import { SdTableColumn } from '../../models/table-column.model';
+import { SdTableItem } from '../../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class TableFormatService {
+    #private;
+    /**
+     * Tải và cache các giá trị từ điển cho cột 'values'
+     */
+    loadValues(columns: SdTableColumn[], cacheValues: Record<string, any[]>, cacheObjValues: Record<string, Record<string, string>>): Promise<void>;
+    /**
+     * Chuyển đổi dữ liệu thô thành SdTableItem kèm các thiết lập hiển thị (Display Meta)
+     */
+    format<T = any>(rawItems: T[], columns: SdTableColumn[], cacheValues: Record<string, any[]>, cacheObjValues: Record<string, Record<string, string>>): Promise<SdTableItem<T>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableFormatService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableFormatService>;
+}

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

@@ -1,19 +1,20 @@
-import { AfterViewInit, ChangeDetectorRef, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
 import { MatPaginator, MatPaginatorIntl } from '@angular/material/paginator';
 import { MatSort } from '@angular/material/sort';
 import { MatTable } from '@angular/material/table';
-import { SdExcelColumn, SdExcelService, SdNotifyService } from '@sd-angular/core/services';
+import { SdExcelColumn } from '@sd-angular/core/services';
 import { SdTabelCellDefDirective } from './directives/sd-table-cell-def.directive';
 import { SdMaterialSubInformationDefDirective } from './directives/sd-table-expand-def.directive';
 import { SdTableFilterDefDirective } from './directives/sd-table-filter-def.directive';
 import { SdMaterialFooterDefDirective } from './directives/sd-table-footer-def.directive';
+import { SdTableTitleDefDirective } from './directives/sd-table-title-def.directive';
 import { SdTableColumn } from './models/table-column.model';
 import { SdTableOption } from './models/table-option.model';
-import { TableFilterRegister } from './services/table-filter/table-filter.model';
+import { SdTableFilterRequest, TableFilterRegister } from './services/table-filter/table-filter.model';
+import { CdkDrag, CdkDragDrop, CdkDropList } from '@angular/cdk/drag-drop';
 import { SdBaseSecureComponent } from '@sd-angular/core/components/base';
 import { SdQuickAction } from '@sd-angular/core/components/quick-action';
 import { SdScrollDirective } from '@sd-angular/core/directives';
-import { SdFormatNumberPipe } from '@sd-angular/core/pipes';
 import { SdOperator } from '@sd-angular/core/utilities';
 import { ExternalFilterComponent } from './components';
 import { ConfigComponent } from './components/config/config.component';
@@ -21,8 +22,6 @@ import { SdPopupExport } from './components/popup-export/popup-export.component'
 import { ISdTableConfiguration } from './configurations';
 import { SdTableItem } from './models/table-item.model';
 import { ConfiguredTableResult } from './models/table-option-config.model';
-import { ConfigService } from './services/config.service';
-import { SdTableFilterService } from './services/table-filter/table-filter.service';
 import * as i0 from "@angular/core";
 export declare class MatPaginatorIntlCro extends MatPaginatorIntl {
     firstPageLabel: string;
@@ -36,60 +35,51 @@ export declare class MatPaginatorIntlCro extends MatPaginatorIntl {
 }
 export declare class SdTable<T = unknown> extends SdBaseSecureComponent implements OnInit, AfterViewInit, OnDestroy {
     #private;
-    private ref;
-    private formatNumberPipe;
-    tableConfiguration: ISdTableConfiguration | undefined;
-    private configService;
-    private excelService;
-    private notifyService;
-    private gridFilterService;
-    autoId?: string;
-    set _autoId(val: string | undefined | null);
-    table?: MatTable<any>;
-    configComponent?: ConfigComponent;
-    sdPopupExport?: SdPopupExport;
-    scroll?: SdScrollDirective;
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
+    autoId: import("@angular/core").Signal<string | undefined>;
+    option: import("@angular/core").InputSignal<SdTableOption<T>>;
+    table: import("@angular/core").Signal<MatTable<any> | undefined>;
+    configComponent: import("@angular/core").Signal<ConfigComponent | undefined>;
+    sdPopupExport: import("@angular/core").Signal<SdPopupExport | undefined>;
+    scroll: import("@angular/core").Signal<SdScrollDirective | undefined>;
+    quickAction: import("@angular/core").Signal<SdQuickAction | undefined>;
+    externalFilter: import("@angular/core").Signal<ExternalFilterComponent | undefined>;
+    paginator: import("@angular/core").Signal<MatPaginator | undefined>;
+    sort: import("@angular/core").Signal<MatSort | undefined>;
+    sdSubInformation: import("@angular/core").Signal<SdMaterialSubInformationDefDirective | undefined>;
+    sdCellDefs: import("@angular/core").Signal<readonly SdTabelCellDefDirective[]>;
+    sdFooterDefs: import("@angular/core").Signal<readonly SdMaterialFooterDefDirective[]>;
+    sdFilterDefs: import("@angular/core").Signal<readonly SdTableFilterDefDirective[]>;
+    sdTitleDefs: import("@angular/core").Signal<readonly SdTableTitleDefDirective[]>;
+    cellDef: import("@angular/core").Signal<Record<string, SdTabelCellDefDirective>>;
+    footerDef: import("@angular/core").Signal<Record<string, SdMaterialFooterDefDirective>>;
+    hasFooter: import("@angular/core").Signal<boolean>;
+    titleDef: import("@angular/core").Signal<Record<string, SdTableTitleDefDirective>>;
+    tableOption: import("@angular/core").WritableSignal<SdTableOption<T> | undefined>;
+    configuration: import("@angular/core").WritableSignal<ConfiguredTableResult | undefined>;
+    items: import("@angular/core").WritableSignal<SdTableItem<T>[]>;
+    selectedTableItems: import("@angular/core").WritableSignal<SdTableItem<T>[]>;
+    total: import("@angular/core").WritableSignal<number | undefined>;
+    loading: import("@angular/core").WritableSignal<boolean>;
+    exporting: import("@angular/core").WritableSignal<boolean>;
+    isSelectAll: import("@angular/core").WritableSignal<boolean>;
+    exportTitle: import("@angular/core").WritableSignal<string>;
+    isFiltered: import("@angular/core").WritableSignal<boolean>;
+    requireFiltered: import("@angular/core").WritableSignal<boolean>;
     filterRegister: TableFilterRegister;
     key: string;
-    quickAction?: SdQuickAction;
-    externalFilter?: ExternalFilterComponent;
-    tableOption: SdTableOption<T>;
-    configuration?: ConfiguredTableResult;
-    set option(option: SdTableOption);
-    items: SdTableItem<T>[];
-    selectedTableItems: SdTableItem<T>[];
-    total?: number;
-    loading: boolean;
-    isHiddenPaginator: boolean;
-    set paginator(paginator: MatPaginator);
-    set sort(sort: MatSort);
-    sdSubInformation?: SdMaterialSubInformationDefDirective;
-    sdCellDefs: QueryList<SdTabelCellDefDirective>;
-    cellDef: Record<string, SdTabelCellDefDirective>;
-    sdFooterDefs: QueryList<SdMaterialFooterDefDirective>;
-    footerDef: Record<string, SdMaterialFooterDefDirective>;
-    hasFooter: boolean;
-    sdFilterDefs: QueryList<SdTableFilterDefDirective>;
-    filterDefs: SdTableFilterDefDirective[];
     columnOperator: Record<string, SdOperator>;
     columnFilter?: Record<string, any>;
-    exporting: boolean;
-    isSelectAll: boolean;
-    exportTitle: string;
     cacheValues: Record<string, any[]>;
-    constructor(ref: ChangeDetectorRef, formatNumberPipe: SdFormatNumberPipe, tableConfiguration: ISdTableConfiguration | undefined, configService: ConfigService, excelService: SdExcelService, notifyService: SdNotifyService, gridFilterService: SdTableFilterService);
+    tableConfiguration: ISdTableConfiguration | null;
+    constructor();
     ngOnInit(): void;
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
-    isFiltered: boolean;
-    requireFiltered: boolean;
+    getFilterRequest: () => SdTableFilterRequest;
     reload: (force?: boolean, scrollTop?: boolean) => Promise<void>;
-    onExport: (args?: {
-        columns?: SdExcelColumn[];
-        isCSV?: boolean;
-    }) => Promise<void>;
-    exportExcel: () => void;
-    exportCSV: () => void;
+    exportExcel: (columns?: SdExcelColumn[]) => void;
+    exportCSV: (columns?: SdExcelColumn[]) => void;
     exportCustom: () => void;
     onFilterChange: () => void;
     onExpand: (rowData: SdTableItem<T>) => Promise<void>;
@@ -106,6 +96,9 @@ export declare class SdTable<T = unknown> extends SdBaseSecureComponent implemen
     detectChanges: () => void;
     onOperatorChange: (column: SdTableColumn, operator: SdOperator) => void;
     trackBy: (index: number, item: SdTableItem) => string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SdTable<any>, [null, null, { optional: true; }, null, null, null, null]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SdTable<any>, "sd-table", never, { "_autoId": { "alias": "autoId"; "required": false; }; "option": { "alias": "option"; "required": false; }; }, {}, ["sdSubInformation", "sdCellDefs", "sdFooterDefs", "sdFilterDefs"], ["[sdTableTop]"], true, never>;
+    isReorderDisabled(item: SdTableItem<T>): boolean;
+    reorderSortPredicate: (index: number, drag: CdkDrag<SdTableItem<T>>, drop: CdkDropList<SdTableItem<T>[]>) => boolean;
+    onReorderDrop(event: CdkDragDrop<SdTableItem<T>[]>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTable<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdTable<any>, "sd-table", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "option": { "alias": "option"; "required": true; "isSignal": true; }; }, {}, ["sdSubInformation", "sdCellDefs", "sdFooterDefs", "sdFilterDefs", "sdTitleDefs"], ["[sdTableTop]"], true, never>;
 }