@sdcorejs/angular 19.0.0-rc.1

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

@@ -0,0 +1,136 @@
+import { Signal } from '@angular/core';
+import { SdSearch } from '@sdcorejs/angular/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/query-builder/index.d.ts

@@ -0,0 +1 @@
+export * from './src/query-builder.component';

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

@@ -0,0 +1,26 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface QueryRule {
+    field: string;
+    operator: string;
+    value: any;
+}
+export interface QueryGroup {
+    condition: 'AND' | 'OR';
+    rules: (QueryRule | QueryGroup)[];
+    isOpen?: boolean;
+}
+export declare class SdQueryBuilder {
+    group: QueryGroup;
+    groupChange: EventEmitter<QueryGroup>;
+    isGroup(item: any): item is QueryGroup;
+    toggleCondition(group: QueryGroup, condition: 'AND' | 'OR'): void;
+    toggleDropdown(group: QueryGroup, event: Event): void;
+    closeAll(): void;
+    closeAllDropdowns(group: QueryGroup): void;
+    addRule(group: QueryGroup): void;
+    addGroup(group: QueryGroup): void;
+    removeItem(parentGroup: QueryGroup, index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdQueryBuilder, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdQueryBuilder, "sd-query-builder", never, { "group": { "alias": "group"; "required": false; }; }, { "groupChange": "groupChange"; }, never, never, true, never>;
+}

package/components/quick-action/index.d.ts

@@ -0,0 +1 @@
+export * from './src/quick-action.component';

package/components/quick-action/src/quick-action.component.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class SdQuickAction {
+    /**
+     * Toggle visibility of the floating toolbar. Bare attribute = true.
+     */
+    readonly opened: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdQuickAction, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdQuickAction, "sd-quick-action", never, { "opened": { "alias": "opened"; "required": false; "isSignal": true; }; }, {}, never, ["[sdMessage]", "[sdAction]"], true, never>;
+}

package/components/section/index.d.ts

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

package/components/section/src/section-item/section-item.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class SdSectionItem {
+    label: import("@angular/core").InputSignal<string>;
+    labelWidth: import("@angular/core").InputSignalWithTransform<string, string | null | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSectionItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdSectionItem, "sd-section-item", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "labelWidth": { "alias": "labelWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,18 @@
+import { SdBaseSecureComponent } from '@sdcorejs/angular/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<Color>;
+    collapsed: import("@angular/core").ModelSignal<boolean>;
+    collapsable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    hideHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    noPaddingBody: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    toggleCollapse: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSection, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdSection, "sd-section", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subTitle": { "alias": "subTitle"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconColor": { "alias": "iconColor"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "collapsable": { "alias": "collapsable"; "required": false; "isSignal": true; }; "hideHeader": { "alias": "hideHeader"; "required": false; "isSignal": true; }; "noPaddingBody": { "alias": "noPaddingBody"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["[sdHeaderLeft]", "[sdHeaderRight]", "*"], true, never>;
+}

package/components/side-drawer/index.d.ts

@@ -0,0 +1 @@
+export * from './src/side-drawer.component';

package/components/side-drawer/src/side-drawer.component.d.ts

@@ -0,0 +1,30 @@
+import { CdkPortal } from '@angular/cdk/portal';
+import { SdBaseSecureComponent } from '@sdcorejs/angular/components/base';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class SdSideDrawer extends SdBaseSecureComponent {
+    #private;
+    id: string;
+    portal: import("@angular/core").Signal<CdkPortal>;
+    title: import("@angular/core").InputSignal<string>;
+    width: import("@angular/core").InputSignal<string>;
+    hideClose: import("@angular/core").InputSignalWithTransform<boolean, boolean | "">;
+    disableBackdropClose: import("@angular/core").InputSignalWithTransform<boolean, boolean | "">;
+    drawerClass: import("@angular/core").InputSignal<any>;
+    readonly autoIdInput: import("@angular/core").InputSignal<string | null | undefined>;
+    readonly autoId: import("@angular/core").Signal<string | undefined>;
+    sdClosed: import("@angular/core").OutputEmitterRef<void>;
+    readonly isOpened: import("@angular/core").Signal<boolean>;
+    readonly isLoading: import("@angular/core").Signal<boolean>;
+    readonly dataOpened: import("@angular/core").Signal<"true" | "false">;
+    readonly dataLoading: import("@angular/core").Signal<"true" | "false">;
+    isHovered$: Observable<boolean>;
+    constructor();
+    open: () => void;
+    close: () => void;
+    startLoading: () => void;
+    stopLoading: () => void;
+    preventScroll: (event: Event) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSideDrawer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdSideDrawer, "sd-side-drawer", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "hideClose": { "alias": "hideClose"; "required": false; "isSignal": true; }; "disableBackdropClose": { "alias": "disableBackdropClose"; "required": false; "isSignal": true; }; "drawerClass": { "alias": "drawerClass"; "required": false; "isSignal": true; }; "autoIdInput": { "alias": "autoId"; "required": false; "isSignal": true; }; }, { "sdClosed": "sdClosed"; }, never, ["[sdHeaderLeft]", "[sdHeaderRight]", "*", "[sdFooter]"], true, never>;
+}

package/components/splitter/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/splitter.component';
+export * from './src/splitter-panel/splitter-panel.component';
+export type { SplitterOrientation, SplitterPanelUnit, SplitterPanelState, SplitterLayoutState } from './src/splitter.models';

package/components/splitter/src/splitter-handle/splitter-handle.component.d.ts

@@ -0,0 +1,24 @@
+import { ElementRef } from '@angular/core';
+import { SplitterOrientation } from '../splitter.models';
+import * as i0 from "@angular/core";
+export declare class SdSplitterHandleComponent {
+    #private;
+    readonly elementRef: ElementRef<HTMLElement>;
+    orientation: import("@angular/core").InputSignal<SplitterOrientation>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    keyboardStep: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    ariaValueMin: import("@angular/core").InputSignal<number | undefined>;
+    ariaValueMax: import("@angular/core").InputSignal<number | undefined>;
+    ariaValueNow: import("@angular/core").InputSignal<number | undefined>;
+    readonly dragStart: import("@angular/core").OutputEmitterRef<void>;
+    readonly dragMove: import("@angular/core").OutputEmitterRef<number>;
+    readonly dragEnd: import("@angular/core").OutputEmitterRef<void>;
+    readonly toggleRequest: import("@angular/core").OutputEmitterRef<void>;
+    onDblClick(): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    onPointerDown(ev: PointerEvent): void;
+    onPointerMove(ev: PointerEvent): void;
+    onPointerUp(ev: PointerEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSplitterHandleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdSplitterHandleComponent, "sd-splitter-handle", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; "ariaValueMin": { "alias": "ariaValueMin"; "required": false; "isSignal": true; }; "ariaValueMax": { "alias": "ariaValueMax"; "required": false; "isSignal": true; }; "ariaValueNow": { "alias": "ariaValueNow"; "required": false; "isSignal": true; }; }, { "dragStart": "dragStart"; "dragMove": "dragMove"; "dragEnd": "dragEnd"; "toggleRequest": "toggleRequest"; }, never, never, true, never>;
+}

package/components/splitter/src/splitter-panel/splitter-panel.component.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef } from '@angular/core';
+import { SplitterPanelUnit } from '../splitter.models';
+import * as i0 from "@angular/core";
+export declare class SdSplitterPanelComponent {
+    readonly elementRef: ElementRef<HTMLElement>;
+    panelId: import("@angular/core").InputSignal<string | undefined>;
+    size: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    unit: import("@angular/core").InputSignal<SplitterPanelUnit>;
+    minSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    maxSize: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+    collapsible: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    collapsed: import("@angular/core").ModelSignal<boolean>;
+    resizable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSplitterPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdSplitterPanelComponent, "sd-splitter-panel", never, { "panelId": { "alias": "panelId"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "minSize": { "alias": "minSize"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}

package/components/splitter/src/splitter-state.service.d.ts

@@ -0,0 +1,26 @@
+import { ResolvedPanelMeta, SplitterLayoutState } from './splitter.models';
+import * as i0 from "@angular/core";
+export declare class SplitterStateService {
+    #private;
+    readonly liveSizes: import("@angular/core").WritableSignal<ReadonlyMap<string | number, number>>;
+    readonly collapsedMap: import("@angular/core").WritableSignal<ReadonlyMap<string | number, boolean>>;
+    readonly committedLayout: import("@angular/core").WritableSignal<SplitterLayoutState>;
+    setPanelMeta(metas: ResolvedPanelMeta[]): void;
+    getPanelMetas(): ReadonlyArray<Readonly<ResolvedPanelMeta>>;
+    setLiveSize(id: string | number, size: number): void;
+    setCollapsed(id: string | number, collapsed: boolean): void;
+    reconcile(metas: ResolvedPanelMeta[], stored: SplitterLayoutState | null | undefined): void;
+    /**
+     * Áp delta px lên 2 panel kề handleIndex (prev = handleIndex, next = handleIndex + 1).
+     * Khi snap collapsible panel: tự set collapsed + reset size = 0.
+     * Khi expand collapsible panel đang collapsed: nếu delta đủ lớn → expand.
+     * Trả về delta thực sự đã áp.
+     */
+    applyDelta(handleIndex: number, deltaPx: number, containerPx: number, snapThreshold?: number): number;
+    collapsePanel(id: string | number): void;
+    expandPanel(id: string | number): void;
+    togglePanel(id: string | number): void;
+    commit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SplitterStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SplitterStateService>;
+}

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

@@ -0,0 +1,28 @@
+import { SdSplitterPanelComponent } from './splitter-panel/splitter-panel.component';
+import { SplitterLayoutState, SplitterOrientation } from './splitter.models';
+import * as i0 from "@angular/core";
+export declare class SdSplitterComponent {
+    #private;
+    orientation: import("@angular/core").InputSignal<SplitterOrientation>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    storageKey: import("@angular/core").InputSignal<string | undefined>;
+    snapThreshold: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    keyboardStep: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    readonly resizeEnd: import("@angular/core").OutputEmitterRef<SplitterLayoutState>;
+    readonly collapsedChange: import("@angular/core").OutputEmitterRef<{
+        panelId: string | number;
+        collapsed: boolean;
+    }>;
+    readonly layoutChange: import("@angular/core").OutputEmitterRef<SplitterLayoutState>;
+    readonly panels: import("@angular/core").Signal<readonly SdSplitterPanelComponent[]>;
+    constructor();
+    getLayout(): SplitterLayoutState;
+    setLayout(state: SplitterLayoutState): void;
+    resetLayout(): void;
+    collapse(target: number | string): void;
+    expand(target: number | string): void;
+    toggle(target: number | string): void;
+    resizePanel(target: number | string, size: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdSplitterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdSplitterComponent, "sd-splitter", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "storageKey": { "alias": "storageKey"; "required": false; "isSignal": true; }; "snapThreshold": { "alias": "snapThreshold"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; }, { "resizeEnd": "resizeEnd"; "collapsedChange": "collapsedChange"; "layoutChange": "layoutChange"; }, ["panels"], ["sd-splitter-panel"], true, never>;
+}

package/components/splitter/src/splitter.models.d.ts

@@ -0,0 +1,23 @@
+export type SplitterOrientation = 'horizontal' | 'vertical';
+export type SplitterPanelUnit = 'px' | 'flex';
+export interface SplitterPanelState {
+    id: string | number;
+    size: number;
+    unit: SplitterPanelUnit;
+    collapsed: boolean;
+}
+export interface SplitterLayoutState {
+    v: 1;
+    panels: SplitterPanelState[];
+}
+export interface ResolvedPanelMeta {
+    id: string | number;
+    index: number;
+    unit: SplitterPanelUnit;
+    minSize: number;
+    maxSize: number | undefined;
+    collapsible: boolean;
+    resizable: boolean;
+    declaredSize: number;
+    lastSize: number;
+}

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 '@sdcorejs/angular/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 '@sdcorejs/angular/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/index.d.ts

@@ -0,0 +1,4 @@
+export * from './src/components/tab-router-outlet/tab-router-outlet.component';
+export * from './src/services/tab-router.service';
+export * from './src/models/tab-router.model';
+export * from './src/decorators/tab.decorator';

package/components/tab-router/src/actions/tab-router.action.d.ts

@@ -0,0 +1,5 @@
+import { SdTab } from '../models/tab-router.model';
+export interface SdTabAction {
+    type: 'close';
+    tab: SdTab;
+}

package/components/tab-router/src/components/tab-router-item/tab-router-item.component.d.ts

@@ -0,0 +1,22 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { SdTab, SdTabInfo } from '../../models';
+import { SdTabRouterService } from '../../services/tab-router.service';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class SdTabRouterItemComponent implements OnInit, OnDestroy {
+    #private;
+    private cdRef;
+    private tabRouterService;
+    private router;
+    tab: SdTab;
+    tabInfo?: SdTabInfo;
+    constructor(cdRef: ChangeDetectorRef, tabRouterService: SdTabRouterService, router: Router);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onTabClick: (event: Event) => void;
+    close: (event: Event) => void;
+    onMousedown: (event: MouseEvent) => void;
+    onMouseup: (event: MouseEvent) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTabRouterItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdTabRouterItemComponent, "sd-tab-router-item", never, { "tab": { "alias": "tab"; "required": true; }; }, {}, never, never, true, never>;
+}

package/components/tab-router/src/components/tab-router-nav/tab-router-nav.component.d.ts

@@ -0,0 +1,16 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+import { SdTab } from '../../models/tab-router.model';
+import * as i0 from "@angular/core";
+export declare class SdTabRouterNavComponent {
+    tabRouterNav: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    tabs: import("@angular/core").InputSignal<SdTab[]>;
+    mode: 'default' | 'compact';
+    cdRef: ChangeDetectorRef;
+    elementRef: ElementRef<any>;
+    onResize(): void;
+    checkUI: () => void;
+    onDrop: (event: CdkDragDrop<SdTab[]>) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTabRouterNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdTabRouterNavComponent, "sd-tab-router-nav", never, { "tabs": { "alias": "tabs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/components/tab-router/src/components/tab-router-outlet/tab-router-outlet.component.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy } from '@angular/core';
+import { SdTab } from '../../models';
+import { SdTabRouterNavComponent } from '../tab-router-nav/tab-router-nav.component';
+import * as i0 from "@angular/core";
+export declare class SdTabRouterOutletComponent implements OnDestroy {
+    #private;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    tabRouterNav: import("@angular/core").Signal<SdTabRouterNavComponent | undefined>;
+    tabs: import("@angular/core").WritableSignal<SdTab[]>;
+    constructor();
+    ngOnDestroy(): void;
+    tabTrackBy: (index: number, tab: SdTab) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdTabRouterOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SdTabRouterOutletComponent, "sd-tab-router-outlet", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,16 @@
+import { Type } from '@angular/core';
+import { Color } from '@sdcorejs/utils/models';
+export interface SdTabComponentArgs {
+    url?: string;
+    params?: any;
+    queryParams?: any;
+    data?: Record<string, any>;
+}
+export declare interface SdTabComponentBuilder {
+    component: Type<any>;
+    name: string | ((args: SdTabComponentArgs) => string);
+    icon?: string | ((args: SdTabComponentArgs) => string);
+    tooltip?: string | ((args: SdTabComponentArgs) => string);
+    color?: Color | ((args: SdTabComponentArgs) => Color);
+}
+export declare function SdTabComponent<T>(builder: SdTabComponentBuilder): (constructor: T) => void;

package/components/tab-router/src/events/tab-router.event.d.ts

@@ -0,0 +1,11 @@
+import { SdTab } from '../models/tab-router.model';
+export declare class SdTabBase {
+    #private;
+    constructor(tab: SdTab | undefined);
+    get tab(): SdTab | undefined;
+}
+export declare class SdTabActivated extends SdTabBase {
+}
+export declare class SdTabDeactivated extends SdTabBase {
+}
+export declare type SdTabEvent = SdTabActivated | SdTabDeactivated;

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

@@ -0,0 +1 @@
+export * from './tab-router.model';