@sdcorejs/angular 19.0.0-rc.1

package/components/tab-router/src/models/tab-router.model.d.ts

@@ -0,0 +1,21 @@
+import { Type } from '@angular/core';
+import { Color } from '@sdcorejs/utils/models';
+import { Subject } from 'rxjs';
+export interface SdTabInfo {
+    name: string;
+    icon?: string;
+    tooltip?: string;
+    color?: Color;
+}
+export interface SdTab {
+    component: Type<any>;
+    injector?: any;
+    key: string;
+    isActive: boolean;
+    url: string;
+    params?: Record<string, string | number>;
+    queryParams?: Record<string, string | number>;
+    data?: Record<string, any>;
+    tabInfoChanges: Subject<SdTabInfo>;
+    beforeClose?: () => boolean | Promise<boolean>;
+}

package/components/tab-router/src/pipes/tab-info.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { SdTab, SdTabInfo } from '../models/tab-router.model';
+import { SdTabRouterService } from '../services/tab-router.service';
+import * as i0 from "@angular/core";
+export declare class SdTabInfoPipe implements PipeTransform {
+    private tabRouterService;
+    constructor(tabRouterService: SdTabRouterService);
+    transform(tabInfo: SdTabInfo | undefined | null, tab: SdTab): SdTabInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTabInfoPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SdTabInfoPipe, "sdTabInfo", true>;
+}

package/components/tab-router/src/services/tab-decorator.service.d.ts

