@seniorsistemas/data-seniorx-core 2.3.0 → 3.0.0

package/features/spotlight/components/spotlight-overlay/spotlight-overlay.component.d.ts

@@ -0,0 +1,59 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import type { SpotlightStep } from '../../../../core/types/spotlight.type';
+import * as i0 from "@angular/core";
+export declare class SpotlightOverlayComponent implements OnInit, OnDestroy {
+    private readonly tourService;
+    private readonly destroyRef;
+    private readonly zone;
+    private readonly overlay;
+    private readonly environmentInjector;
+    private readonly focusTrapFactory;
+    readonly isActive: import("@angular/core").Signal<boolean>;
+    readonly currentStep: import("@angular/core").Signal<(SpotlightStep & {
+        showDoNotShowAgain?: boolean;
+    }) | undefined>;
+    readonly currentIndex: import("@angular/core").Signal<number>;
+    readonly totalSteps: import("@angular/core").Signal<number>;
+    readonly targetRect: import("@angular/core").WritableSignal<DOMRect | null>;
+    readonly topMaskStyle: import("@angular/core").Signal<Record<string, string>>;
+    readonly leftMaskStyle: import("@angular/core").Signal<Record<string, string>>;
+    readonly rightMaskStyle: import("@angular/core").Signal<Record<string, string>>;
+    readonly bottomMaskStyle: import("@angular/core").Signal<Record<string, string>>;
+    readonly transparentBlockerStyle: import("@angular/core").Signal<Record<string, string>>;
+    private resizeObserver;
+    private popoverOverlayRef;
+    private popoverComponentRef;
+    private popoverSubscriptions;
+    private focusTrap;
+    private previouslyFocusedElement;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onNext(): void;
+    protected onPrevious(): void;
+    protected onClose(): void;
+    protected onDismiss(): void;
+    private updatePopoverOverlay;
+    private setPopoverZIndex;
+    private attachPopoverPortal;
+    private updatePopoverInputs;
+    private scheduleSync;
+    private activateTourMode;
+    private scheduleFocusTrapRefocus;
+    private subscribeToViewportUpdates;
+    private subscribeToEscapeKey;
+    private runOverlayRefresh;
+    private syncResolvedElement;
+    private applyResolvedElement;
+    private syncDirectionAndArrow;
+    private computeDirection;
+    private computeDirectionByDistance;
+    private computeArrowOffset;
+    private destroyPopoverOverlay;
+    private updateTargetRect;
+    private refreshRect;
+    private observeElement;
+    private disconnectResizeObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpotlightOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpotlightOverlayComponent, "sdc-spotlight-overlay", never, {}, {}, never, never, true, never>;
+}

package/features/spotlight/directives/spotlight-step.directive.d.ts

