@sd-angular/core 19.0.0-beta.100 → 19.0.0-beta.101

package/components/query-bar/src/query-bar.component.d.ts

@@ -0,0 +1,180 @@
+import { MatMenuTrigger } from '@angular/material/menu';
+import { SdSearch } from '@sd-angular/core/forms/models';
+import { Filter, Operator } from '@sd-angular/core/utilities/models';
+import { SdQuery, SdQueryField, SdQueryLogic, sdQueryFieldIcon } from './query-bar.model';
+import * as i0 from "@angular/core";
+type Density = 'compact' | 'comfortable';
+interface BuildingChip {
+    field: SdQueryField;
+    operator?: Operator;
+    step: 'operator' | 'value';
+    value?: unknown;
+}
+export declare class SdQueryBar {
+    #private;
+    /** All chip menu triggers (one per chip button). Used to auto-open the popover after addFilter. */
+    readonly chipTriggers: import("@angular/core").Signal<readonly MatMenuTrigger[]>;
+    /** The build chip's operator dropdown — auto-opened when entering the operator step. */
+    private readonly buildOperator;
+    /** The build chip's value picker (bare sd-select / sd-date / sd-datetime) — auto-opened at the value step. */
+    private readonly buildPicker;
+    /** Prefix for auto-generated `data-autoid` on inner controls (chips, operator/value editors, buttons). */
+    readonly autoIdInput: import("@angular/core").InputSignalWithTransform<string | undefined, string | null | undefined>;
+    /** Available fields the user can filter by. Required for the field picker. */
+    readonly fields: import("@angular/core").InputSignalWithTransform<SdQueryField[], SdQueryField[] | null | undefined>;
+    /**
+     * Active filter chips. Two-way bindable via `[(filters)]`.
+     * Use this when you only need a flat `Filter[]` (no global logic / search box).
+     */
+    readonly filters: import("@angular/core").ModelSignal<Filter[]>;
+    /**
+     * Global connector between filters. Two-way bindable via `[(logic)]`.
+     * Only meaningful when `showLogicToggle=true` and there are ≥2 filters.
+     */
+    readonly logic: import("@angular/core").ModelSignal<SdQueryLogic>;
+    /** Free-text search string. Two-way bindable via `[(search)]`. Only shown when `showSearch=true`. */
+    readonly search: import("@angular/core").ModelSignal<string>;
+    /**
+     * Editing mode:
+     * - `'popover'` (default) → compact chips; click a chip to edit operator + value in a
+     *   mat-menu popover, commit with "Áp dụng".
+     * - `'inline'` → GitLab-style. Each filter's operator + value controls render directly
+     *   on the bar (no popup, no per-filter apply). Edits update `filters` live; the user
+     *   presses the search button (or Enter) once to fire `(apply)`.
+     */
+    readonly mode: import("@angular/core").InputSignalWithTransform<"popover" | "inline", "popover" | "inline" | null | undefined>;
+    /** Density preset — chip / control height. */
+    readonly density: import("@angular/core").InputSignalWithTransform<Density, Density | null | undefined>;
+    /** Show free-text search input on the left. */
+    readonly showSearch: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Show saved-views dropdown on the right. */
+    readonly showSavedViews: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Show AND/OR segmented toggle (renders only when there are ≥2 filters). */
+    readonly showLogicToggle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Show "Clear all" button when at least one filter is active. */
+    readonly showClearAll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Render the operator label on the chip face (default: hidden — operator only visible in popover). */
+    readonly showOperatorOnChip: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Composite payload — emitted whenever filters / logic / search change. */
+    readonly queryChange: import("@angular/core").OutputEmitterRef<SdQuery<any>>;
+    /** Fires when the user presses "Áp dụng" inside a chip popover — host should reload data. */
+    readonly apply: import("@angular/core").OutputEmitterRef<SdQuery<any>>;
+    /** Map of `field.key` → `SdQueryField` for fast lookup from filters[]. */
+    readonly fieldByKey: import("@angular/core").Signal<Record<string, SdQueryField>>;
+    /** Field keys already chained on a chip — the picker greys these out. */
+    readonly usedFieldKeys: import("@angular/core").Signal<Set<string>>;
+    /** Render the global AND/OR connector text between chips when `logic === 'OR'`. */
+    readonly showOrConnector: import("@angular/core").Signal<boolean>;
+    /** Search button is actionable only when there is something to apply. */
+    readonly canSearch: import("@angular/core").Signal<boolean>;
+    /** Index of the chip whose popover is open. Reset to null after Apply / close. */
+    readonly editingIndex: import("@angular/core").WritableSignal<number | null>;
+    /** Staged operator (uncommitted). */
+    readonly editingOperator: import("@angular/core").WritableSignal<Operator>;
+    /** Staged value (uncommitted) — type varies by kind. */
+    readonly editingValue: import("@angular/core").WritableSignal<unknown>;
+    /** Resolved option list for the currently editing values / lazy-values field. */
+    readonly editingOptions: import("@angular/core").WritableSignal<any[]>;
+    /** Loading state for async option fetch. */
+    readonly editingOptionsLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly editingField: import("@angular/core").Signal<SdQueryField | null>;
+    readonly editingAllowedOperators: import("@angular/core").Signal<Operator[]>;
+    /** Show the operator dropdown only when the field exposes >1 operator (else simple mode). */
+    readonly editingShowOperatorSelector: import("@angular/core").Signal<boolean>;
+    /** Multi-select is derived from the operator (IN / NOT_IN), not a field flag. */
+    readonly editingIsMulti: import("@angular/core").Signal<boolean>;
+    /** Compose a deterministic autoId for an inner control inside a chip's editor. */
+    chipAutoId(role: string): string;
+    readonly iconFor: typeof sdQueryFieldIcon;
+    /** Chip is "active" when it has a non-empty value OR a no-data operator (NULL/NOT_NULL). */
+    isFilterActive(filter: Filter): boolean;
+    /** Rendered value text on a chip. */
+    chipValueText(filter: Filter): string;
+    isNoDataOperator(op: Operator | string): boolean;
+    isMultiOperator(op: Operator | string): boolean;
+    lazyItemsFor(field: SdQueryField): SdSearch;
+    readonly building: import("@angular/core").Signal<BuildingChip | null>;
+    readonly editingValueIndex: import("@angular/core").Signal<number | null>;
+    /** True when chip `i` is in inline value-edit mode. */
+    isEditingValue(i: number): boolean;
+    allowedOperatorsFor(field: SdQueryField): Operator[];
+    inlineAutoId(index: number, role: string): string;
+    /** Entry point from the field picker — start building a chip for `field`. */
+    beginBuild(field: SdQueryField): void;
+    /** Operator chosen during build — finish (no-data) or advance to the value step. */
+    pickBuildOperator(op: Operator): void;
+    /** Value committed during build — push the completed chip, clear building. No emit. */
+    commitBuildValue(value: unknown): void;
+    /**
+     * Commit from the seamless build chip (string / number). An empty value (blur with no
+     * input) cancels the build instead of pushing a blank chip.
+     */
+    onBuildSeamlessCommit(value: unknown): void;
+    /** Abandon the in-progress chip. */
+    cancelBuild(): void;
+    /** Live-commit an inline edit for a completed chip (bare control path). */
+    editValueFn(i: number): (v: unknown) => void;
+    /** Single-value commit from a completed chip in edit mode — write data + exit edit. */
+    onChipSingleCommit(i: number, v: unknown): void;
+    /**
+     * Multi-value chips exit edit when focus actually leaves the wrapper subtree.
+     * why: focusout fires on every internal blur (option click, search input, …) — only
+     * exit when the new focus target is NOT a descendant of the chip's value wrapper.
+     */
+    onChipValueFocusOut(i: number, ev: FocusEvent): void;
+    /**
+     * Cập nhật đầu `from` của BETWEEN cho 1 chip đã commit (inline edit).
+     * why: dual picker BETWEEN trên chip hoàn tất cần ghi từng đầu vào filter mà không reset đầu kia.
+     */
+    setFilterRangeFrom(i: number, v: unknown): void;
+    /**
+     * Cập nhật đầu `to` của BETWEEN cho 1 chip đã commit (inline edit).
+     */
+    setFilterRangeTo(i: number, v: unknown): void;
+    noop: () => void;
+    setEditDraftFn(): (v: unknown) => void;
+    commitEditDraftFn(i: number): () => void;
+    setBuildDraftFn(): (v: unknown) => void;
+    /** Update the `from` end of the build chip's BETWEEN range without committing. */
+    setBuildRangeFrom(v: unknown): void;
+    /**
+     * Update the `to` end of the build chip's BETWEEN range. Once both ends are set, commit
+     * the chip so the user does not need an extra blur / apply press.
+     */
+    setBuildRangeTo(v: unknown): void;
+    commitBuildDraftFn(): () => void;
+    /** Start inline value edit on a completed chip (operator + field stay locked). */
+    beginEditValue(i: number): void;
+    /** Commit an inline value edit — change only `data`, no emit. */
+    commitEditValue(i: number, value: unknown): void;
+    addFilter(field: SdQueryField): void;
+    /** Swap the field of an existing chip — reset operator + value to the new field's defaults. */
+    changeFilterField(index: number, field: SdQueryField): void;
+    updateFilter(index: number, patch: Partial<Filter>): void;
+    removeFilter(index: number): void;
+    clearAll(): void;
+    setLogic(value: SdQueryLogic): void;
+    setSearch(value: string): void;
+    triggerApply(): void;
+    /** Called when a chip is clicked — copy current operator + value into the staging signals. */
+    openChipPopover(index: number): void;
+    /** Called on operator <select> change in the popover. */
+    onEditingOperatorChange(next: Operator): void;
+    /** Two-way bind for primitive value control. */
+    onEditingValueInput(value: unknown): void;
+    /** BETWEEN range mutators. */
+    onEditingRangeFrom(value: string | number | null): void;
+    onEditingRangeTo(value: string | number | null): void;
+    /** Toggle a value inside the staged multi-select array. */
+    toggleEditingMultiValue(value: unknown): void;
+    isEditingMultiSelected(value: unknown): boolean;
+    /**
+     * Commit the staged operator + value into the chip when the popover closes.
+     * why: nút Áp dụng đã bị bỏ — đóng popover (out-focus) tự động áp dụng phần
+     * chỉnh sửa đang staging. Không emit: nút Search toàn cục vẫn là trigger query duy nhất.
+     */
+    commitChipEditOnClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdQueryBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdQueryBar, "sd-query-bar", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "filters": { "alias": "filters"; "required": false; "isSignal": true; }; "logic": { "alias": "logic"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; "showSavedViews": { "alias": "showSavedViews"; "required": false; "isSignal": true; }; "showLogicToggle": { "alias": "showLogicToggle"; "required": false; "isSignal": true; }; "showClearAll": { "alias": "showClearAll"; "required": false; "isSignal": true; }; "showOperatorOnChip": { "alias": "showOperatorOnChip"; "required": false; "isSignal": true; }; }, { "filters": "filtersChange"; "logic": "logicChange"; "search": "searchChange"; "queryChange": "queryChange"; "apply": "apply"; }, never, never, true, never>;
+}
+export {};

