@sd-angular/core 19.0.0-beta.99 → 19.0.3

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

@@ -0,0 +1,35 @@
+import { MatMenu } from '@angular/material/menu';
+import { Filter, Operator } from '@sdcorejs/utils/models';
+import { SdQueryField, sdQueryFieldIcon } from '../../query-bar.model';
+import * as i0 from "@angular/core";
+/**
+ * Compact popover-mode chip face. Click → opens the parent-supplied [menu] (mat-menu
+ * containing the chip editor). Inert div[role=button] so the nested <sd-operator>
+ * doesn't end up as a button-in-button (invalid HTML).
+ */
+export declare class SdQueryPopoverChip {
+    /** Resolved field (from the bar's `fieldByKey()` map). `undefined` → render raw key. */
+    readonly field: import("@angular/core").InputSignal<SdQueryField | undefined>;
+    /** The chip's filter — used to read `field` / `operator` / `data` for display text. */
+    readonly filter: import("@angular/core").InputSignal<Filter>;
+    /** "Active" = chip has a real value or is no-data op. Drives layout + colour. */
+    readonly active: import("@angular/core").InputSignal<boolean>;
+    /** Operator visible on the chip face (else hidden, ":" separator). */
+    readonly showOperator: import("@angular/core").InputSignal<boolean>;
+    /** Rendered value text for the value slot. */
+    readonly valueText: import("@angular/core").InputSignal<string>;
+    /** Chip popover mat-menu instance supplied by the parent. */
+    readonly menu: import("@angular/core").InputSignal<MatMenu>;
+    /** Fired when the chip popover opens (parent seeds its editing state). */
+    readonly open: import("@angular/core").OutputEmitterRef<void>;
+    /** Fired when the user clicks the × removal icon. */
+    readonly remove: import("@angular/core").OutputEmitterRef<void>;
+    readonly iconFor: typeof sdQueryFieldIcon;
+    filterField(): string;
+    filterOperator(): Operator;
+    private readonly trigger;
+    openMenu(): void;
+    closeMenu(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdQueryPopoverChip, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdQueryPopoverChip, "sd-query-popover-chip", never, { "field": { "alias": "field"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": true; "isSignal": true; }; "active": { "alias": "active"; "required": true; "isSignal": true; }; "showOperator": { "alias": "showOperator"; "required": false; "isSignal": true; }; "valueText": { "alias": "valueText"; "required": false; "isSignal": true; }; "menu": { "alias": "menu"; "required": true; "isSignal": true; }; }, { "open": "open"; "remove": "remove"; }, never, never, true, never>;
+}

package/components/query-bar/src/components/saved-filters-menu/saved-filters-menu.component.d.ts

@@ -0,0 +1,39 @@
+import { SdQuery, SdSavedFilter } from '../../query-bar.model';
+import * as i0 from "@angular/core";
+/**
+ * Saved-filters dropdown for `sd-query-bar`.
+ *
+ * Self-contained: persists the list to `localStorage` under
+ * `sd-query-bar:savedFilters:<key>` whenever the host passes a `[key]`. Without a
+ * key the dropdown still renders (host can still preview the menu) but the
+ * trigger stays disabled.
+ *
+ * The host owns the live `[query]`: each save snapshots it into a new entry,
+ * each apply emits the chosen filter back via `(apply)` for the host to install
+ * into its own `filters` / `logic` / `search` model.
+ *
+ * The save action (`promptSave`) is public so the parent toolbar can place its
+ * own "Lưu bộ lọc" button anywhere — typically next to the Search trigger.
+ */
+export declare class SdQuerySavedFiltersMenu {
+    #private;
+    /** Namespace key used to scope localStorage. `undefined` → menu disabled. */
+    readonly key: import("@angular/core").InputSignal<string | undefined>;
+    /** Current query the host wants to snapshot when the user clicks "Save current". */
+    readonly query: import("@angular/core").InputSignal<SdQuery<any>>;
+    /** Fired when the user picks a saved filter from the list. */
+    readonly apply: import("@angular/core").OutputEmitterRef<SdSavedFilter<any>>;
+    readonly savedFilters: import("@angular/core").WritableSignal<SdSavedFilter<any>[]>;
+    /**
+     * Prompt for a name and append a snapshot of the current query as a new
+     * saved filter. Public so the parent toolbar can wire its external "save"
+     * button to this method without re-implementing persistence.
+     */
+    promptSave(): void;
+    /** Apply a saved filter — host re-installs filters/logic/search via `(apply)`. */
+    pick(filter: SdSavedFilter): void;
+    /** Delete a saved filter by id. Stops propagation so the parent button doesn't fire `pick`. */
+    remove(id: string, ev?: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdQuerySavedFiltersMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdQuerySavedFiltersMenu, "sd-query-saved-filters-menu", never, { "key": { "alias": "key"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; }, { "apply": "apply"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,137 @@
+import { Filter, Operator } from '@sdcorejs/utils/models';
+import { SdQueryChipPopover } from './components/chip-popover/chip-popover.component';
+import { SdQueryPopoverChip } from './components/popover-chip/popover-chip.component';
+import { BuildingChip, SdQuery, SdQueryField, SdQueryLogic, SdSavedFilter, sdQueryFieldIcon } from './query-bar.model';
+import * as i0 from "@angular/core";
+type Density = 'compact' | 'comfortable';
+export declare class SdQueryBar {
+    #private;
+    /** All popover-mode chips in order — used to auto-open after addFilter / close before removeFilter. */
+    readonly popoverChips: import("@angular/core").Signal<readonly SdQueryPopoverChip[]>;
+    /** The extracted in-progress chip — owns operator menu + value picker view refs. */
+    private readonly buildChip;
+    /** The extracted chip popover — owns operator+value staging + commit-on-close. */
+    readonly chipPopover: import("@angular/core").Signal<SdQueryChipPopover | undefined>;
+    /** 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-filters dropdown on the right. Requires `[savedFiltersKey]` to actually persist. */
+    readonly showSavedFilters: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Namespace key for persisting saved filters to `localStorage`. When set, the saved-filters
+     * dropdown loads/saves under `sd-query-bar:savedFilters:<key>`. Leave undefined to disable.
+     */
+    readonly savedFiltersKey: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Snapshot of the current query — fed into `<sd-query-saved-filters-menu [query]>` so
+     * saving a filter captures live filters/logic/search.
+     */
+    readonly currentQuery: import("@angular/core").Signal<SdQuery<any>>;
+    /** Receive an applied filter from the saved-filters menu — re-install bar state + trigger apply. */
+    onApplyFilter(saved: SdSavedFilter): void;
+    /** 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 commit / close. */
+    readonly editingIndex: import("@angular/core").WritableSignal<number | null>;
+    /** Resolved field of the chip whose popover is currently open (or null). */
+    readonly editingField: import("@angular/core").Signal<SdQueryField | null>;
+    /**
+     * Multi-select is derived from the operator (IN / NOT_IN) — not a field flag.
+     * Only called by inline-mode + build-mode templates with a known operator;
+     * popover-mode chips read `multiple()` from the child popover directly.
+     */
+    multiple(op: Operator): boolean;
+    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;
+    readonly building: import("@angular/core").Signal<BuildingChip<any> | null>;
+    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;
+    /**
+     * Commit both ends of a BETWEEN range at once — called from `<sd-query-inline-chip>`'s
+     * `(commitRange)` output when the user picks a date range.
+     * why: sd-date-range emits {from,to} via (sdChange) — single call thay cho cặp
+     * setFilterRangeFrom / setFilterRangeTo cũ (đã bỏ).
+     */
+    setFilterRange(i: number, ev: {
+        from: unknown;
+        to: unknown;
+    } | null): 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 popover-mode chip is clicked — set editingIndex and seed the
+     * child popover's staging signals from the chip's Filter.
+     */
+    openChipPopover(index: number): void;
+    /** Receive `(commit)` from the child popover — splice into filters, null the index. */
+    onChipPopoverCommit(next: Filter): 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; }; "showSavedFilters": { "alias": "showSavedFilters"; "required": false; "isSignal": true; }; "savedFiltersKey": { "alias": "savedFiltersKey"; "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,136 @@
+import { Signal } from '@angular/core';
+import { SdSearch } from '@sd-angular/core/forms/models';
+import { Filter, NestedKeyOf, Operator } from '@sdcorejs/utils/models';
+export type SdQueryFieldType = '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_TYPE_ICON[type]` 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-type default). Use this for screens that don't need
+     *   operator choice.
+     * - `true` → show the full operator set for the field's `type`
+     *   (`SD_QUERY_OPERATORS_BY_TYPE[type]`).
+     * - `Operator[]` → show exactly these operators.
+     */
+    operators?: boolean | Operator[];
+    /**
+     * Operator the chip starts with. Falls back to `SD_QUERY_DEFAULT_OPERATOR_BY_TYPE[type]`:
+     * 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> {
+    type: 'string';
+}
+export interface SdQueryFieldNumber<T = any> extends SdQueryFieldBase<T> {
+    type: '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> {
+    type: 'boolean';
+    /** Labels rendered for the true/false buttons. Default: "Có" / "Không". */
+    trueLabel?: string;
+    falseLabel?: string;
+}
+export interface SdQueryFieldDate<T = any> extends SdQueryFieldBase<T> {
+    type: '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> {
+    type: 'values';
+    option: {
+        items: K[] | Signal<K[]> | (() => Promise<K[]>);
+        valueField: NestedKeyOf<K>;
+        displayField: NestedKeyOf<K>;
+    };
+}
+/**
+ * Server-backed options — searchable, paginated. Mirrors `SdTableColumnLazyValues.option`.
+ * `search` is the unified `SdSearch<K>` callback used by `sd-select`: it handles
+ * `{ type: 'SEARCH', searchText }` for live queries and `{ type: 'VALUE', value }` for
+ * resolving chip-display labels of already-selected IDs.
+ */
+export interface SdQueryFieldLazyValues<T = any, K = Record<string, any>> extends SdQueryFieldBase<T> {
+    type: 'lazy-values';
+    option: {
+        search: SdSearch<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;
+}
+/** Persisted bookmark of a query (filters + logic + search) — managed by `[savedFiltersKey]`. */
+export interface SdSavedFilter<T = any> {
+    id: string;
+    name: string;
+    query: SdQuery<T>;
+}
+/**
+ * Transient state of the in-progress chip during inline-mode token build (field →
+ * operator → value). Lives at the parent (`SdQueryBar.building()`) and is rendered
+ * by `<sd-query-build-chip>`. Step transitions:
+ *   - 'operator' — operator menu open, waiting for the user to pick a condition
+ *   - 'value'    — operator locked, value picker / seamless input is the focus
+ */
+export interface BuildingChip<T = any> {
+    field: SdQueryField<T>;
+    operator?: Operator;
+    step: 'operator' | 'value';
+    value?: unknown;
+}
+/** Full operator set per field type — used when `operators: true`. */
+export declare const SD_QUERY_OPERATORS_BY_TYPE: Record<SdQueryFieldType, Operator[]>;
+/** Default operator when a chip is created and `field.defaultOperator` is not set. */
+export declare const SD_QUERY_DEFAULT_OPERATOR_BY_TYPE: Record<SdQueryFieldType, Operator>;
+/** Icon fallback per field type when `SdQueryField.icon` is not set. */
+export declare const SD_QUERY_TYPE_ICON: Record<SdQueryFieldType, string>;
+/**
+ * Resolves the icon shown on chips and in the field picker.
+ * Priority: `field.icon` → `SD_QUERY_TYPE_ICON[field.type]` → `'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 type
+ * - `operators` is an array → that array (deduped against the type 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/section/src/section.component.d.ts

@@ -1,11 +1,12 @@
 import { SdBaseSecureComponent } from '@sd-angular/core/components/base';
+import { Color } from '@sdcorejs/utils/models';
 import * as i0 from "@angular/core";
 export declare class SdSection extends SdBaseSecureComponent {
     #private;
     title: import("@angular/core").InputSignal<string | null | undefined>;
     subTitle: import("@angular/core").InputSignal<string | null | undefined>;
     icon: import("@angular/core").InputSignal<string | null | undefined>;
-    iconColor: import("@angular/core").InputSignal<import("@sdcorejs/utils/models").Color>;
+    iconColor: import("@angular/core").InputSignal<Color>;
     collapsed: import("@angular/core").ModelSignal<boolean>;
     collapsable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     hideHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;

package/components/stepper/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/step.component';
+export * from './src/stepper.component';

package/components/stepper/src/step.component.d.ts

@@ -0,0 +1,17 @@
+import { TemplateRef } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export type SdStepState = 'pending' | 'active' | 'completed' | 'error' | string;
+export declare class SdStep {
+    label: import("@angular/core").InputSignal<string>;
+    icon: import("@angular/core").InputSignal<string | null | undefined>;
+    optional: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    editable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    stepControl: import("@angular/core").InputSignal<AbstractControl<any, any> | null | undefined>;
+    state: import("@angular/core").InputSignal<string | undefined>;
+    errorMessage: import("@angular/core").InputSignal<string | undefined>;
+    selectChange: import("@angular/core").OutputEmitterRef<void>;
+    bodyTpl: import("@angular/core").Signal<TemplateRef<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdStep, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdStep, "sd-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "stepControl": { "alias": "stepControl"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; }, { "selectChange": "selectChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,33 @@
+import { StepperSelectionEvent } from '@angular/cdk/stepper';
+import { MatStepper } from '@angular/material/stepper';
+import { SdBaseSecureComponent } from '@sd-angular/core/components/base';
+import { Color } from '@sdcorejs/utils/models';
+import { SdStep } from './step.component';
+import * as i0 from "@angular/core";
+export declare class SdStepper extends SdBaseSecureComponent {
+    steps: import("@angular/core").Signal<readonly SdStep[]>;
+    selectedIndex: import("@angular/core").ModelSignal<number>;
+    linear: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    orientation: import("@angular/core").InputSignal<"horizontal" | "vertical">;
+    labelPosition: import("@angular/core").InputSignal<"end" | "bottom">;
+    headerPosition: import("@angular/core").InputSignal<"bottom" | "top">;
+    animationDuration: import("@angular/core").InputSignal<string>;
+    disableRipple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    color: import("@angular/core").InputSignal<Color>;
+    autoId: import("@angular/core").InputSignal<string | undefined>;
+    selectionChange: import("@angular/core").OutputEmitterRef<StepperSelectionEvent>;
+    protected matStepper: import("@angular/core").Signal<MatStepper | undefined>;
+    get autoIdAttr(): string | null;
+    get cssActive(): string;
+    get cssActiveBg(): string;
+    get cssCompleted(): string;
+    get cssLine(): string;
+    constructor();
+    next(): void;
+    previous(): void;
+    reset(): void;
+    goTo(index: number): void;
+    protected onSelectionChange(ev: StepperSelectionEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdStepper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdStepper, "sd-stepper", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "headerPosition": { "alias": "headerPosition"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "autoId": { "alias": "autoId"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectionChange": "selectionChange"; }, ["steps"], never, true, never>;
+}

package/components/tab/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/tab.component';
+export * from './src/tab-group.component';

package/components/tab/src/tab-group.component.d.ts

@@ -0,0 +1,37 @@
+import { MatTabGroup } from '@angular/material/tabs';
+import { SdBaseSecureComponent } from '@sd-angular/core/components/base';
+import { Color } from '@sdcorejs/utils/models';
+import { SdTab } from './tab.component';
+import * as i0 from "@angular/core";
+export interface SdTabClosedEvent {
+    index: number;
+    tab: SdTab;
+}
+export declare class SdTabGroup extends SdBaseSecureComponent {
+    tabs: import("@angular/core").Signal<readonly SdTab[]>;
+    selectedIndex: import("@angular/core").ModelSignal<number>;
+    variant: import("@angular/core").InputSignal<"line" | "pills" | "segmented">;
+    color: import("@angular/core").InputSignal<Color>;
+    headerPosition: import("@angular/core").InputSignal<"above" | "below">;
+    alignTabs: import("@angular/core").InputSignal<"start" | "center" | "end">;
+    stretchTabs: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    animationDuration: import("@angular/core").InputSignal<string>;
+    disableRipple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    dynamicHeight: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    autoId: import("@angular/core").InputSignal<string | undefined>;
+    tabClosed: import("@angular/core").OutputEmitterRef<SdTabClosedEvent>;
+    protected matTabGroup: import("@angular/core").Signal<MatTabGroup | undefined>;
+    get autoIdAttr(): string | null;
+    get isPills(): boolean;
+    get isSegmented(): boolean;
+    get cssIndicator(): string;
+    get cssActive(): string;
+    get cssBadgeBg(): string;
+    get cssBadgeColor(): string;
+    constructor();
+    selectTab(index: number): void;
+    realignInkBar(): void;
+    protected onClose(tab: SdTab, index: number, event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTabGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdTabGroup, "sd-tab-group", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "headerPosition": { "alias": "headerPosition"; "required": false; "isSignal": true; }; "alignTabs": { "alias": "alignTabs"; "required": false; "isSignal": true; }; "stretchTabs": { "alias": "stretchTabs"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "disableRipple": { "alias": "disableRipple"; "required": false; "isSignal": true; }; "dynamicHeight": { "alias": "dynamicHeight"; "required": false; "isSignal": true; }; "autoId": { "alias": "autoId"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "tabClosed": "tabClosed"; }, ["tabs"], never, true, never>;
+}

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

@@ -0,0 +1,13 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SdTab {
+    label: import("@angular/core").InputSignal<string>;
+    icon: import("@angular/core").InputSignal<string | null | undefined>;
+    badge: import("@angular/core").InputSignal<string | number | null | undefined>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    closable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    close: import("@angular/core").OutputEmitterRef<void>;
+    bodyTpl: import("@angular/core").Signal<TemplateRef<unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdTab, "sd-tab", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "close": "close"; }, never, ["*"], true, never>;
+}

package/components/tab-router/src/decorators/tab.decorator.d.ts

@@ -1,5 +1,5 @@
 import { Type } from '@angular/core';
-import { SdColor } from '@sd-angular/core/utilities/models';
+import { Color } from '@sdcorejs/utils/models';
 export interface SdTabComponentArgs {
     url?: string;
     params?: any;
@@ -11,6 +11,6 @@ export declare interface SdTabComponentBuilder {
     name: string | ((args: SdTabComponentArgs) => string);
     icon?: string | ((args: SdTabComponentArgs) => string);
     tooltip?: string | ((args: SdTabComponentArgs) => string);
-    color?: SdColor | ((args: SdTabComponentArgs) => SdColor);
+    color?: Color | ((args: SdTabComponentArgs) => Color);
 }
 export declare function SdTabComponent<T>(builder: SdTabComponentBuilder): (constructor: T) => void;

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

@@ -1,11 +1,11 @@
 import { Type } from '@angular/core';
-import { SdColor } from '@sd-angular/core/utilities/models';
+import { Color } from '@sdcorejs/utils/models';
 import { Subject } from 'rxjs';
 export interface SdTabInfo {
     name: string;
     icon?: string;
     tooltip?: string;
-    color?: SdColor;
+    color?: Color;
 }
 export interface SdTab {
     component: Type<any>;

package/components/table/index.d.ts

@@ -2,6 +2,7 @@ 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';

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/config/config.component.d.ts

@@ -6,8 +6,10 @@ import { SdTableOption } from '../../models/table-option.model';
 import * as i0 from "@angular/core";
 export declare class ConfigComponent {
     #private;
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
     tableOption: import("@angular/core").InputSignal<SdTableOption | undefined>;
     changes: import("@angular/core").OutputEmitterRef<ConfiguredTableResult>;
+    autoId: import("@angular/core").Signal<string>;
     modal: import("@angular/core").Signal<SdModal | undefined>;
     table: import("@angular/core").Signal<MatTable<SdTableColumn>>;
     configuration: import("@angular/core").WritableSignal<ConfiguredTable | undefined>;
@@ -21,5 +23,5 @@ export declare class ConfigComponent {
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigComponent, "config", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "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

@@ -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/components/selector-action/selector-action.component.d.ts

@@ -4,13 +4,15 @@ import { Action } from './action-filter.pipe';
 import * as i0 from "@angular/core";
 export declare class SelectorActionComponent {
     #private;
+    autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
     tableOption: import("@angular/core").InputSignal<SdTableOption | undefined>;
     selectedTableItems: import("@angular/core").InputSignal<SdTableItem<any>[] | undefined>;
     clear: import("@angular/core").OutputEmitterRef<void>;
+    autoId: import("@angular/core").Signal<string>;
     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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectorActionComponent, "selector-action", never, { "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; "tableOption": { "alias": "tableOption"; "required": false; "isSignal": true; }; "selectedTableItems": { "alias": "selectedTableItems"; "required": false; "isSignal": true; }; }, { "clear": "clear"; }, never, never, true, never>;
 }