@@ -0,0 +1,9 @@
+import { BehaviorSubject } from 'rxjs';
+import { SdTabRouterService } from './tab-router.service';
+import * as i0 from "@angular/core";
+export declare class SdTabDecoratorService {
+    static tabRouterService: BehaviorSubject<SdTabRouterService | undefined>;
+    constructor(tabRouterService: SdTabRouterService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTabDecoratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdTabDecoratorService>;
+}

package/components/tab-router/src/services/tab-router.service.d.ts

@@ -0,0 +1,27 @@
+import { Type } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { SdTabAction } from '../actions/tab-router.action';
+import { SdTabComponentBuilder } from '../decorators/tab.decorator';
+import { SdTabEvent } from '../events/tab-router.event';
+import { SdTab } from '../models/tab-router.model';
+import * as i0 from "@angular/core";
+export declare class SdTabRouterService {
+    #private;
+    events: BehaviorSubject<SdTabEvent>;
+    actions: BehaviorSubject<SdTabAction | undefined>;
+    builders: BehaviorSubject<SdTabComponentBuilder[]>;
+    currentTabChanges: BehaviorSubject<SdTab | undefined>;
+    newTabs: BehaviorSubject<SdTab | undefined>;
+    updateTabs: BehaviorSubject<SdTab | undefined>;
+    constructor();
+    addBuilder: (builder: SdTabComponentBuilder) => void;
+    get currentTab(): SdTab | undefined;
+    get currentKey(): string | null;
+    setCurrentTab: (tab: SdTab) => void;
+    pushEvent: (tab: SdTab, Event: Type<SdTabEvent>) => void;
+    setOptions: () => void;
+    close: (tab?: SdTab) => void;
+    updateTab: (tab: SdTab) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTabRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SdTabRouterService>;
+}

package/components/table/index.d.ts

@@ -0,0 +1,11 @@
+export * from './src/directives/sd-table-cell-def.directive';
+export * from './src/directives/sd-table-expand-def.directive';
+export * from './src/directives/sd-table-filter-def.directive';
+export * from './src/directives/sd-table-footer-def.directive';
+export * from './src/directives/sd-table-group-def.directive';
+export * from './src/directives/sd-table-title-def.directive';
+export * from './src/table.component';
+export * from './src/services/table-filter/table-filter.model';
+export type { ISdTableConfiguration } from './src/configurations';
+export { SD_TABLE_CONFIGURATION } from './src/configurations';
+export * from './src/models';

package/components/table/src/components/column-title/column-title.component.d.ts

@@ -0,0 +1,10 @@
+import { SdTableTitleDefDirective } from '../../directives/sd-table-title-def.directive';
+import { SdTableColumn } from '../../models/table-column.model';
+import * as i0 from "@angular/core";
+export declare class ColumnTitleComponent {
+    column: import("@angular/core").InputSignal<SdTableColumn>;
+    titleDef: import("@angular/core").InputSignal<SdTableTitleDefDirective<any> | undefined>;
+    templateRef: import("@angular/core").Signal<import("@angular/core").TemplateRef<any> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnTitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnTitleComponent, "column-title", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "titleDef": { "alias": "titleDef"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/table/src/components/command/desktop-command.component.d.ts

@@ -0,0 +1,14 @@
+import { SdTableCommand } from '../../models/table-command.model';
+import { SdTableItem } from '../../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class DesktopCommand {
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
+    item: import("@angular/core").InputSignal<SdTableItem<any>>;
+    itemIndex: import("@angular/core").InputSignal<number>;
+    commands: import("@angular/core").InputSignal<SdTableCommand[] | null | undefined>;
+    itemKey: import("@angular/core").Signal<string>;
+    autoId: import("@angular/core").Signal<string>;
+    _commands: import("@angular/core").Signal<SdTableCommand[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesktopCommand, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesktopCommand, "desktop-command", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; "itemIndex": { "alias": "itemIndex"; "required": true; "isSignal": true; }; "commands": { "alias": "commands"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/table/src/components/command/pipes/command.pipe.d.ts

@@ -0,0 +1,30 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableCommand } from '../../../models/table-command.model';
+import { SdTableItem } from '../../../models/table-item.model';
+import * as i0 from "@angular/core";
+/**
+ * Pipe gộp resolve metadata của 1 command theo row hiện tại — return 1 object
+ * chứa `disabled`, `title`, `icon`, và `htmlTemplate` (khi command là child có
+ * htmlTemplate). Một lần gọi cho cả 4 truy vấn, template dùng `@let` để alias.
+ *
+ * Trước đây tách thành 3 pipe `commandDisable` / `commandTitle` / `commandIcon`.
+ *
+ * @example
+ *   @let meta = item | command:cmd;
+ *   <button [disabled]="meta.disabled" [matTooltip]="meta.title">
+ *     <mat-icon>{{ meta.icon }}</mat-icon>
+ *     <div [innerHTML]="meta.htmlTemplate"></div>
+ *   </button>
+ */
+export declare class CommandPipe implements PipeTransform {
+    #private;
+    transform(item: SdTableItem, command: SdTableCommand): CommandMeta;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CommandPipe, "command", true>;
+}
+export interface CommandMeta {
+    disabled: boolean;
+    title: string;
+    icon: string;
+    htmlTemplate: string | undefined;
+}

package/components/table/src/components/command/pipes/filter.pipe.d.ts

@@ -0,0 +1,35 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableCommand, SdTableCommandChildren, SdTableCommandNormal } from '../../../models/table-command.model';
+import { SdTableItem } from '../../../models/table-item.model';
+import * as i0 from "@angular/core";
+/**
+ * Lọc danh sách commands theo `hidden` (sync / async) + pre-resolve `icon`, `title`, `key`
+ * cho từng row. Output dùng trực tiếp trong template không cần thêm pipe phụ.
+ *
+ * Đã rename từ `commandFilter` → `filter` sau khi gom toàn bộ pipe command vào
+ * `components/command/pipes/`.
+ *
+ * @example
+ *   @let filteredCommands = item | filter:commands | async;
+ */
+export declare class CommandFilterPipe implements PipeTransform {
+    #private;
+    transform(item: SdTableItem, commands: SdTableCommand[]): Promise<Command[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CommandFilterPipe, "filter", true>;
+}
+type Command<T = any> = CommandNormal<T> | CommandChildren<T>;
+interface CommandNormal<T = any> extends SdTableCommandNormal<T> {
+    type: 'normal';
+    key: string;
+    title: string;
+    icon: string;
+}
+interface CommandChildren<T = any> extends SdTableCommandChildren<T> {
+    type: 'children';
+    key: string;
+    title: string;
+    icon: string;
+    children: CommandNormal<T>[];
+}
+export {};

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

@@ -0,0 +1,25 @@
+import { MatTable } from '@angular/material/table';
+import { SdModal } from '@sdcorejs/angular/components/modal';
+import { SdTableColumn } from '../../models/table-column.model';
+import { ConfiguredTable, ConfiguredTableResult } from '../../models/table-option-config.model';
+import { SdTableOption } from '../../models/table-option.model';
+import * as i0 from "@angular/core";
+export declare class ConfigComponent {
+    #private;
+    tableOption: import("@angular/core").InputSignal<SdTableOption | undefined>;
+    changes: import("@angular/core").OutputEmitterRef<ConfiguredTableResult>;
+    modal: import("@angular/core").Signal<SdModal | undefined>;
+    table: import("@angular/core").Signal<MatTable<SdTableColumn>>;
+    configuration: import("@angular/core").WritableSignal<ConfiguredTable | undefined>;
+    dragDisabled: boolean;
+    constructor();
+    open: () => Promise<void>;
+    close: () => void;
+    onSave: () => void;
+    onReset: () => Promise<void>;
+    dropTable(event: any): void;
+    handleMouseDown(): void;
+    handleMouseUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigComponent, "config", never, { "tableOption": { "alias": "tableOption"; "required": false; "isSignal": true; }; }, { "changes": "changes"; }, never, never, true, never>;
+}

package/components/table/src/components/desktop-cell/desktop-cell.component.d.ts

@@ -0,0 +1,24 @@
+import { ElementRef, TemplateRef } from '@angular/core';
+import { SdTableCellDefDirective } from '../../directives/sd-table-cell-def.directive';
+import { SdTableColumn } from '../../models/table-column.model';
+import { SdTableItem } from '../../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class DesktopCellComponent {
+    #private;
+    contentContainer: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    column: import("@angular/core").InputSignal<SdTableColumn>;
+    item: import("@angular/core").InputSignal<SdTableItem<any>>;
+    cellDef: import("@angular/core").InputSignal<Record<string, SdTableCellDefDirective<any>>>;
+    value: import("@angular/core").Signal<any>;
+    key: import("@angular/core").Signal<any>;
+    autoId: import("@angular/core").Signal<string>;
+    truncateEnable: import("@angular/core").Signal<boolean | undefined>;
+    truncateWidth: import("@angular/core").Signal<string | undefined>;
+    templateRef: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    isCollapsed: import("@angular/core").WritableSignal<boolean>;
+    isOverflowing: import("@angular/core").WritableSignal<boolean>;
+    constructor();
+    toggle: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesktopCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesktopCellComponent, "desktop-cell", never, { "column": { "alias": "column"; "required": true; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; "cellDef": { "alias": "cellDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/table/src/components/desktop-cell/view/view.component.d.ts

@@ -0,0 +1,24 @@
+import { ElementRef, PipeTransform } from '@angular/core';
+import { SdTableColumn } from '../../../models/table-column.model';
+import { SdTableItem } from '../../../models/table-item.model';
+import * as i0 from "@angular/core";
+export declare class ToStringPipe implements PipeTransform {
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToStringPipe, "asString", true>;
+}
+export declare class ViewComponent {
+    #private;
+    contentContainer: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    isCollapsed: import("@angular/core").WritableSignal<boolean>;
+    isOverflowing: import("@angular/core").WritableSignal<boolean>;
+    autoId: import("@angular/core").InputSignal<string | null | undefined>;
+    column: import("@angular/core").InputSignal<SdTableColumn>;
+    item: import("@angular/core").InputSignal<SdTableItem<any>>;
+    truncateEnable: import("@angular/core").Signal<boolean | undefined>;
+    truncateWidth: import("@angular/core").Signal<string | undefined>;
+    constructor();
+    toggle: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewComponent, "view", never, { "autoId": { "alias": "autoId"; "required": true; "isSignal": true; }; "column": { "alias": "column"; "required": true; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/table/src/components/filter/column-filter/column-filter.component.d.ts

@@ -0,0 +1,32 @@
+import { Signal } from '@angular/core';
+import { SdSearch } from '@sdcorejs/angular/forms';
+import { Operator } from '@sdcorejs/utils/models';
+import { SdTableColumn } from '../../../models/table-column.model';
+import * as i0 from "@angular/core";
+export declare class ColumnFilterComponent {
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
+    column: import("@angular/core").InputSignal<SdTableColumn>;
+    columnFilter: import("@angular/core").InputSignal<Record<string, any>>;
+    cacheValues: import("@angular/core").InputSignal<Record<string, any[]> | undefined>;
+    value: import("@angular/core").InputSignal<any>;
+    operator: import("@angular/core").ModelSignal<Operator | undefined>;
+    isMobile: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    filterChange: import("@angular/core").OutputEmitterRef<void>;
+    filterCommit: import("@angular/core").OutputEmitterRef<void>;
+    autoId: Signal<string>;
+    templateRef: Signal<import("@angular/core").TemplateRef<any> | undefined>;
+    label: Signal<string | undefined>;
+    operators: Signal<{
+        value: Operator;
+        icon: string;
+        display: string;
+    }[]>;
+    operatorValues: Signal<Operator[]>;
+    operatorWrapperClass: Signal<"mb-4 mr-2" | "mr-2">;
+    items: Signal<any[] | SdSearch | Signal<any[]>>;
+    constructor();
+    onFilterChange: () => void;
+    onFilterCommit: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnFilterComponent, "column-filter", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "column": { "alias": "column"; "required": true; "isSignal": true; }; "columnFilter": { "alias": "columnFilter"; "required": false; "isSignal": true; }; "cacheValues": { "alias": "cacheValues"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "operator": { "alias": "operator"; "required": false; "isSignal": true; }; "isMobile": { "alias": "isMobile"; "required": false; "isSignal": true; }; }, { "operator": "operatorChange"; "filterChange": "filterChange"; "filterCommit": "filterCommit"; }, never, never, true, never>;
+}

package/components/table/src/components/filter/external-filter/external-filter.component.d.ts

@@ -0,0 +1,27 @@
+import { FormGroup } from '@angular/forms';
+import { SdTableExternalFilter, SdTableOptionFilter, TableFilterRegister } from '../../../services/table-filter/table-filter.model';
+import * as i0 from "@angular/core";
+export declare class ExternalFilterComponent {
+    #private;
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
+    filter: import("@angular/core").InputSignal<SdTableOptionFilter<any> | undefined>;
+    externalFilters: import("@angular/core").InputSignal<SdTableExternalFilter[] | null | undefined>;
+    filterRegister: import("@angular/core").InputSignal<TableFilterRegister | undefined>;
+    externalFilter: import("@angular/core").WritableSignal<Record<string, any>>;
+    inlineExternal: import("@angular/core").WritableSignal<Record<string, boolean>>;
+    filtered: import("@angular/core").WritableSignal<boolean>;
+    isMobileOrTablet: boolean;
+    readonly form: FormGroup<{}>;
+    autoId: import("@angular/core").Signal<string>;
+    col: import("@angular/core").Signal<2 | 3>;
+    filterItems: import("@angular/core").Signal<SdTableExternalFilter[]>;
+    constructor();
+    onKeyupEnter: () => void;
+    onFilter: (externalFilter: SdTableExternalFilter) => void;
+    onSubmit: () => void;
+    updateFilter: () => void;
+    clearFilter: (event?: Event) => void;
+    onCheckboxChange: (event: Event, externalFilter: SdTableExternalFilter) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExternalFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExternalFilterComponent, "external-filter", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "externalFilters": { "alias": "externalFilters"; "required": false; "isSignal": true; }; "filterRegister": { "alias": "filterRegister"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,3 @@
+export * from './column-filter/column-filter.component';
+export * from './external-filter/external-filter.component';
+export * from './mobile-filter/mobile-filter.component';

package/components/table/src/components/filter/mobile-filter/mobile-filter.component.d.ts

@@ -0,0 +1,42 @@
+import { SdSideDrawer } from '@sdcorejs/angular/components/side-drawer';
+import { Operator } from '@sdcorejs/utils/models';
+import { SdTableFilterDefDirective } from '../../../directives/sd-table-filter-def.directive';
+import { SdTableColumn } from '../../../models/table-column.model';
+import { SdTableExternalFilter, SdTableOptionFilter, TableFilterRegister } from '../../../services/table-filter/table-filter.model';
+import * as i0 from "@angular/core";
+/**
+ * Mobile-filter — side-drawer chiếm ~90% width thiết bị. Dùng cho table khi
+ * render trên màn hình điện thoại (inline filter bị ẩn).
+ *
+ * Layout (mỗi filter 1 hàng, size='sm'):
+ *  1. External filter (render inline — KHÔNG reuse external-filter component
+ *     vì component đó dùng grid 2/3 cột + có chọn ẩn/hiện không phù hợp mobile).
+ *  2. filterDefs — custom templates do app khai báo qua `[sdTableFilterDef]`.
+ *  3. Column filter — 1 column-filter / column.
+ *
+ * State: local working copy. Cancel = đóng (không ghi). Apply = flush vào
+ * filterRegister + đóng.
+ */
+export declare class MobileFilterComponent {
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
+    filter: import("@angular/core").InputSignal<SdTableOptionFilter<any> | undefined>;
+    externalFilters: import("@angular/core").InputSignal<SdTableExternalFilter[] | null | undefined>;
+    columns: import("@angular/core").InputSignal<SdTableColumn[] | null | undefined>;
+    filterDefs: import("@angular/core").InputSignal<readonly SdTableFilterDefDirective[] | null | undefined>;
+    filterRegister: import("@angular/core").InputSignal<TableFilterRegister | undefined>;
+    cacheValues: import("@angular/core").InputSignal<Record<string, any[]> | undefined>;
+    drawer: import("@angular/core").Signal<SdSideDrawer>;
+    workingColumnFilter: import("@angular/core").WritableSignal<Record<string, any>>;
+    workingColumnOperator: import("@angular/core").WritableSignal<Record<string, Operator>>;
+    workingExternalFilter: import("@angular/core").WritableSignal<Record<string, any>>;
+    autoId: import("@angular/core").Signal<string>;
+    externalFilterItems: import("@angular/core").Signal<SdTableExternalFilter[]>;
+    columnItems: import("@angular/core").Signal<SdTableColumn[]>;
+    filterDefItems: import("@angular/core").Signal<readonly SdTableFilterDefDirective[]>;
+    open: () => void;
+    close: () => void;
+    onApply: () => void;
+    onCancel: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MobileFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MobileFilterComponent, "mobile-filter", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "externalFilters": { "alias": "externalFilters"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "filterDefs": { "alias": "filterDefs"; "required": false; "isSignal": true; }; "filterRegister": { "alias": "filterRegister"; "required": false; "isSignal": true; }; "cacheValues": { "alias": "cacheValues"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,3 @@
+export * from './column-title/column-title.component';
+export * from './filter';
+export * from './selector-action/selector-action.component';

package/components/table/src/components/popup-export/popup-export.component.d.ts

@@ -0,0 +1,51 @@
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { MatSelectionList } from '@angular/material/list';
+import { SdModal } from '@sdcorejs/angular/components/modal';
+import { SdConfirmService, SdExcelColumn, SdExcelService, SdLoadingService, SdNotifyService } from '@sdcorejs/angular/services';
+import { SdTableOption } from '../../models';
+import { ConfiguredTableResult } from '../../models/table-option-config.model';
+import { SdTableOptionExportDefault } from '../../models/table-option-export.model';
+import * as i0 from "@angular/core";
+export declare class SdPopupExport {
+    #private;
+    private ref;
+    private loadingService;
+    private excelService;
+    private notifyService;
+    private confirmService;
+    tableOption: SdTableOption;
+    columns: SdExcelColumn[];
+    templateName?: string | null;
+    enableCreating: boolean;
+    modal?: SdModal;
+    listGroups?: MatSelectionList;
+    selected: Record<string, boolean>;
+    files: any[];
+    export: EventEmitter<{
+        file: any | null;
+        columns: SdExcelColumn[];
+        isCSV?: boolean;
+    }>;
+    form: FormGroup<{}>;
+    exportOption?: SdTableOptionExportDefault;
+    set _tableOption(option: SdTableOption);
+    configuration?: ConfiguredTableResult;
+    private get key();
+    private get tableColumns();
+    private get additionalColumns();
+    constructor(ref: ChangeDetectorRef, loadingService: SdLoadingService, excelService: SdExcelService, notifyService: SdNotifyService, confirmService: SdConfirmService);
+    open: () => Promise<void>;
+    exportDefault: () => void;
+    exportCSV: () => void;
+    loadFiles: (group?: string | undefined) => Promise<void>;
+    generateTemplate: () => Promise<void>;
+    generateAndUploadTemplate: (fileName?: string) => Promise<void>;
+    onExport: (file: any) => void;
+    uploadTemplate: () => Promise<void>;
+    removeFile: (file: any) => void;
+    createTemplate: () => Promise<void>;
+    templateNameValidator: (val: string) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdPopupExport, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdPopupExport, "sd-popup-export", never, { "_tableOption": { "alias": "tableOption"; "required": false; }; "configuration": { "alias": "configuration"; "required": false; }; }, { "export": "export"; }, never, never, true, never>;
+}

package/components/table/src/components/selector-action/action-filter.pipe.d.ts

@@ -0,0 +1,34 @@
+import { PipeTransform } from '@angular/core';
+import { SdTableAction } from '../../models/table-option-selector.model';
+import { SdTableItem } from '../../models/table-item.model';
+import { SdButton } from '@sdcorejs/angular/components/button';
+import { SdUnwrapSignal } from '@sdcorejs/angular/utilities/models';
+import * as i0 from "@angular/core";
+export declare class ActionFilterPipe implements PipeTransform {
+    #private;
+    transform: (selectedItems: SdTableItem[] | undefined, actions: SdTableAction[] | undefined) => Action[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ActionFilterPipe, "actionFilter", true>;
+}
+export type Action<T = any> = ActionNormal<T> | ActionChildren<T>;
+interface ActionNormal<T = any> {
+    variant: 'normal';
+    icon?: string;
+    fontSet?: SdUnwrapSignal<SdButton['fontSet']>;
+    tooltip?: SdUnwrapSignal<SdButton['tooltip']>;
+    title?: SdUnwrapSignal<SdButton['title']>;
+    color?: SdUnwrapSignal<SdButton['color']>;
+    type?: SdUnwrapSignal<SdButton['type']>;
+    click: (selectedItems?: T[]) => void;
+}
+interface ActionChildren<T = any> {
+    variant: 'children';
+    icon?: string;
+    fontSet?: SdUnwrapSignal<SdButton['fontSet']>;
+    tooltip?: SdUnwrapSignal<SdButton['tooltip']>;
+    title?: SdUnwrapSignal<SdButton['title']>;
+    color?: SdUnwrapSignal<SdButton['color']>;
+    type?: SdUnwrapSignal<SdButton['type']>;
+    children: ActionNormal<T>[];
+}
+export {};

package/components/table/src/components/selector-action/selector-action.component.d.ts

@@ -0,0 +1,16 @@
+import { SdTableItem } from '../../models/table-item.model';
+import { SdTableOption } from '../../models/table-option.model';
+import { Action } from './action-filter.pipe';
+import * as i0 from "@angular/core";
+export declare class SelectorActionComponent {
+    #private;
+    tableOption: import("@angular/core").InputSignal<SdTableOption | undefined>;
+    selectedTableItems: import("@angular/core").InputSignal<SdTableItem<any>[] | undefined>;
+    clear: import("@angular/core").OutputEmitterRef<void>;
+    message: import("@angular/core").Signal<string>;
+    opened: import("@angular/core").Signal<boolean>;
+    onClear: () => void;
+    onClickAction: (action: Action) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectorActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectorActionComponent, "selector-action", never, { "tableOption": { "alias": "tableOption"; "required": false; "isSignal": true; }; "selectedTableItems": { "alias": "selectedTableItems"; "required": false; "isSignal": true; }; }, { "clear": "clear"; }, never, never, true, never>;
+}

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

@@ -0,0 +1 @@
+export * from './table.configuration';

package/components/table/src/configurations/table.configuration.d.ts

@@ -0,0 +1,35 @@
+import { InjectionToken } from '@angular/core';
+import { SdTableOptionPaginate } from '../models/table-option-paginate.model';
+import { SdTableOptionFilter } from '../services/table-filter/table-filter.model';
+import { Operator } from '@sdcorejs/utils/models';
+import { SdTableColumn } from '../models';
+export interface ISdTableConfiguration {
+    paginate?: {
+        /** Số dòng mỗi trang. */
+        pageSize?: SdTableOptionPaginate['pageSize'];
+        /** Danh sách các tuỳ chọn số dòng/trang mà người dùng có thể chọn. */
+        pages?: SdTableOptionPaginate['pages'];
+        showFirstLastButtons?: SdTableOptionPaginate['showFirstLastButtons'];
+    };
+    filter?: {
+        /** Ẩn bộ lọc dưới cột, nếu không cấu hình thì giá trị mặc định là false */
+        hideInlineFilter?: SdTableOptionFilter['hideInlineFilter'];
+        /** Số lượng external filter mỗi dòng, mặc định là 6 */
+        externalFilterPerRow?: SdTableOptionFilter['externalFilterPerRow'];
+        /**  Kích hoạt chế độ lọc thủ công, hiển thị nút áp dụng, mặc định là false */
+        manualFilter?: SdTableOptionFilter['manualFilter'];
+        /** Ẩn toolbar (xóa bộ lọc, thiết lập) của external filter, khi có ít external filter user không cần chức năng này, mặc định là false */
+        hideExternalFilterToolbar?: SdTableOptionFilter['hideExternalFilterToolbar'];
+        operator?: {
+            list?: Partial<Record<SdTableColumn['type'], Operator[]>>;
+            default?: Partial<Record<SdTableColumn['type'], Operator>>;
+        };
+    };
+    images?: {
+        filterRequired?: string;
+        dataEmpty?: string;
+        filterEmpty?: string;
+    };
+}
+export declare const DEFAULT_TABLE_CONFIG: ISdTableConfiguration;
+export declare const SD_TABLE_CONFIGURATION: InjectionToken<ISdTableConfiguration>;

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

@@ -0,0 +1,6 @@
+export * from './sd-table-column-filter-def.directive';
+export * from './sticky-shadow.directive';
+export * from './sd-table-title-def.directive';
+export * from './sd-table-cell-def.directive';
+export * from './sd-table-group-def.directive';
+export * from './sd-column-resize.directive';

package/components/table/src/directives/sd-column-resize.directive.d.ts

@@ -0,0 +1,13 @@
+import { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SdColumnResizeDirective implements OnDestroy {
+    #private;
+    sdColumnResize: import("@angular/core").InputSignal<boolean>;
+    minWidth: import("@angular/core").InputSignal<string | undefined>;
+    maxWidth: import("@angular/core").InputSignal<string | undefined>;
+    resizeEnd: import("@angular/core").OutputEmitterRef<string>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdColumnResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdColumnResizeDirective, "[sdColumnResize]", never, { "sdColumnResize": { "alias": "sdColumnResize"; "required": true; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, { "resizeEnd": "resizeEnd"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,16 @@
+import { TemplateRef } from '@angular/core';
+import { SdTableColumn } from '../models/table-column.model';
+import * as i0 from "@angular/core";
+interface Context<T = any> {
+    item: T;
+    column: SdTableColumn<T>;
+    autoId: string;
+}
+export declare class SdTableCellDefDirective<T = any> {
+    static ngTemplateContextGuard<T>(_dir: SdTableCellDefDirective<T>, _ctx: unknown): _ctx is Context<T>;
+    sdTableCellDef: import("@angular/core").InputSignal<string>;
+    templateRef: TemplateRef<Context<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableCellDefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableCellDefDirective<any>, "[sdTableCellDef]", never, { "sdTableCellDef": { "alias": "sdTableCellDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { TemplateRef } from '@angular/core';
+import { SdTableColumn } from '../models/table-column.model';
+import * as i0 from "@angular/core";
+interface Context<T = any> {
+    column: SdTableColumn<T>;
+    field: string;
+    disabled?: boolean;
+}
+export declare class SdTableColumnFilterDefDirective<T = any> {
+    static ngTemplateContextGuard<T>(_dir: SdTableColumnFilterDefDirective<T>, _ctx: unknown): _ctx is Context<T>;
+    sdTableColumnFilterDef: import("@angular/core").InputSignal<string>;
+    templateRef: TemplateRef<Context<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableColumnFilterDefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableColumnFilterDefDirective<any>, "[sdTableColumnFilterDef]", never, { "sdTableColumnFilterDef": { "alias": "sdTableColumnFilterDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { TemplateRef } from '@angular/core';
+import { SdTableItem } from '../models/table-item.model';
+import * as i0 from "@angular/core";
+interface Context<T = any> {
+    item: SdTableItem<T>;
+}
+export declare class SdTableExpandDefDirective<T = any> {
+    static ngTemplateContextGuard<T>(_dir: SdTableExpandDefDirective<T>, _ctx: unknown): _ctx is Context<T>;
+    templateRef: TemplateRef<Context<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableExpandDefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableExpandDefDirective<any>, "[sdTableExpandDef]", never, {}, {}, never, never, true, never>;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+interface Context {
+    externalFilter?: Record<string, unknown>;
+}
+export declare class SdTableFilterDefDirective {
+    static ngTemplateContextGuard(_dir: SdTableFilterDefDirective, _ctx: unknown): _ctx is Context;
+    sdTableFilterDef: import("@angular/core").InputSignal<string>;
+    defaultShowing: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    templateRef: TemplateRef<Context> | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableFilterDefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableFilterDefDirective, "[sdTableFilterDef]", never, { "sdTableFilterDef": { "alias": "sdTableFilterDef"; "required": true; "isSignal": true; }; "defaultShowing": { "alias": "defaultShowing"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};