package/components/query-bar/src/query-bar.model.d.ts

@@ -0,0 +1,121 @@
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Filter, NestedKeyOf, Operator } from '@sd-angular/core/utilities/models';
+export type SdQueryFieldKind = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'values' | 'lazy-values';
+interface SdQueryFieldBase<T = any> {
+    /** Dot-notation field path (matches `Filter.field`). */
+    key: NestedKeyOf<T>;
+    /** Human-readable label shown on chip + field picker. */
+    label: string;
+    /** Material icon name; falls back to `SD_QUERY_KIND_ICON[kind]` then `'tune'`. */
+    icon?: string;
+    /**
+     * Controls the operator selector in the chip popover:
+     * - omitted / `false` → **simple mode**: no operator dropdown; the chip always uses
+     *   `defaultOperator` (or the per-kind default). Use this for screens that don't need
+     *   operator choice.
+     * - `true` → show the full operator set for the field's `kind`
+     *   (`SD_QUERY_OPERATORS_BY_KIND[kind]`).
+     * - `Operator[]` → show exactly these operators.
+     */
+    operators?: boolean | Operator[];
+    /**
+     * Operator the chip starts with. Falls back to `SD_QUERY_DEFAULT_OPERATOR_BY_KIND[kind]`:
+     * string→CONTAIN, number→EQUAL, values/lazy-values→IN, boolean→EQUAL, date/datetime→BETWEEN.
+     */
+    defaultOperator?: Operator;
+    /** Field is offered in picker but not interactive (read-only badge in chip). */
+    disabled?: boolean;
+}
+export interface SdQueryFieldString<T = any> extends SdQueryFieldBase<T> {
+    kind: 'string';
+}
+export interface SdQueryFieldNumber<T = any> extends SdQueryFieldBase<T> {
+    kind: 'number';
+    /** Bounds for the input control inside the chip popover. */
+    min?: number;
+    max?: number;
+    /** Step for the number input. */
+    step?: number;
+}
+export interface SdQueryFieldBoolean<T = any> extends SdQueryFieldBase<T> {
+    kind: 'boolean';
+    /** Labels rendered for the true/false buttons. Default: "Có" / "Không". */
+    trueLabel?: string;
+    falseLabel?: string;
+}
+export interface SdQueryFieldDate<T = any> extends SdQueryFieldBase<T> {
+    kind: 'date' | 'datetime';
+    /** Restrict the picker calendar to this range. */
+    min?: Date | string;
+    max?: Date | string;
+}
+/**
+ * Statically-known options (sync array, signal, or one-shot promise).
+ * Mirrors `SdTableColumnValues.option`.
+ */
+export interface SdQueryFieldValues<T = any, K = Record<string, any>> extends SdQueryFieldBase<T> {
+    kind: 'values';
+    option: {
+        items: K[] | Signal<K[]> | (() => Promise<K[]>);
+        valueField: NestedKeyOf<K>;
+        displayField: NestedKeyOf<K>;
+    };
+}
+/**
+ * Server-backed options — searchable, paginated. Mirrors `SdTableColumnLazyValues.option`.
+ * `search(req)` runs the live picker query; `views(values)` resolves chip-display labels for selected IDs.
+ */
+export interface SdQueryFieldLazyValues<T = any, K = Record<string, any>> extends SdQueryFieldBase<T> {
+    kind: 'lazy-values';
+    option: {
+        search: (req: {
+            search?: string;
+            size?: number;
+        }) => Observable<K[]> | Promise<K[]>;
+        views?: (values: any[]) => Promise<K[]>;
+        valueField: NestedKeyOf<K>;
+        displayField: NestedKeyOf<K>;
+    };
+}
+export type SdQueryField<T = any> = SdQueryFieldString<T> | SdQueryFieldNumber<T> | SdQueryFieldBoolean<T> | SdQueryFieldDate<T> | SdQueryFieldValues<T> | SdQueryFieldLazyValues<T>;
+export type SdQueryLogic = 'AND' | 'OR';
+export interface SdQuery<T = any> {
+    filters: Filter<T>[];
+    /** Global connector between filters. Defaults to `'AND'`. */
+    logic?: SdQueryLogic;
+    /** Free-text search box (only present when `showSearch=true`). */
+    search?: string;
+}
+/** Full operator set per field kind — used when `operators: true`. */
+export declare const SD_QUERY_OPERATORS_BY_KIND: Record<SdQueryFieldKind, Operator[]>;
+/** Default operator when a chip is created and `field.defaultOperator` is not set. */
+export declare const SD_QUERY_DEFAULT_OPERATOR_BY_KIND: Record<SdQueryFieldKind, Operator>;
+/** Vietnamese operator labels. Replace via i18n in the consuming template if needed. */
+export declare const SD_QUERY_OPERATOR_LABEL: Record<Operator, string>;
+/** Icon fallback per field kind when `SdQueryField.icon` is not set. */
+export declare const SD_QUERY_KIND_ICON: Record<SdQueryFieldKind, string>;
+/**
+ * Resolves the icon shown on chips and in the field picker.
+ * Priority: `field.icon` → `SD_QUERY_KIND_ICON[field.kind]` → `'tune'`.
+ */
+export declare function sdQueryFieldIcon(field: SdQueryField): string;
+/** Operators that carry no data — value section is hidden in chip popover. */
+export declare const SD_QUERY_NO_DATA_OPERATORS: Operator[];
+/** Operators that carry an array payload — UI offers multi-select. */
+export declare const SD_QUERY_MULTI_OPERATORS: Operator[];
+/** Picks the initial operator when a new chip is created for `field`. */
+export declare function sdQueryDefaultOperator(field: SdQueryField): Operator;
+/**
+ * Operators offered in the chip popover for `field`:
+ * - `operators === true` → full set for the kind
+ * - `operators` is an array → that array (deduped against the kind set is the caller's job)
+ * - otherwise (simple mode) → just the single default operator (no real choice)
+ */
+export declare function sdQueryAllowedOperators(field: SdQueryField): Operator[];
+/**
+ * Whether the operator selector should be visible. Simple mode (operators omitted/false,
+ * or an array with a single entry) hides the dropdown — the chip uses one fixed operator.
+ */
+export declare function sdQueryShowOperatorSelector(field: SdQueryField): boolean;
+export {};

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