@@ -0,0 +1,13 @@
+import { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SpotlightStepDirective implements OnDestroy {
+    sdcSpotlightStep: import("@angular/core").InputSignal<string | undefined>;
+    sSpotlightStep: import("@angular/core").InputSignal<string | undefined>;
+    private readonly elementRef;
+    private readonly tourService;
+    private currentId;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpotlightStepDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SpotlightStepDirective, "[sdcSpotlightStep],[sSpotlightStep]", never, { "sdcSpotlightStep": { "alias": "sdcSpotlightStep"; "required": false; "isSignal": true; }; "sSpotlightStep": { "alias": "sSpotlightStep"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/features/spotlight/services/spotlight-tour.service.d.ts

@@ -0,0 +1,46 @@
+import { ElementRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import type { SpotlightConfig, SpotlightStep, SpotlightStepChangedEvent, SpotlightStopEvent } from '../../../core/types/spotlight.type';
+import * as i0 from "@angular/core";
+type SpotlightStepInternal = SpotlightStep & {
+    showDoNotShowAgain?: boolean;
+};
+export declare class SpotlightTourService {
+    private readonly overlay;
+    private readonly environmentInjector;
+    private overlayRef;
+    private readonly stepsSignal;
+    private readonly currentIndexSignal;
+    private readonly activeSignal;
+    private readonly registrationVersionSignal;
+    private readonly registeredElements;
+    private pendingDoNotShowAgain;
+    private interactionVersion;
+    private readonly stoppedSubject;
+    private readonly stepChangedSubject;
+    readonly isActive: import("@angular/core").Signal<boolean>;
+    readonly currentIndex: import("@angular/core").Signal<number>;
+    readonly totalSteps: import("@angular/core").Signal<number>;
+    readonly currentStep: import("@angular/core").Signal<SpotlightStepInternal | undefined>;
+    readonly stopped$: Observable<SpotlightStopEvent>;
+    readonly stepChanged$: Observable<SpotlightStepChangedEvent>;
+    readonly registrationVersion: import("@angular/core").Signal<number>;
+    start(steps: SpotlightStep[]): void;
+    spotlight(stepId: string, config: SpotlightConfig): void;
+    next(doNotShowAgain?: boolean): void;
+    previous(): void;
+    stop(event?: Partial<SpotlightStopEvent>): void;
+    registerElement(stepId: string, element: ElementRef): void;
+    unregisterElement(stepId: string): void;
+    getElement(stepId: string): ElementRef | undefined;
+    private advance;
+    private advanceIfCurrent;
+    private retreat;
+    private retreatIfCurrent;
+    private isCurrentInteraction;
+    private attachOverlay;
+    private detachOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpotlightTourService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpotlightTourService>;
+}
+export {};

package/features/spotlight/spotlight.component.d.ts

@@ -0,0 +1,59 @@
+import { TemplateRef } from '@angular/core';
+import type { SpotlightPosition, SpotlightStepAction } from '../../core/types/spotlight.type';
+import * as i0 from "@angular/core";
+export declare class SpotlightComponent {
+    private static readonly SPOTLIGHT_DUPLICATE_LITERAL;
+    title: import("@angular/core").InputSignal<string | TemplateRef<unknown>>;
+    message: import("@angular/core").InputSignal<string | TemplateRef<unknown> | undefined>;
+    content: import("@angular/core").InputSignal<TemplateRef<unknown> | null>;
+    position: import("@angular/core").InputSignal<SpotlightPosition>;
+    currentStep: import("@angular/core").InputSignal<number>;
+    totalSteps: import("@angular/core").InputSignal<number>;
+    showDoNotShowAgain: import("@angular/core").InputSignal<boolean>;
+    actions: import("@angular/core").InputSignal<SpotlightStepAction[]>;
+    arrowOffsetPx: import("@angular/core").InputSignal<number | null>;
+    closed: import("@angular/core").OutputEmitterRef<void>;
+    next: import("@angular/core").OutputEmitterRef<void>;
+    previous: import("@angular/core").OutputEmitterRef<void>;
+    understand: import("@angular/core").OutputEmitterRef<void>;
+    isDoNotShowAgainChecked: import("@angular/core").WritableSignal<boolean>;
+    protected readonly closeLabelKey = "platform.datacore.spotlight.close";
+    protected readonly backLabelKey = "platform.datacore.spotlight.back";
+    protected readonly nextLabelKey = "platform.datacore.spotlight.next";
+    protected readonly completeLabelKey = "platform.datacore.spotlight.complete";
+    protected readonly understoodLabelKey = "platform.datacore.spotlight.understood";
+    protected readonly doNotShowAgainLabelKey = "platform.datacore.spotlight.do_not_show_again";
+    protected readonly stepCounterLabelKey = "platform.datacore.spotlight.step_counter";
+    protected readonly stepProgressLabelKey = "platform.datacore.spotlight.step_progress";
+    private static instanceCount;
+    private static incrementInstanceCount;
+    protected readonly instanceId: string;
+    protected readonly titleId: string;
+    protected readonly descId: string;
+    protected get titleTemplate(): TemplateRef<unknown> | null;
+    protected get titleString(): string;
+    protected get messageTemplate(): TemplateRef<unknown> | null;
+    protected get messageString(): string;
+    protected get arrowPosition(): SpotlightPosition;
+    protected get isArrowTop(): boolean;
+    protected get isArrowBottom(): boolean;
+    protected get isArrowLeft(): boolean;
+    protected get isArrowRight(): boolean;
+    protected get arrowTransform(): string;
+    protected get arrowJustifyContent(): string;
+    protected get arrowAlignItems(): string;
+    protected get arrowPaddingStyle(): Record<string, string>;
+    private readonly FLEX_START;
+    private readonly FLEX_END;
+    private readonly FLEX_CENTER;
+    private getArrowTransformForDirection;
+    private getFlexPropertyForAlignment;
+    protected onClose(): void;
+    protected onNext(): void;
+    protected onPrevious(): void;
+    protected onUnderstand(): void;
+    protected toggleDoNotShowAgain(): void;
+    private getOppositeDirection;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpotlightComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpotlightComponent, "sdc-spotlight", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "currentStep": { "alias": "currentStep"; "required": false; "isSignal": true; }; "totalSteps": { "alias": "totalSteps"; "required": false; "isSignal": true; }; "showDoNotShowAgain": { "alias": "showDoNotShowAgain"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "arrowOffsetPx": { "alias": "arrowOffsetPx"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "next": "next"; "previous": "previous"; "understand": "understand"; }, never, never, true, never>;
+}

package/features/star-rating/star-rating.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class StarRatingComponent implements ControlValueAccessor {
+    private readonly cdr;
+    private readonly translate;
+    value: number;
+    maxStars: number;
+    disabled: boolean;
+    ariaLabel?: string;
+    valueChange: EventEmitter<number>;
+    private onChangeFn;
+    private onTouchedFn;
+    get stars(): number[];
+    get groupAriaLabel(): string;
+    isFilled(star: number): boolean;
+    getStarAriaLabel(star: number): string;
+    onStarClick(star: number): void;
+    onKeydown(event: KeyboardEvent, star: number): void;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StarRatingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StarRatingComponent, "sdc-star-rating", never, { "value": { "alias": "value"; "required": false; }; "maxStars": { "alias": "maxStars"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/features/stepper/stepper.component.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from '@angular/core';
+import { Step, StepSelectionEvent, StepState } from '../../core/types/stepper.type';
+import * as i0 from "@angular/core";
+export declare class StepperComponent {
+    private static nextId;
+    private static allocateId;
+    id: string;
+    steps: Step[];
+    activeIndex: number;
+    stepSelected: EventEmitter<StepSelectionEvent>;
+    protected readonly stepState: typeof StepState;
+    get visibleSteps(): Step[];
+    protected trackByStep(index: number, step: Step): string | number;
+    protected resolveStepId(step: Step, index: number): string;
+    protected resolveStepAriaLabel(step: Step): string | null;
+    protected resolveStepAriaControls(step: Step): string | null;
+    protected onStepClick(step: Step, index: number, event: Event): void;
+    protected isVisited(index: number): boolean;
+    protected isActive(index: number): boolean;
+    protected connectorState(index: number): 'active' | 'inactive';
+    static ɵfac: i0.ɵɵFactoryDeclaration<StepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StepperComponent, "sdc-stepper, sdc-steps", never, { "id": { "alias": "id"; "required": false; }; "steps": { "alias": "steps"; "required": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; }; }, { "stepSelected": "stepSelected"; }, never, never, true, never>;
+}

package/features/switch/switch.component.d.ts

@@ -28,6 +28,7 @@ export declare class SwitchComponent extends InputsComponent<boolean> {
     get messageId(): string;
     get describedBy(): string | null;
     get computedDisabled(): boolean;
+    get inputDisabled(): boolean;
     get hasTooltip(): boolean;
     get switchReadonly(): boolean;
     get switchTabIndex(): number;
@@ -37,7 +38,7 @@ export declare class SwitchComponent extends InputsComponent<boolean> {
     get resolvedAriaLabel(): string | null;
     get resolvedAriaLabelledBy(): string | null;
     get switchAriaChecked(): 'true' | 'false';
-    onInnerChange(next: boolean): void;
+    onNativeChange(event: Event): void;
     onInterceptToggle(event: Event): void;
     onInterceptKeydown(event: KeyboardEvent): void;
     onBlur(): void;

package/features/tab/tab.component.d.ts

@@ -1,4 +1,4 @@
-import { AfterContentChecked, AfterContentInit, AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { AfterContentInit, AfterContentChecked, AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
 import { TabHeader } from '../../core/types/tab.type';
 import * as i0 from "@angular/core";
 export declare class TabComponent implements AfterContentInit, AfterContentChecked, AfterViewInit, OnDestroy {

package/features/table/components/table-cell-content.component.d.ts

@@ -1,7 +1,6 @@
 import { EventEmitter } from '@angular/core';
 import type { RowBase, TableCellConfigMap, TableColumn } from '../../../core/types/table.type';
 import type { TableTextOverflow } from '../../../core/types/table-column.type';
-import { normalizeTableColumnAlignment } from '../utils/table-layout.util';
 import * as i0 from "@angular/core";
 export declare class TableCellContentComponent<T extends RowBase = RowBase> {
     cellConfigs: TableCellConfigMap<T>;
@@ -13,6 +12,8 @@ export declare class TableCellContentComponent<T extends RowBase = RowBase> {
     defaultTextOverflow?: TableTextOverflow;
     rowCheckboxId: string;
     rowLabel: string;
+    rowSelectionDisabled: boolean;
+    forceLeftAlign: boolean;
     rowSelected: boolean;
     toggleActionsMenu: EventEmitter<{
         event: Event;
@@ -22,7 +23,7 @@ export declare class TableCellContentComponent<T extends RowBase = RowBase> {
     triggerButtonAction: EventEmitter<void>;
     protected readonly iconSize = 16;
     protected readonly tagIconSize = 12;
-    get resolvedAlignment(): ReturnType<typeof normalizeTableColumnAlignment>;
+    get resolvedAlignment(): 'left' | 'center' | 'right';
     protected cellTextValue(field?: string | undefined): string;
     protected displayText(field?: string | undefined): string;
     protected isEllipsisMode(): boolean;
@@ -38,5 +39,5 @@ export declare class TableCellContentComponent<T extends RowBase = RowBase> {
     protected actionsButtonLabel(): string;
     protected onActionsClick(event: Event, trigger: HTMLElement): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableCellContentComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellContentComponent<any>, "sdc-table-cell-content", never, { "cellConfigs": { "alias": "cellConfigs"; "required": true; }; "col": { "alias": "col"; "required": true; }; "resolveValue": { "alias": "resolveValue"; "required": true; }; "row": { "alias": "row"; "required": true; }; "actionsMenuOpen": { "alias": "actionsMenuOpen"; "required": false; }; "actionsMenuId": { "alias": "actionsMenuId"; "required": false; }; "defaultTextOverflow": { "alias": "defaultTextOverflow"; "required": false; }; "rowCheckboxId": { "alias": "rowCheckboxId"; "required": false; }; "rowLabel": { "alias": "rowLabel"; "required": false; }; "rowSelected": { "alias": "rowSelected"; "required": false; }; }, { "toggleActionsMenu": "toggleActionsMenu"; "toggleRow": "toggleRow"; "triggerButtonAction": "triggerButtonAction"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellContentComponent<any>, "sdc-table-cell-content", never, { "cellConfigs": { "alias": "cellConfigs"; "required": true; }; "col": { "alias": "col"; "required": true; }; "resolveValue": { "alias": "resolveValue"; "required": true; }; "row": { "alias": "row"; "required": true; }; "actionsMenuOpen": { "alias": "actionsMenuOpen"; "required": false; }; "actionsMenuId": { "alias": "actionsMenuId"; "required": false; }; "defaultTextOverflow": { "alias": "defaultTextOverflow"; "required": false; }; "rowCheckboxId": { "alias": "rowCheckboxId"; "required": false; }; "rowLabel": { "alias": "rowLabel"; "required": false; }; "rowSelectionDisabled": { "alias": "rowSelectionDisabled"; "required": false; }; "forceLeftAlign": { "alias": "forceLeftAlign"; "required": false; }; "rowSelected": { "alias": "rowSelected"; "required": false; }; }, { "toggleActionsMenu": "toggleActionsMenu"; "toggleRow": "toggleRow"; "triggerButtonAction": "triggerButtonAction"; }, never, never, true, never>;
 }

package/features/table/table.component.d.ts

@@ -1,10 +1,15 @@
-import { EventEmitter } from '@angular/core';
+import { AfterViewInit, EventEmitter, OnDestroy } from '@angular/core';
 import type { PaginatorState } from '../../core/types/paginator.type';
 import { type SearchTriggerMode } from '../../core/types/searchbox.type';
 import { type RowBase, type SortOrder, type TableActionMenuItem as NativeActionMenuItem, type TableActionMenuCloseEvent, type TableCellConfig, type TableColumn, type TableOpenMenuState as OpenMenuState, type TableOptions, type TableSearchEvent, TableMenuFocusTarget } from '../../core/types/table.type';
 import * as i0 from "@angular/core";
-export declare class TableComponent<T extends RowBase = RowBase> {
+export declare class TableComponent<T extends RowBase = RowBase> implements AfterViewInit, OnDestroy {
+    private static allocateTableInstanceId;
+    private readonly elementRef;
+    private resizeObserver?;
+    private _tableInstanceId;
     private actionsMenuIdSequence;
+    private get tableInstanceId();
     private readonly colsSignal;
     private readonly dataSignal;
     private readonly loadingSignal;
@@ -39,7 +44,12 @@ export declare class TableComponent<T extends RowBase = RowBase> {
     lazyLoad: EventEmitter<{
         first: number;
         rows: number;
+        sortField?: string | null;
+        sortOrder?: SortOrder;
+        trigger?: "page" | "sort" | "search";
+        searchTerm?: string;
     }>;
+    selectionChange: EventEmitter<T[]>;
     get isLoading(): boolean;
     protected readonly options: import("@angular/core").Signal<TableOptions<T>>;
     protected readonly isMobile: import("@angular/core").Signal<boolean>;
@@ -51,6 +61,13 @@ export declare class TableComponent<T extends RowBase = RowBase> {
     protected readonly triggerMode: import("@angular/core").Signal<SearchTriggerMode>;
     protected readonly totalRecordsLabel: import("@angular/core").Signal<string>;
     protected readonly defaultTextOverflow: import("@angular/core").Signal<import("../../core/types/table-column.type").TableTextOverflow | undefined>;
+    protected readonly tableMode: import("@angular/core").Signal<"local" | "api">;
+    protected readonly isApiMode: import("@angular/core").Signal<boolean>;
+    protected readonly isFitLayout: import("@angular/core").Signal<boolean>;
+    protected readonly mobileMode: import("@angular/core").Signal<"expandable" | "stacked">;
+    protected readonly expandedRowIndex: import("@angular/core").WritableSignal<number | null>;
+    protected readonly summaryCols: import("@angular/core").Signal<TableColumn<T>[]>;
+    protected readonly checkboxCol: import("@angular/core").Signal<TableColumn<T> | null>;
     protected readonly emptyTitle: import("@angular/core").Signal<string>;
     protected readonly emptyText: import("@angular/core").Signal<string>;
     protected readonly cellsCfg: import("@angular/core").Signal<import("../../core/types/table-options.type").TableCellConfigMap<T>>;
@@ -66,24 +83,35 @@ export declare class TableComponent<T extends RowBase = RowBase> {
     protected readonly resolveValue: (obj: T, path?: string) => unknown;
     protected onDocumentClick(): void;
     protected onEscapeKey(): void;
-    protected onWindowResize(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
     protected onWindowScroll(): void;
     protected onSearchTerm(eventOrValue: TableSearchEvent): void;
     protected onClearSearch(): void;
     protected toggleSort(field: string, enabled?: boolean): void;
     protected getSortAriaAttribute(col: TableColumn<T>): string | undefined;
-    protected columnAlignClass(col: TableColumn<T>): string | null;
+    protected columnAlignClass(col: TableColumn<T>, target?: 'cell' | 'header'): string;
     protected isSortableColumn(col: TableColumn<T>): boolean;
+    protected hasDataRows(): boolean;
+    protected canSortColumn(col: TableColumn<T>): boolean;
     protected columnMinWidthPx(col: TableColumn<T>): number;
+    protected colWidthStyle(col: TableColumn<T>): string | undefined;
     protected mobileFieldLabel(col: TableColumn<T>): string;
+    protected toggleExpandRow(index: number): void;
+    protected isRowExpanded(index: number): boolean;
     protected onPageChange(event: PaginatorState): void;
     protected onToggleRow(row: T, checked: boolean): void;
     protected isRowSelected(row: T): boolean;
+    protected isRowSelectionDisabled(row: T): boolean;
     protected toggleSelectPage(checked: boolean): void;
     protected isPageFullySelected(): boolean;
+    protected isPagePartiallySelected(): boolean;
+    protected hasSelectablePageRows(): boolean;
+    protected getPageSelectionAriaChecked(): 'false' | 'mixed' | 'true';
     protected getCheckedValue(event: Event): boolean;
     protected getRowCheckboxId(row: T): string;
     protected getRowCheckboxLabel(row: T): string;
+    protected getSelectAllCheckboxId(columnIndex: number): string;
     protected tableAriaLabelKey(): string;
     protected toggleActionsMenu(event: Event, row: T, col: TableColumn<T>, triggerElement: HTMLElement): void;
     protected closeActionsMenu(focusTarget?: TableMenuFocusTarget): void;
@@ -100,11 +128,18 @@ export declare class TableComponent<T extends RowBase = RowBase> {
     protected onButtonClick(row: T, col: TableColumn<T>): void;
     protected resolveCellId(col: TableColumn<T>, row: T): string | null;
     private cellCfg;
+    private emitLazyLoad;
     private clampPage;
     private reconcileSelectionWithData;
     private resolveActionDisabled;
+    private selectablePageRows;
+    private updateSelection;
+    private normalizeSelection;
+    private getSelectionKey;
+    private hasSameSelection;
+    private toComparableText;
     private nextActionsMenuId;
     private focusClosedMenuTarget;
     static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "sdc-table", never, { "cols": { "alias": "cols"; "required": true; }; "data": { "alias": "data"; "required": true; }; "loading": { "alias": "loading"; "required": false; }; "config": { "alias": "config"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "action": "action"; "lazyLoad": "lazyLoad"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent<any>, "sdc-table", never, { "cols": { "alias": "cols"; "required": true; }; "data": { "alias": "data"; "required": true; }; "loading": { "alias": "loading"; "required": false; }; "config": { "alias": "config"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "action": "action"; "lazyLoad": "lazyLoad"; "selectionChange": "selectionChange"; }, never, never, true, never>;
 }

package/features/table/utils/table-data.util.d.ts

@@ -6,5 +6,6 @@ export declare function formatTableDate(value: unknown): string;
 export declare function formatTableCurrency(value: unknown, currency?: string): string;
 export declare function toTableTextValue(value: unknown): string;
 export declare function resolveRowIdentityLabel(rowIdentity: TableRowIdentity): string;
+export declare function resolveRowSelectionKey<T extends RowBase = RowBase>(row: T): string;
 export declare function buildRowCheckboxId<T extends RowBase = RowBase>(row: T): string;
 export declare function filterTableRows<T extends RowBase = RowBase>(data: T[], cols: TableColumn<T>[], query: string, resolveValue: (row: T, field?: string) => unknown): T[];

package/features/table/utils/table-layout.util.d.ts

@@ -1,4 +1,5 @@
 import type { RowBase, TableColumn, TableColumnAlignment } from '../../../core/types/table.type';
 export declare function normalizeTableColumnAlignment(value: unknown): TableColumnAlignment | null;
+export declare function resolveTableColumnAlignment<T extends RowBase = RowBase>(column: TableColumn<T> | null | undefined, target?: 'cell' | 'header'): TableColumnAlignment;
 export declare function getTableColumnMinWidthPx<T extends RowBase = RowBase>(column: TableColumn<T>): number;
 export declare function getTableMinWidthPx<T extends RowBase = RowBase>(columns: TableColumn<T>[]): number;

package/features/tiered-menu/components/tiered-menu/tiered-menu.component.d.ts

@@ -0,0 +1,49 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import type { TieredMenuItemInternalData, TieredMenuTriggerEvent } from '../../../../core/types/tiered-menu.type';
+import { TieredMenuService } from '../../services/tiered-menu.service';
+import * as i0 from "@angular/core";
+export declare class TieredMenuComponent implements OnInit, OnDestroy {
+    private readonly appRef;
+    private readonly injector;
+    private readonly cdr;
+    readonly tieredMenuService: TieredMenuService;
+    private readonly eventService;
+    ariaLabel?: string;
+    items: TieredMenuItemInternalData[];
+    top: number;
+    left: number;
+    menuTriggerEvent: TieredMenuTriggerEvent;
+    isSubmenu: boolean;
+    private componentRef;
+    private menuElement;
+    private readonly unsubscribe$;
+    protected onResize(): void;
+    protected onDocumentClick(event: MouseEvent): void;
+    protected onKeydownHandler(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private focusCurrentItem;
+    private incrementCurrentItem;
+    private decrementCurrentItem;
+    private createMenu;
+    private destroy;
+    private setMenuPosition;
+    private countMenuItems;
+    private setMenuHorizontalPosition;
+    private setMenuVerticalPosition;
+    private hasSpaceOnRight;
+    private hasSpaceAtBottom;
+    private subscribeEvents;
+    private closeCurrentItemAncestors;
+    private openItemSubmenu;
+    private getCurrentNavigableItem;
+    private getKeydownAction;
+    private resetCurrentItems;
+    private closeAllMenus;
+    private selectCurrentItem;
+    private moveCurrentItem;
+    private closeCurrentItemMenu;
+    private openCurrentItemMenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TieredMenuComponent, "sdc-tiered-menu", never, {}, {}, never, never, true, never>;
+}

package/features/tiered-menu/components/tiered-menu-divider/tiered-menu-divider.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class TieredMenuDividerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TieredMenuDividerComponent, "sdc-tiered-menu-divider", never, {}, {}, never, never, true, never>;
+}

package/features/tiered-menu/components/tiered-menu-item/tiered-menu-item.component.d.ts

@@ -0,0 +1,19 @@
+import { OnDestroy } from '@angular/core';
+import type { TieredMenuItemInternalData, TieredMenuTriggerEvent } from '../../../../core/types/tiered-menu.type';
+import * as i0 from "@angular/core";
+export declare class TieredMenuItemComponent implements OnDestroy {
+    private readonly eventService;
+    item: TieredMenuItemInternalData;
+    focused: boolean;
+    highlight: boolean;
+    triggerEvent: TieredMenuTriggerEvent;
+    closeOnClick: boolean;
+    private showTimeoutId?;
+    ngOnDestroy(): void;
+    protected onClick(): void;
+    protected onTouchEnd(event: TouchEvent): void;
+    protected onMouseEnter(): void;
+    protected onMouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TieredMenuItemComponent, "sdc-tiered-menu-item", never, { "item": { "alias": "item"; "required": true; }; "focused": { "alias": "focused"; "required": false; }; "highlight": { "alias": "highlight"; "required": false; }; "triggerEvent": { "alias": "triggerEvent"; "required": false; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/tiered-menu/components/tiered-menu-nested/tiered-menu-nested.component.d.ts

@@ -0,0 +1,26 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import type { TieredMenuItemInternalData } from '../../../../core/types/tiered-menu.type';
+import { TieredMenuService } from '../../services/tiered-menu.service';
+import * as i0 from "@angular/core";
+export declare class TieredMenuNestedComponent implements OnInit, OnDestroy {
+    readonly tieredMenuService: TieredMenuService;
+    private readonly eventService;
+    ariaLabel?: string;
+    items: TieredMenuItemInternalData[];
+    top: number;
+    left: number;
+    private lastOpenItem?;
+    private readonly unsubscribe$;
+    protected onResize(): void;
+    protected onDocumentClick(event: MouseEvent): void;
+    protected onKeydownHandler(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private incrementCurrentItem;
+    private decrementCurrentItem;
+    private closeItem;
+    private openItem;
+    private subscribeEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuNestedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TieredMenuNestedComponent, "sdc-tiered-menu-nested", never, {}, {}, never, never, true, never>;
+}

package/features/tiered-menu/directives/tiered-menu.directive.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import type { TieredMenuItemData, TieredMenuTriggerEvent } from '../../../core/types/tiered-menu.type';
+import * as i0 from "@angular/core";
+export declare class TieredMenuDirective implements OnInit, OnChanges, OnDestroy {
+    private readonly elementRef;
+    private readonly appRef;
+    private readonly injector;
+    private readonly eventService;
+    private readonly tieredMenuService;
+    private readonly globalService;
+    private readonly cdr;
+    items: TieredMenuItemData[];
+    focusedItem?: TieredMenuItemData;
+    triggerEvent: TieredMenuTriggerEvent;
+    ariaLabel?: string;
+    tieredMenuOpened: EventEmitter<void>;
+    tieredMenuClosed: EventEmitter<void>;
+    set dataCoreItems(value: TieredMenuItemData[] | null | undefined);
+    set legacyItems(value: TieredMenuItemData[] | null | undefined);
+    private setItems;
+    private componentRef;
+    private isNested;
+    private isOpen;
+    private readonly unsubscribe$;
+    private lastActiveElement?;
+    private itemsAreValid;
+    private readonly resizeObserver;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    protected onClick(event: MouseEvent): void;
+    protected onMouseEnter(): void;
+    private createMenu;
+    private createTieredMenu;
+    private createNestedMenu;
+    destroy(): void;
+    private setMenuPosition;
+    private setMenuComponentProperties;
+    private subscribeEvents;
+    private rebuildMenu;
+    private updateServiceItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TieredMenuDirective, "[sdcTieredMenu],[sTieredMenu]", never, { "items": { "alias": "items"; "required": false; }; "focusedItem": { "alias": "focusedItem"; "required": false; }; "triggerEvent": { "alias": "triggerEvent"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "dataCoreItems": { "alias": "sdcTieredMenu"; "required": false; }; "legacyItems": { "alias": "sTieredMenu"; "required": false; }; }, { "tieredMenuOpened": "tieredMenuOpened"; "tieredMenuClosed": "tieredMenuClosed"; }, never, never, true, never>;
+}

package/features/tiered-menu/services/tiered-menu.event.service.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '@angular/core';
+import type { TieredMenuItemInternalData } from '../../../core/types/tiered-menu.type';
+import * as i0 from "@angular/core";
+export declare class TieredMenuEventService {
+    incrementCurrentItemEvent: EventEmitter<void>;
+    decrementCurrentItemEvent: EventEmitter<void>;
+    closeAllMenusEvent: EventEmitter<void>;
+    selectItemEvent: EventEmitter<TieredMenuItemInternalData | null>;
+    openItemMenuEvent: EventEmitter<TieredMenuItemInternalData | null>;
+    closeItemMenuEvent: EventEmitter<TieredMenuItemInternalData | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TieredMenuEventService>;
+}

package/features/tiered-menu/services/tiered-menu.global.service.d.ts

@@ -0,0 +1,7 @@
+import type { TieredMenuDirective } from '../directives/tiered-menu.directive';
+import * as i0 from "@angular/core";
+export declare class TieredMenuGlobalService {
+    lastInstance: TieredMenuDirective | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuGlobalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TieredMenuGlobalService>;
+}

package/features/tiered-menu/services/tiered-menu.service.d.ts

@@ -0,0 +1,14 @@
+import type { TieredMenuItemData, TieredMenuItemInternalData } from '../../../core/types/tiered-menu.type';
+import * as i0 from "@angular/core";
+export declare class TieredMenuService {
+    currentItem: TieredMenuItemInternalData | null;
+    currentItems: TieredMenuItemInternalData[];
+    items: TieredMenuItemInternalData[];
+    private idCounter;
+    normalizeData(items: TieredMenuItemData[], parent?: TieredMenuItemInternalData): TieredMenuItemInternalData[];
+    markAllItemsAsClosed(items: TieredMenuItemInternalData[]): TieredMenuItemInternalData[];
+    searchTheHierarchy(itemA: TieredMenuItemInternalData, itemB: TieredMenuItemInternalData): boolean;
+    private generateId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TieredMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TieredMenuService>;
+}