@@ -3,7 +3,7 @@ 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 | undefined>;
+    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/desktop-cell/desktop-cell.component.d.ts

@@ -1,4 +1,4 @@
-import { ElementRef } from '@angular/core';
+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';
@@ -8,13 +8,13 @@ export declare class DesktopCellComponent {
     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>>;
+    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<import("@angular/core").TemplateRef<any>>;
+    templateRef: import("@angular/core").Signal<TemplateRef<any> | undefined>;
     isCollapsed: import("@angular/core").WritableSignal<boolean>;
     isOverflowing: import("@angular/core").WritableSignal<boolean>;
     constructor();

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

@@ -18,19 +18,15 @@ export declare class ColumnFilterComponent {
     label: Signal<string | undefined>;
     operators: Signal<{
         value: Operator;
-        symbol?: string;
+        icon: string;
         display: string;
     }[]>;
-    inlineSymbol: Signal<string>;
+    operatorValues: Signal<Operator[]>;
+    operatorWrapperClass: Signal<"mb-4 mr-2" | "mr-2">;
     items: Signal<any[] | SdSearch | Signal<any[]>>;
     constructor();
     onFilterChange: () => void;
     onFilterCommit: () => void;
-    onChangeOperator: (operator: {
-        value: Operator;
-        symbol?: string;
-        display: string;
-    } | undefined) => 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/directives/sd-table-cell-def.directive.d.ts

@@ -1,8 +1,16 @@
 import { TemplateRef } from '@angular/core';
+import { SdTableColumn } from '../models/table-column.model';
 import * as i0 from "@angular/core";
-export declare class SdTableCellDefDirective {
+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<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableCellDefDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableCellDefDirective, "[sdTableCellDef]", never, { "sdTableCellDef": { "alias": "sdTableCellDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    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

@@ -1,8 +1,16 @@
 import { TemplateRef } from '@angular/core';
+import { SdTableColumn } from '../models/table-column.model';
 import * as i0 from "@angular/core";
-export declare class SdTableColumnFilterDefDirective {
+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<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableColumnFilterDefDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableColumnFilterDefDirective, "[sdTableColumnFilterDef]", never, { "sdTableColumnFilterDef": { "alias": "sdTableColumnFilterDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    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

@@ -1,7 +1,13 @@
 import { TemplateRef } from '@angular/core';
+import { SdTableItem } from '../models/table-item.model';
 import * as i0 from "@angular/core";
-export declare class SdTableExpandDefDirective {
-    templateRef: TemplateRef<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SdTableExpandDefDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SdTableExpandDefDirective, "[sdTableExpandDef]", never, {}, {}, never, never, true, never>;
+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

@@ -1,13 +1,13 @@
 import { TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
 interface Context {
-    externalFilter?: Record<string, any>;
+    externalFilter?: Record<string, unknown>;
 }
 export declare class SdTableFilterDefDirective {
-    static ngTemplateContextGuard(dir: Context, ctx: unknown): ctx is Context;
+    static ngTemplateContextGuard(_dir: SdTableFilterDefDirective, _ctx: unknown): _ctx is Context;
     sdTableFilterDef: import("@angular/core").InputSignal<string>;
     defaultShowing: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    templateRef: TemplateRef<any> | null;
+    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>;
 }

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

@@ -1,8 +1,16 @@
 import { TemplateRef } 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 SdMaterialFooterDefDirective {
+interface Context<T = any> {
+    items: SdTableItem<T>[];
+    column: SdTableColumn<T>;
+}
+export declare class SdMaterialFooterDefDirective<T = any> {
+    static ngTemplateContextGuard<T>(_dir: SdMaterialFooterDefDirective<T>, _ctx: unknown): _ctx is Context<T>;
     sdTableFooterDef: import("@angular/core").InputSignal<string>;
-    templateRef: TemplateRef<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SdMaterialFooterDefDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SdMaterialFooterDefDirective, "[sdTableFooterDef]", never, { "sdTableFooterDef": { "alias": "sdTableFooterDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    templateRef: TemplateRef<Context<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdMaterialFooterDefDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SdMaterialFooterDefDirective<any>, "[sdTableFooterDef]", never, { "sdTableFooterDef": { "alias": "sdTableFooterDef"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
+export {};

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

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

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

@@ -48,15 +48,15 @@ export declare class SdTable<T = unknown> extends SdBaseSecureComponent implemen
     mobileFilter: import("@angular/core").Signal<MobileFilterComponent | undefined>;
     paginator: import("@angular/core").Signal<MatPaginator | undefined>;
     sort: import("@angular/core").Signal<MatSort | undefined>;
-    sdSubInformation: import("@angular/core").Signal<SdTableExpandDefDirective | undefined>;
-    sdCellDefs: import("@angular/core").Signal<readonly SdTableCellDefDirective[]>;
-    sdFooterDefs: import("@angular/core").Signal<readonly SdMaterialFooterDefDirective[]>;
+    sdSubInformation: import("@angular/core").Signal<SdTableExpandDefDirective<any> | undefined>;
+    sdCellDefs: import("@angular/core").Signal<readonly SdTableCellDefDirective<any>[]>;
+    sdFooterDefs: import("@angular/core").Signal<readonly SdMaterialFooterDefDirective<any>[]>;
     sdFilterDefs: import("@angular/core").Signal<readonly SdTableFilterDefDirective[]>;
-    sdTitleDefs: import("@angular/core").Signal<readonly SdTableTitleDefDirective[]>;
-    cellDef: import("@angular/core").Signal<Record<string, SdTableCellDefDirective>>;
-    footerDef: import("@angular/core").Signal<Record<string, SdMaterialFooterDefDirective>>;
+    sdTitleDefs: import("@angular/core").Signal<readonly SdTableTitleDefDirective<any>[]>;
+    cellDef: import("@angular/core").Signal<Record<string, SdTableCellDefDirective<any>>>;
+    footerDef: import("@angular/core").Signal<Record<string, SdMaterialFooterDefDirective<any>>>;
     hasFooter: import("@angular/core").Signal<boolean>;
-    titleDef: import("@angular/core").Signal<Record<string, SdTableTitleDefDirective>>;
+    titleDef: import("@angular/core").Signal<Record<string, SdTableTitleDefDirective<any>>>;
     tableOption: import("@angular/core").WritableSignal<SdTableOption<T> | undefined>;
     configuration: import("@angular/core").WritableSignal<ConfiguredTableResult | undefined>;
     items: import("@angular/core").WritableSignal<SdTableItem<T>[]>;

package/directives/src/sd-desktop.directive.d.ts

@@ -1,9 +1,7 @@
-import { ViewContainerRef, TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class SdDesktopDirective {
-    private templateRef;
-    private viewContainerRef;
-    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    #private;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<SdDesktopDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<SdDesktopDirective, "[sdDesktop]", never, {}, {}, never, never, true, never>;
 }

package/directives/src/sd-mobile.directive.d.ts

@@ -1,9 +1,7 @@
-import { TemplateRef, ViewContainerRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class SdMobileDirective {
-    private templateRef;
-    private viewContainerRef;
-    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef);
+    #private;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<SdMobileDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<SdMobileDirective, "[sdMobile]", never, {}, {}, never, never, true, never>;
 }