@semantic-components/ui-lab 0.79.0 → 0.81.0

package/types/semantic-components-ui-lab.d.ts

@@ -1,18 +1,19 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, TemplateRef, Type, ElementRef, model, output, DoCheck } from '@angular/core';
+import { InjectionToken, TemplateRef, Type, Signal, WritableSignal, ElementRef, model, output, DoCheck } from '@angular/core';
 import * as _semantic_components_ui_lab from '@semantic-components/ui-lab';
 import { Temporal } from '@js-temporal/polyfill';
 import * as _semantic_components_ui from '@semantic-components/ui';
-import { ScDateRange } from '@semantic-components/ui';
+import { ScDateRange, ScCalendarValue, ScPopoverProvider } from '@semantic-components/ui';
 export { ScDateRange } from '@semantic-components/ui';
-import * as i1 from '@angular/aria/listbox';
+import * as i1 from '@angular/cdk/overlay';
+import { CdkOverlayOrigin, ScrollStrategy, ConnectedPosition } from '@angular/cdk/overlay';
+import * as i1$1 from '@angular/aria/listbox';
 import { ScCarousel } from '@semantic-components/carousel';
-import * as i1$1 from '@angular/aria/toolbar';
+import * as i1$2 from '@angular/aria/toolbar';
 import { Toolbar } from '@angular/aria/toolbar';
-import * as _angular_cdk_overlay from '@angular/cdk/overlay';
-import { CdkOverlayOrigin } from '@angular/cdk/overlay';
-import { SafeResourceUrl } from '@angular/platform-browser';
-import * as i1$2 from '@angular/aria/tree';
+import * as pdfjs_dist_types_src_display_api from 'pdfjs-dist/types/src/display/api';
+import * as uqr from 'uqr';
+import * as i1$3 from '@angular/aria/tree';
 import { Tree, TreeItem } from '@angular/aria/tree';
 
 declare class ScStackedLayout {
@@ -36,44 +37,6 @@ declare class AuthLayout {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AuthLayout, "sc-auth-layout", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type AnimatedCounterEasing = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut';
-interface AnimatedCounterOptions {
-    duration?: number;
-    easing?: AnimatedCounterEasing;
-    decimalPlaces?: number;
-    separator?: string;
-    prefix?: string;
-    suffix?: string;
-}
-declare const DEFAULT_COUNTER_OPTIONS: Required<AnimatedCounterOptions>;
-
-declare class ScAnimatedCounter {
-    private readonly destroyRef;
-    readonly classInput: _angular_core.InputSignal<string>;
-    readonly value: _angular_core.InputSignal<number>;
-    readonly duration: _angular_core.InputSignal<number>;
-    readonly easing: _angular_core.InputSignal<AnimatedCounterEasing>;
-    readonly decimalPlaces: _angular_core.InputSignal<number>;
-    readonly separator: _angular_core.InputSignal<string>;
-    readonly prefix: _angular_core.InputSignal<string>;
-    readonly suffix: _angular_core.InputSignal<string>;
-    readonly animationComplete: _angular_core.OutputEmitterRef<number>;
-    private readonly currentValue;
-    private animationId;
-    private previousValue;
-    protected readonly displayValue: _angular_core.Signal<string>;
-    protected readonly ariaLabel: _angular_core.Signal<string>;
-    protected readonly class: _angular_core.Signal<string>;
-    constructor();
-    private animateToValue;
-    private cancelAnimation;
-    private getEasingFunction;
-    private formatNumber;
-    reset(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAnimatedCounter, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAnimatedCounter, "span[scAnimatedCounter]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "easing": { "alias": "easing"; "required": false; "isSignal": true; }; "decimalPlaces": { "alias": "decimalPlaces"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; }, { "animationComplete": "animationComplete"; }, never, never, true, never>;
-}
-
 interface ScAudioTrack {
     src: string;
     title?: string;
@@ -361,52 +324,94 @@ interface HSL {
     s: number;
     l: number;
 }
+interface OKLCH {
+    l: number;
+    c: number;
+    h: number;
+}
+
 declare const SC_COLOR_PICKER: InjectionToken<ScColorPicker>;
 declare class ScColorPicker {
     readonly classInput: _angular_core.InputSignal<string>;
     readonly value: _angular_core.ModelSignal<string>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     private readonly _hsv;
+    private _lastInternalHex;
     protected readonly class: _angular_core.Signal<string>;
     readonly hsv: _angular_core.Signal<HSV>;
     readonly rgb: _angular_core.Signal<RGB>;
     readonly hsl: _angular_core.Signal<HSL>;
     readonly hex: _angular_core.Signal<string>;
+    readonly oklch: _angular_core.Signal<OKLCH>;
     constructor();
     setHsv(hsv: Partial<HSV>): void;
     setRgb(rgb: Partial<RGB>): void;
     setHex(hex: string): void;
+    setOklch(oklch: OKLCH): void;
     setHue(h: number): void;
     setSaturation(s: number): void;
     setValue(v: number): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPicker, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPicker, "[scColorPicker]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPicker, "[scColorPicker]", ["scColorPicker"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
 declare class ScColorPickerArea {
-    readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
+    protected readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
     private readonly elementRef;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
+    protected readonly background: _angular_core.Signal<string>;
+    protected readonly valueText: _angular_core.Signal<string>;
+    private updateColor;
     onMouseDown(event: MouseEvent): void;
     onTouchStart(event: TouchEvent): void;
-    private updateFromEvent;
-    private updateFromTouch;
+    onKeyDown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerArea, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScColorPickerArea, "[scColorPickerArea]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerArea, "div[scColorPickerArea]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScColorPickerAreaSaturation {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerAreaSaturation, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerAreaSaturation, "div[scColorPickerAreaSaturation]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScColorPickerAreaBrightness {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerAreaBrightness, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerAreaBrightness, "div[scColorPickerAreaBrightness]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScColorPickerAreaCursor {
+    protected readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerAreaCursor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerAreaCursor, "div[scColorPickerAreaCursor]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScColorPickerHue {
-    readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
+    protected readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
     private readonly elementRef;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
+    protected readonly valueText: _angular_core.Signal<string>;
+    private updateHue;
     onMouseDown(event: MouseEvent): void;
     onTouchStart(event: TouchEvent): void;
-    private updateFromEvent;
-    private updateFromTouch;
+    onKeyDown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerHue, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScColorPickerHue, "[scColorPickerHue]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerHue, "div[scColorPickerHue]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScColorPickerHueCursor {
+    protected readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerHueCursor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerHueCursor, "div[scColorPickerHueCursor]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScColorPickerPreview {
@@ -420,30 +425,42 @@ declare class ScColorPickerPreview {
 declare class ScColorPickerInput {
     readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
     readonly classInput: _angular_core.InputSignal<string>;
-    readonly format: _angular_core.InputSignal<"hex" | "rgb" | "hsl">;
+    readonly ariaLabelInput: _angular_core.InputSignal<string>;
+    readonly format: _angular_core.InputSignal<"hex" | "rgb" | "hsl" | "oklch">;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
     protected readonly class: _angular_core.Signal<string>;
     protected readonly displayValue: _angular_core.Signal<string>;
     onInput(event: Event): void;
-    onBlur(): void;
+    onBlur(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerInput, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScColorPickerInput, "input[scColorPickerInput]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerInput, "input[scColorPickerInput]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScColorPickerSwatches {
-    readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
     readonly classInput: _angular_core.InputSignal<string>;
     readonly colors: _angular_core.InputSignal<string[]>;
     protected readonly class: _angular_core.Signal<string>;
-    selectColor(color: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerSwatches, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScColorPickerSwatches, "[scColorPickerSwatches]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerSwatches, "[scColorPickerSwatches]", ["scColorPickerSwatches"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScColorPickerSwatch {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly ariaLabelInput: _angular_core.InputSignal<string>;
+    private readonly colorPicker;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
+    protected selectColor(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerSwatch, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerSwatch, "button[scColorPickerSwatch]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": true; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScColorPickerEyeDropper {
     readonly colorPicker: _semantic_components_ui_lab.ScColorPicker;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
-    isSupported(): boolean;
+    readonly isSupported: boolean;
     pickColor(): Promise<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScColorPickerEyeDropper, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScColorPickerEyeDropper, "button[scColorPickerEyedropper]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -614,40 +631,59 @@ interface ScDateRangePreset {
 declare class ScDateRangePicker {
     readonly classInput: _angular_core.InputSignal<string>;
     readonly placeholder: _angular_core.InputSignal<string>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly minDate: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
-    readonly maxDate: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
-    readonly disabledDates: _angular_core.InputSignal<Temporal.PlainDate[]>;
-    readonly presets: _angular_core.InputSignal<ScDateRangePreset[]>;
-    readonly showTwoMonths: _angular_core.InputSignal<boolean>;
-    readonly showClear: _angular_core.InputSignal<boolean>;
     readonly dateFormat: _angular_core.InputSignal<string>;
     readonly value: _angular_core.ModelSignal<ScDateRange>;
-    readonly valueChange: _angular_core.OutputEmitterRef<ScDateRange>;
     readonly apply: _angular_core.OutputEmitterRef<ScDateRange>;
-    protected readonly dropdownOpen: _angular_core.WritableSignal<boolean>;
-    private readonly triggerEl;
-    private pendingValue;
-    protected readonly displayValue: _angular_core.Signal<string>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly triggerClass: _angular_core.Signal<string>;
-    protected readonly dropdownClass: _angular_core.Signal<string>;
-    protected presetClass(preset: ScDateRangePreset): string;
-    private isPresetActive;
-    toggleDropdown(): void;
-    openDropdown(): void;
-    closeDropdown(): void;
-    selectPreset(preset: ScDateRangePreset): void;
-    applySelection(): void;
-    clearSelection(event: Event): void;
+    private readonly popoverProvider;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly pendingValue;
+    readonly displayText: _angular_core.Signal<string>;
+    constructor();
     formatDate(date: Temporal.PlainDate): string;
-    focus(): void;
-    getRange(): ScDateRange;
+    onValueChange(newValue: ScCalendarValue): void;
+    onCancel(): void;
+    onApply(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDateRangePicker, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDateRangePicker, "sc-date-range-picker", ["scScDateRangePicker"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "showTwoMonths": { "alias": "showTwoMonths"; "required": false; "isSignal": true; }; "showClear": { "alias": "showClear"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "apply": "apply"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDateRangePicker, "div[scDateRangePicker]", ["scDateRangePicker"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "dateFormat": { "alias": "dateFormat"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "apply": "apply"; }, ["popoverProvider"], never, true, never>;
 }
 declare function createScDateRangePresets(): ScDateRangePreset[];
 
+declare class ScDateRangePickerTrigger {
+    readonly popover: ScPopoverProvider;
+    readonly overlayOrigin: CdkOverlayOrigin;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    togglePopover(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDateRangePickerTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDateRangePickerTrigger, "button[scDateRangePickerTrigger]", ["scDateRangePickerTrigger"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScDateRangePickerPresets {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDateRangePickerPresets, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDateRangePickerPresets, "div[scDateRangePickerPresets]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDateRangePickerPreset {
+    private readonly picker;
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<ScDateRange>;
+    private readonly isActive;
+    protected readonly class: _angular_core.Signal<string>;
+    protected selectPreset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDateRangePickerPreset, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDateRangePickerPreset, "button[scDateRangePickerPreset]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDateRangePickerFooter {
+    readonly picker: ScDateRangePicker;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDateRangePickerFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDateRangePickerFooter, "div[scDateRangePickerFooter]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 type DiffLineType = 'added' | 'removed' | 'unchanged' | 'modified';
 interface DiffLine {
     type: DiffLineType;
@@ -696,31 +732,123 @@ declare function computeWordDiff(oldLine: string, newLine: string): {
 
 type DiffViewMode = 'split' | 'unified';
 
+declare const SC_DIFF_VIEWER: InjectionToken<ScDiffViewer>;
 declare class ScDiffViewer {
+    readonly classInput: _angular_core.InputSignal<string>;
     readonly oldText: _angular_core.InputSignal<string>;
     readonly newText: _angular_core.InputSignal<string>;
     readonly oldTitle: _angular_core.InputSignal<string>;
     readonly newTitle: _angular_core.InputSignal<string>;
     readonly defaultViewMode: _angular_core.InputSignal<DiffViewMode>;
-    readonly showHeader: _angular_core.InputSignal<boolean>;
-    readonly showFooter: _angular_core.InputSignal<boolean>;
-    readonly showViewModeToggle: _angular_core.InputSignal<boolean>;
-    readonly showSideHeaders: _angular_core.InputSignal<boolean>;
     readonly showWordDiff: _angular_core.InputSignal<boolean>;
     readonly ignoreWhitespace: _angular_core.InputSignal<boolean>;
     readonly ignoreCase: _angular_core.InputSignal<boolean>;
-    readonly maxHeight: _angular_core.InputSignal<string>;
-    readonly class: _angular_core.InputSignal<string>;
     readonly viewMode: _angular_core.WritableSignal<DiffViewMode>;
     constructor();
-    protected readonly diffResult: _angular_core.Signal<DiffResult>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected viewModeButtonClass(active: boolean): string;
-    protected getLineClass(type: string, side: 'old' | 'new' | 'unified'): string;
-    protected highlightLine(line: DiffLine, side: 'old' | 'new'): string;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly diffResult: _angular_core.Signal<DiffResult>;
+    getLineClass(type: string): string;
+    highlightLine(line: DiffLine, side: 'old' | 'new'): string;
     private escapeHtml;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDiffViewer, "sc-diff-viewer", never, { "oldText": { "alias": "oldText"; "required": false; "isSignal": true; }; "newText": { "alias": "newText"; "required": false; "isSignal": true; }; "oldTitle": { "alias": "oldTitle"; "required": false; "isSignal": true; }; "newTitle": { "alias": "newTitle"; "required": false; "isSignal": true; }; "defaultViewMode": { "alias": "defaultViewMode"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "showFooter": { "alias": "showFooter"; "required": false; "isSignal": true; }; "showViewModeToggle": { "alias": "showViewModeToggle"; "required": false; "isSignal": true; }; "showSideHeaders": { "alias": "showSideHeaders"; "required": false; "isSignal": true; }; "showWordDiff": { "alias": "showWordDiff"; "required": false; "isSignal": true; }; "ignoreWhitespace": { "alias": "ignoreWhitespace"; "required": false; "isSignal": true; }; "ignoreCase": { "alias": "ignoreCase"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewer, "[scDiffViewer]", ["scDiffViewer"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "oldText": { "alias": "oldText"; "required": false; "isSignal": true; }; "newText": { "alias": "newText"; "required": false; "isSignal": true; }; "oldTitle": { "alias": "oldTitle"; "required": false; "isSignal": true; }; "newTitle": { "alias": "newTitle"; "required": false; "isSignal": true; }; "defaultViewMode": { "alias": "defaultViewMode"; "required": false; "isSignal": true; }; "showWordDiff": { "alias": "showWordDiff"; "required": false; "isSignal": true; }; "ignoreWhitespace": { "alias": "ignoreWhitespace"; "required": false; "isSignal": true; }; "ignoreCase": { "alias": "ignoreCase"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerHeader {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerHeader, "div[scDiffViewerHeader]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerModeSwitch {
+    private readonly diffViewer;
+    private readonly toolbar;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerModeSwitch, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerModeSwitch, "div[scDiffViewerModeSwitch]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly maxHeight: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerContent, "div[scDiffViewerContent]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerSplit {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerSplit, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerSplit, "div[scDiffViewerSplit]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerPane {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly side: _angular_core.InputSignal<"old" | "new">;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerPane, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerPane, "div[scDiffViewerPane]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerPaneHeader {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly variant: _angular_core.InputSignal<"old" | "new">;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerPaneHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerPaneHeader, "div[scDiffViewerPaneHeader]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerLine {
+    private readonly diffViewer;
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly type: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerLine, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerLine, "div[scDiffViewerLine]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerLineNumber {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerLineNumber, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerLineNumber, "span[scDiffViewerLineNumber]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerLineSign {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerLineSign, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerLineSign, "span[scDiffViewerLineSign]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerLineContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerLineContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerLineContent, "span[scDiffViewerLineContent]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerLinePlaceholder {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerLinePlaceholder, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerLinePlaceholder, "div[scDiffViewerLinePlaceholder]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerFooter {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerFooter, "div[scDiffViewerFooter]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScDiffViewerEmpty {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDiffViewerEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDiffViewerEmpty, "div[scDiffViewerEmpty]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface DockItem {
@@ -779,14 +907,14 @@ declare class ScDockItem {
     protected onClick(): void;
     protected onMouseEnter(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDockItem, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDockItem, "button[scDockItem]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDockItem, "button[scDockItem]", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScDockBadge {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDockBadge, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDockBadge, "span[scDockBadge]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScDockBadge, "span[scDockBadge]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface Emoji {
@@ -831,30 +959,35 @@ declare class ScEmojiPicker {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScEmojiPicker, "div[scEmojiPicker]", ["scEmojiPicker"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "categories": { "alias": "categories"; "required": false; "isSignal": true; }; "maxRecent": { "alias": "maxRecent"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "emojiSelect": "emojiSelect"; }, never, never, true, never>;
 }
 
-declare class ScEmojiPickerCategoryTabs {
+declare class ScEmojiPickerCategoryTab {
     readonly state: ScEmojiPickerState;
+    readonly category: _angular_core.InputSignal<EmojiCategory>;
     readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly isActive: _angular_core.Signal<boolean>;
     protected readonly class: _angular_core.Signal<string>;
-    protected categoryTabClass(isActive: boolean): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScEmojiPickerCategoryTabs, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScEmojiPickerCategoryTabs, "div[scEmojiPickerCategoryTabs]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScEmojiPickerCategoryTab, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScEmojiPickerCategoryTab, "button[scEmojiPickerCategoryTab]", never, { "category": { "alias": "category"; "required": true; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare const DEFAULT_CATEGORIES: EmojiCategory[];
-
-declare class ScEmojiPickerEmpty {
+declare class ScEmojiPickerCategoryTabs {
+    readonly state: ScEmojiPickerState;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScEmojiPickerEmpty, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScEmojiPickerEmpty, "[scEmojiPickerEmpty]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScEmojiPickerCategoryTabs, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScEmojiPickerCategoryTabs, "div[scEmojiPickerCategoryTabs]", ["scEmojiPickerCategoryTabs"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+declare const DEFAULT_CATEGORIES: EmojiCategory[];
+
 declare class ScEmojiPickerGrid {
     readonly state: ScEmojiPickerState;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
+    readonly emojis: _angular_core.Signal<Emoji[]>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    readonly rows: _angular_core.Signal<Emoji[][]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScEmojiPickerGrid, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScEmojiPickerGrid, "div[scEmojiPickerGrid]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["[scEmojiPickerEmpty]"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScEmojiPickerGrid, "div[scEmojiPickerGrid]", ["scEmojiPickerGrid"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScEmojiPickerItem {
@@ -870,8 +1003,9 @@ declare class ScEmojiPickerRecent {
     readonly state: ScEmojiPickerState;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
+    readonly visible: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScEmojiPickerRecent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScEmojiPickerRecent, "div[scEmojiPickerRecent]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScEmojiPickerRecent, "div[scEmojiPickerRecent]", ["scEmojiPickerRecent"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScEmojiPickerSearch {
@@ -885,9 +1019,11 @@ declare class ScEmojiPickerSearch {
 
 declare class ScEmojiPickerTrigger {
     readonly classInput: _angular_core.InputSignal<string>;
+    readonly ariaLabelInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScEmojiPickerTrigger, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScEmojiPickerTrigger, "button[scEmojiPickerTrigger]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScEmojiPickerTrigger, "button[scEmojiPickerTrigger]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type AnnotationTool = 'pen' | 'line' | 'rectangle' | 'circle' | 'arrow' | 'text' | 'eraser';
@@ -911,41 +1047,79 @@ interface ImageAnnotatorState {
 }
 
 declare class ScImageAnnotator {
-    readonly imageCanvasRef: _angular_core.Signal<ElementRef<HTMLCanvasElement> | undefined>;
-    readonly annotationCanvasRef: _angular_core.Signal<ElementRef<HTMLCanvasElement> | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
     readonly src: _angular_core.InputSignal<string>;
     readonly width: _angular_core.InputSignal<number>;
     readonly height: _angular_core.InputSignal<number>;
-    readonly class: _angular_core.InputSignal<string>;
     readonly annotationsChange: _angular_core.OutputEmitterRef<Annotation[]>;
     readonly save: _angular_core.OutputEmitterRef<string>;
-    protected readonly annotations: _angular_core.WritableSignal<Annotation[]>;
-    protected readonly currentTool: _angular_core.WritableSignal<AnnotationTool>;
-    protected readonly currentColor: _angular_core.WritableSignal<string>;
-    protected readonly lineWidth: _angular_core.WritableSignal<number>;
-    protected readonly imageLoaded: _angular_core.WritableSignal<boolean>;
-    private isDrawing;
-    private currentAnnotation;
-    private startPoint;
+    private readonly state;
+    protected readonly class: _angular_core.Signal<string>;
+    constructor();
+    getAnnotations(): Annotation[];
+    setAnnotations(annotations: Annotation[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScImageAnnotator, "div[scImageAnnotator]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "annotationsChange": "annotationsChange"; "save": "save"; }, never, never, true, never>;
+}
+
+declare class ScImageAnnotatorAction {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly action: _angular_core.InputSignal<"undo" | "clear" | "download">;
+    private readonly state;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotatorAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScImageAnnotatorAction, "button[scImageAnnotatorAction]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScImageAnnotatorState {
+    src: Signal<string>;
+    width: Signal<number>;
+    height: Signal<number>;
+    onAnnotationsChange: ((annotations: Annotation[]) => void) | undefined;
+    onSave: ((dataUrl: string) => void) | undefined;
+    onRedraw: (() => void) | undefined;
+    onDownload: (() => void) | undefined;
+    readonly annotations: _angular_core.WritableSignal<Annotation[]>;
+    readonly currentTool: _angular_core.WritableSignal<AnnotationTool>;
+    readonly currentColor: _angular_core.WritableSignal<string>;
+    readonly lineWidth: _angular_core.WritableSignal<number>;
+    readonly imageLoaded: _angular_core.WritableSignal<boolean>;
+    readonly cursor: Signal<"cell" | "crosshair">;
     readonly tools: {
         id: AnnotationTool;
         label: string;
     }[];
     readonly colors: string[];
-    protected readonly canvasWidth: _angular_core.Signal<number>;
-    protected readonly canvasHeight: _angular_core.Signal<number>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    constructor();
-    private loadImage;
-    protected toolButtonClass(tool: AnnotationTool): string;
     selectTool(tool: AnnotationTool): void;
     selectColor(color: string): void;
-    onLineWidthChange(event: Event): void;
-    getCursor(): string;
-    onMouseDown(event: MouseEvent): void;
-    onMouseMove(event: MouseEvent): void;
-    onMouseUp(event: MouseEvent): void;
-    private eraseAt;
+    setLineWidth(width: number): void;
+    addAnnotation(annotation: Annotation): void;
+    eraseAt(x: number, y: number): void;
+    undo(): void;
+    clearAll(): void;
+    download(): void;
+    getAnnotations(): Annotation[];
+    setAnnotations(annotations: Annotation[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotatorState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScImageAnnotatorState>;
+}
+
+declare class ScImageAnnotatorCanvas {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScImageAnnotatorState;
+    private readonly imageCanvasRef;
+    private readonly annotationCanvasRef;
+    private isDrawing;
+    private currentAnnotation;
+    private startPoint;
+    protected readonly class: _angular_core.Signal<string>;
+    constructor();
+    private loadImage;
+    protected onMouseDown(event: MouseEvent): void;
+    protected onMouseMove(event: MouseEvent): void;
+    protected onMouseUp(): void;
     private redrawAnnotations;
     private drawAnnotation;
     private drawPen;
@@ -953,18 +1127,60 @@ declare class ScImageAnnotator {
     private drawRectangle;
     private drawCircle;
     private drawArrow;
-    undo(): void;
-    clearAll(): void;
-    download(): void;
-    getAnnotations(): Annotation[];
-    setAnnotations(annotations: Annotation[]): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotator, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScImageAnnotator, "sc-image-annotator", never, { "src": { "alias": "src"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "annotationsChange": "annotationsChange"; "save": "save"; }, never, never, true, never>;
+    private performDownload;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotatorCanvas, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScImageAnnotatorCanvas, "div[scImageAnnotatorCanvas]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScImageAnnotatorColorButton {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<string>;
+    private readonly state;
+    protected readonly isActive: _angular_core.Signal<boolean>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotatorColorButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScImageAnnotatorColorButton, "button[scImageAnnotatorColorButton]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScImageAnnotatorLineWidth {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScImageAnnotatorState;
+    protected readonly class: _angular_core.Signal<string>;
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotatorLineWidth, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScImageAnnotatorLineWidth, "input[type=\"range\"][scImageAnnotatorLineWidth]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScImageAnnotatorToolButton {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly tool: _angular_core.InputSignal<AnnotationTool>;
+    private readonly state;
+    protected readonly isActive: _angular_core.Signal<boolean>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotatorToolButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScImageAnnotatorToolButton, "button[scImageAnnotatorToolButton]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "tool": { "alias": "tool"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScImageAnnotatorToolbar {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly state;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly tools: {
+        id: _semantic_components_ui_lab.AnnotationTool;
+        label: string;
+    }[];
+    readonly colors: string[];
+    readonly lineWidth: _angular_core.WritableSignal<number>;
+    readonly hasAnnotations: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImageAnnotatorToolbar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScImageAnnotatorToolbar, "div[scImageAnnotatorToolbar]", ["scImageAnnotatorToolbar"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare const SC_IMAGE_COMPARE: InjectionToken<ScImageCompare>;
 declare class ScImageCompare {
-    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
     readonly position: _angular_core.ModelSignal<number>;
     readonly isDragging: _angular_core.WritableSignal<boolean>;
     startDragging(): void;
@@ -1280,18 +1496,20 @@ declare class ScInfiniteScroll {
     private readonly elementRef;
     private readonly sentinel;
     readonly classInput: _angular_core.InputSignal<string>;
+    readonly ariaLabelInput: _angular_core.InputSignal<string>;
     readonly threshold: _angular_core.InputSignal<number>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly hasReachedEnd: _angular_core.InputSignal<boolean>;
     readonly loadMore: _angular_core.OutputEmitterRef<void>;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
     protected readonly class: _angular_core.Signal<string>;
     private observer;
     constructor();
     scrollToTop(): void;
     scrollToBottom(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInfiniteScroll, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInfiniteScroll, "div[scInfiniteScroll]", ["scInfiniteScroll"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "hasReachedEnd": { "alias": "hasReachedEnd"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInfiniteScroll, "div[scInfiniteScroll]", ["scInfiniteScroll"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "hasReachedEnd": { "alias": "hasReachedEnd"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; }, never, ["*"], true, never>;
 }
 
 declare class ScInfiniteScrollLoader {
@@ -1466,7 +1684,7 @@ declare class ScLightboxThumbnail {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLightboxThumbnail, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxThumbnail, "[scLightboxThumbnail]", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.Option; inputs: { "value": "value"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxThumbnail, "[scLightboxThumbnail]", never, { "index": { "alias": "index"; "required": true; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.Option; inputs: { "value": "value"; }; outputs: {}; }]>;
 }
 
 declare class ScLightboxPortal {
@@ -1561,7 +1779,7 @@ declare class ScLightboxThumbnailBar {
     protected readonly class: _angular_core.Signal<string>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLightboxThumbnailBar, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxThumbnailBar, "[scLightboxThumbnailBar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.Listbox; inputs: { "values": "values"; }; outputs: { "valuesChange": "valuesChange"; }; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxThumbnailBar, "[scLightboxThumbnailBar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.Listbox; inputs: { "values": "values"; }; outputs: { "valuesChange": "valuesChange"; }; }]>;
 }
 
 declare class ScLightboxToolbar {
@@ -1569,14 +1787,14 @@ declare class ScLightboxToolbar {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLightboxToolbar, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxToolbar, "[scLightboxToolbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.Toolbar; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxToolbar, "[scLightboxToolbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.Toolbar; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
 }
 
 declare class ScLightboxZoomControls {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLightboxZoomControls, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomControls, "[scLightboxZoomControls]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.ToolbarWidgetGroup; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomControls, "[scLightboxZoomControls]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.ToolbarWidgetGroup; inputs: {}; outputs: {}; }]>;
 }
 
 declare class ScLightboxZoomIn {
@@ -1584,7 +1802,7 @@ declare class ScLightboxZoomIn {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLightboxZoomIn, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomIn, "button[scLightboxZoomIn]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.ToolbarWidget; inputs: { "value": "value"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomIn, "button[scLightboxZoomIn]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.ToolbarWidget; inputs: { "value": "value"; }; outputs: {}; }]>;
 }
 
 declare class ScLightboxZoomOut {
@@ -1592,7 +1810,7 @@ declare class ScLightboxZoomOut {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLightboxZoomOut, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomOut, "button[scLightboxZoomOut]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.ToolbarWidget; inputs: { "value": "value"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomOut, "button[scLightboxZoomOut]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.ToolbarWidget; inputs: { "value": "value"; }; outputs: {}; }]>;
 }
 
 declare class ScLightboxZoomReset {
@@ -1600,12 +1818,12 @@ declare class ScLightboxZoomReset {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLightboxZoomReset, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomReset, "button[scLightboxZoomReset]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.ToolbarWidget; inputs: { "value": "value"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScLightboxZoomReset, "button[scLightboxZoomReset]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.ToolbarWidget; inputs: { "value": "value"; }; outputs: {}; }]>;
 }
 
 declare class ScMarquee {
     readonly classInput: _angular_core.InputSignal<string>;
-    readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly direction: _angular_core.InputSignal<"vertical" | "horizontal">;
     readonly duration: _angular_core.InputSignal<number>;
     readonly gap: _angular_core.InputSignal<number>;
     readonly pauseOnHover: _angular_core.InputSignal<boolean>;
@@ -1631,7 +1849,7 @@ declare class ScMarqueeContent {
 
 declare class ScMarqueeFade {
     readonly classInput: _angular_core.InputSignal<string>;
-    readonly direction: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly direction: _angular_core.InputSignal<"vertical" | "horizontal">;
     readonly fadeSize: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     protected readonly maskImage: _angular_core.Signal<string>;
@@ -1641,35 +1859,33 @@ declare class ScMarqueeFade {
 
 declare class ScMarqueeText {
     readonly classInput: _angular_core.InputSignal<string>;
-    readonly text: _angular_core.InputSignal<string>;
-    readonly separator: _angular_core.InputSignal<string>;
     readonly duration: _angular_core.InputSignal<number>;
     readonly pauseOnHover: _angular_core.InputSignal<boolean>;
     readonly reverse: _angular_core.InputSignal<boolean>;
     protected readonly class: _angular_core.Signal<string>;
-    protected readonly trackClass: _angular_core.Signal<string>;
-    protected readonly textClass: _angular_core.Signal<string>;
-    protected readonly separatorClass: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMarqueeText, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMarqueeText, "div[scMarqueeText]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMarqueeText, "div[scMarqueeText]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; "isSignal": true; }; "reverse": { "alias": "reverse"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ScMasonryItem {
-    private readonly elementRef;
-    private readonly destroyRef;
-    private resizeObserver;
+declare class ScMarqueeTextTrack {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
-    readonly sizeChange: _angular_core.OutputEmitterRef<{
-        width: number;
-        height: number;
-    }>;
-    constructor();
-    private observeSize;
-    getElement(): HTMLElement;
-    getHeight(): number;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMasonryItem, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMasonryItem, "[scMasonryItem]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, { "sizeChange": "sizeChange"; }, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMarqueeTextTrack, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMarqueeTextTrack, "[scMarqueeTextTrack]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScMarqueeTextSegment {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMarqueeTextSegment, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMarqueeTextSegment, "[scMarqueeTextSegment]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScMarqueeTextSeparator {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMarqueeTextSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMarqueeTextSeparator, "[scMarqueeTextSeparator]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface MasonryBreakpoint {
@@ -1681,15 +1897,24 @@ interface MasonryConfig {
     gap?: number;
     breakpoints?: MasonryBreakpoint[];
 }
+type MasonryLayoutMode = 'columns' | 'absolute';
+interface MasonryGridRef {
+    gap: () => number;
+}
+interface MasonryItemRef {
+    getElement(): HTMLElement;
+    getHeight(): number;
+}
+declare const SC_MASONRY_GRID: InjectionToken<MasonryGridRef>;
+declare const SC_MASONRY_ITEM: InjectionToken<MasonryItemRef>;
 declare const DEFAULT_BREAKPOINTS: MasonryBreakpoint[];
 declare const DEFAULT_CONFIG: MasonryConfig;
 
-type MasonryLayoutMode = 'columns' | 'absolute';
 declare class ScMasonryGrid {
+    private readonly elementRef;
     private readonly destroyRef;
     private resizeObserver;
-    readonly containerRef: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
-    readonly items: _angular_core.Signal<readonly ScMasonryItem[]>;
+    readonly items: _angular_core.Signal<readonly _semantic_components_ui_lab.MasonryItemRef[]>;
     readonly columns: _angular_core.InputSignal<number>;
     readonly gap: _angular_core.InputSignal<number>;
     readonly breakpoints: _angular_core.InputSignal<MasonryBreakpoint[]>;
@@ -1698,60 +1923,126 @@ declare class ScMasonryGrid {
     protected readonly class: _angular_core.Signal<string>;
     protected readonly containerWidth: _angular_core.WritableSignal<number>;
     protected readonly containerHeight: _angular_core.WritableSignal<number>;
-    protected readonly currentColumns: _angular_core.Signal<number>;
-    protected readonly containerClass: _angular_core.Signal<string>;
+    readonly currentColumns: _angular_core.Signal<number>;
     constructor();
     private observeResize;
     private updateContainerWidth;
-    private applyItemGap;
     private calculateLayout;
     /** Recalculate the layout manually */
     relayout(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMasonryGrid, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMasonryGrid, "[scMasonryGrid]", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "breakpoints": { "alias": "breakpoints"; "required": false; "isSignal": true; }; "layoutMode": { "alias": "layoutMode"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMasonryGrid, "[scMasonryGrid]", ["scMasonryGrid"], { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "breakpoints": { "alias": "breakpoints"; "required": false; "isSignal": true; }; "layoutMode": { "alias": "layoutMode"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["items"], never, true, never>;
 }
 
-interface MentionUser {
-    id: string;
-    name: string;
-    username: string;
-    avatar?: string;
-}
-declare class ScMentionInput {
+declare class ScMasonryItem {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private resizeObserver;
+    protected readonly masonryGrid: _semantic_components_ui_lab.MasonryGridRef;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly sizeChange: _angular_core.OutputEmitterRef<{
+        width: number;
+        height: number;
+    }>;
+    constructor();
+    private observeSize;
+    getElement(): HTMLElement;
+    getHeight(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMasonryItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMasonryItem, "[scMasonryItem]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, { "sizeChange": "sizeChange"; }, never, never, true, never>;
+}
+
+interface MentionUser {
+    id: string;
+    name: string;
+    username: string;
+    avatar?: string;
+}
+
+declare const SC_MENTION_INPUT: InjectionToken<ScMentionInput>;
+declare class ScMentionInput {
     readonly classInput: _angular_core.InputSignal<string>;
-    readonly placeholder: _angular_core.InputSignal<string>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly rows: _angular_core.InputSignal<number>;
     readonly users: _angular_core.InputSignal<MentionUser[]>;
     readonly trigger: _angular_core.InputSignal<string>;
     readonly value: _angular_core.ModelSignal<string>;
     readonly mentions: _angular_core.ModelSignal<MentionUser[]>;
     readonly mentionSelect: _angular_core.OutputEmitterRef<MentionUser>;
-    protected readonly showSuggestions: _angular_core.WritableSignal<boolean>;
-    protected readonly searchQuery: _angular_core.WritableSignal<string>;
-    protected readonly selectedIndex: _angular_core.WritableSignal<number>;
-    protected readonly suggestionsPosition: _angular_core.WritableSignal<{
-        top: number;
-        left: number;
+    private readonly state;
+    readonly showSuggestions: _angular_core.Signal<boolean>;
+    readonly filteredUsers: _angular_core.Signal<MentionUser[]>;
+    protected readonly class: _angular_core.Signal<string>;
+    constructor();
+    focus(): void;
+    getMentions(): MentionUser[];
+    clearMentions(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMentionInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMentionInput, "[scMentionInput]", ["scMentionInput"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "users": { "alias": "users"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mentions": { "alias": "mentions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "mentions": "mentionsChange"; "mentionSelect": "mentionSelect"; }, never, never, true, never>;
+}
+
+declare class ScMentionInputState {
+    users: Signal<MentionUser[]>;
+    trigger: Signal<string>;
+    value: WritableSignal<string>;
+    mentions: WritableSignal<MentionUser[]>;
+    onMentionSelect: ((user: MentionUser) => void) | undefined;
+    textareaEl: ElementRef<HTMLTextAreaElement> | undefined;
+    overlayOrigin: CdkOverlayOrigin | undefined;
+    readonly showSuggestions: WritableSignal<boolean>;
+    readonly searchQuery: WritableSignal<string>;
+    readonly selectedIndex: WritableSignal<number>;
+    readonly caretOffset: WritableSignal<{
+        x: number;
+        y: number;
     }>;
-    private readonly textareaEl;
     private mentionStartIndex;
-    protected readonly filteredUsers: _angular_core.Signal<MentionUser[]>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly textareaClass: _angular_core.Signal<string>;
-    protected readonly suggestionsClass: _angular_core.Signal<string>;
-    protected suggestionItemClass(index: number): string;
+    readonly filteredUsers: Signal<MentionUser[]>;
     onInput(event: Event): void;
     onKeydown(event: KeyboardEvent): void;
     onBlur(): void;
     selectUser(user: MentionUser): void;
-    private closeSuggestions;
-    private updateSuggestionsPosition;
     focus(): void;
-    getMentions(): MentionUser[];
     clearMentions(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMentionInput, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMentionInput, "sc-mention-input", ["scMentionInput"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "users": { "alias": "users"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mentions": { "alias": "mentions"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "mentions": "mentionsChange"; "mentionSelect": "mentionSelect"; }, never, never, true, never>;
+    private closeSuggestions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMentionInputState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScMentionInputState>;
+}
+
+declare class ScMentionInputControl {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly idInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScMentionInputState;
+    private readonly field;
+    private readonly elementRef;
+    private readonly fallbackId;
+    readonly overlayOrigin: CdkOverlayOrigin;
+    readonly id: _angular_core.Signal<string>;
+    readonly ariaDescribedBy: _angular_core.Signal<string | null>;
+    protected readonly class: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMentionInputControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMentionInputControl, "textarea[scMentionInputControl]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScMentionInputSuggestionItem {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly user: _angular_core.InputSignal<MentionUser>;
+    readonly index: _angular_core.InputSignal<number>;
+    protected readonly state: ScMentionInputState;
+    protected readonly isSelected: _angular_core.Signal<boolean>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMentionInputSuggestionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMentionInputSuggestionItem, "button[scMentionInputSuggestionItem]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "user": { "alias": "user"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScMentionInputSuggestions {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScMentionInputState;
+    protected readonly scrollStrategy: ScrollStrategy;
+    protected readonly positions: _angular_core.Signal<ConnectedPosition[]>;
+    protected readonly listClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMentionInputSuggestions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMentionInputSuggestions, "div[scMentionInputSuggestions]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class ScNavbar {
@@ -1760,7 +2051,7 @@ declare class ScNavbar {
     readonly overlayOrigin: CdkOverlayOrigin;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScNavbar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNavbar, "nav[scNavbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof _angular_cdk_overlay.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNavbar, "nav[scNavbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
 }
 
 declare class ScNavbarProvider {
@@ -1780,7 +2071,7 @@ declare class ScNavbarProvider {
     readonly overlayOpen: _angular_core.WritableSignal<boolean>;
     protected readonly class: _angular_core.Signal<string>;
     private readonly navbar;
-    readonly origin: _angular_core.Signal<_angular_cdk_overlay.CdkOverlayOrigin | undefined>;
+    readonly origin: _angular_core.Signal<i1.CdkOverlayOrigin | undefined>;
     private readonly router;
     constructor();
     /**
@@ -1829,7 +2120,7 @@ declare class ScNavbarMobilePortal {
     private readonly destroyRef;
     readonly classInput: _angular_core.InputSignal<string>;
     private mobileMenuTemplate;
-    protected readonly origin: _angular_core.Signal<_angular_cdk_overlay.CdkOverlayOrigin | undefined>;
+    protected readonly origin: _angular_core.Signal<i1.CdkOverlayOrigin | undefined>;
     protected readonly class: _angular_core.Signal<string>;
     private overlayRef;
     constructor();
@@ -2040,65 +2331,68 @@ interface OrgChartNode {
     expanded?: boolean;
     data?: Record<string, unknown>;
 }
-type OrgChartDirection = 'vertical' | 'horizontal';
-interface OrgChartNodeClickEvent {
+type ScOrgChartDirection = 'vertical' | 'horizontal';
+interface ScOrgChartNodeExpandEvent {
     node: OrgChartNode;
-    event: MouseEvent;
+    expanded: boolean;
 }
-interface OrgChartNodeExpandEvent {
-    node: OrgChartNode;
+interface ScOrgChartNodeDefContext {
+    $implicit: OrgChartNode;
     expanded: boolean;
+    hasChildren: boolean;
+    toggle: () => void;
+}
+declare const SC_ORG_CHART: InjectionToken<ScOrgChart>;
+
+declare class ScOrgChartNodeDef {
+    readonly templateRef: TemplateRef<ScOrgChartNodeDefContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScOrgChartNodeDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScOrgChartNodeDef, "ng-template[scOrgChartNodeDef]", never, {}, {}, never, never, true, never>;
 }
 
 declare class ScOrgChart {
-    readonly data: _angular_core.InputSignal<OrgChartNode | null>;
-    readonly direction: _angular_core.InputSignal<OrgChartDirection>;
+    readonly direction: _angular_core.InputSignal<ScOrgChartDirection>;
     readonly collapsible: _angular_core.InputSignal<boolean>;
     readonly compact: _angular_core.InputSignal<boolean>;
     readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly class: _angular_core.InputSignal<string>;
-    readonly nodeClick: _angular_core.OutputEmitterRef<OrgChartNodeClickEvent>;
-    readonly nodeExpand: _angular_core.OutputEmitterRef<OrgChartNodeExpandEvent>;
-    protected readonly containerClass: _angular_core.Signal<string>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly nodeExpand: _angular_core.OutputEmitterRef<ScOrgChartNodeExpandEvent>;
+    readonly nodeDef: _angular_core.Signal<ScOrgChartNodeDef>;
+    protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScOrgChart, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScOrgChart, "sc-org-chart", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeExpand": "nodeExpand"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScOrgChart, "div[scOrgChart]", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, { "nodeExpand": "nodeExpand"; }, ["nodeDef"], never, true, never>;
+}
+
+declare class ScOrgChartCard {
+    private readonly orgChart;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScOrgChartCard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScOrgChartCard, "button[scOrgChartCard]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScOrgChartNode {
+    readonly orgChart: _semantic_components_ui_lab.ScOrgChart;
     readonly node: _angular_core.InputSignal<OrgChartNode>;
-    readonly direction: _angular_core.InputSignal<OrgChartDirection>;
-    readonly collapsible: _angular_core.InputSignal<boolean>;
-    readonly compact: _angular_core.InputSignal<boolean>;
-    readonly nodeClick: _angular_core.OutputEmitterRef<OrgChartNodeClickEvent>;
-    readonly nodeExpand: _angular_core.OutputEmitterRef<OrgChartNodeExpandEvent>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly hostClass: _angular_core.Signal<string>;
     protected readonly expanded: _angular_core.WritableSignal<boolean | null>;
-    protected readonly hasChildren: _angular_core.Signal<boolean | undefined>;
+    protected readonly hasChildren: _angular_core.Signal<boolean>;
     protected readonly isExpanded: _angular_core.Signal<boolean>;
+    readonly toggleFn: () => void;
+    protected readonly templateContext: _angular_core.Signal<ScOrgChartNodeDefContext>;
     protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly nodeCardClass: _angular_core.Signal<string>;
-    protected readonly cardButtonClass: _angular_core.Signal<string>;
-    protected readonly expandIconClass: _angular_core.Signal<string>;
     protected readonly childrenContainerClass: _angular_core.Signal<string>;
     protected readonly connectorClass: _angular_core.Signal<string>;
     protected readonly childrenWrapperClass: _angular_core.Signal<string>;
     protected childNodeClass(isFirst: boolean, isLast: boolean): string;
     protected horizontalConnectorClass(isFirst: boolean, isLast: boolean): string;
-    getInitials(name: string): string;
-    onNodeClick(event: MouseEvent): void;
+    onToggle(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScOrgChartNode, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScOrgChartNode, "sc-org-chart-node", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeExpand": "nodeExpand"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScOrgChartNode, "sc-org-chart-node", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type PdfZoomLevel = 'auto' | 'page-fit' | 'page-width' | number;
-interface PdfToolbarConfig {
-    showNavigation?: boolean;
-    showZoom?: boolean;
-    showDownload?: boolean;
-    showPrint?: boolean;
-    showFullscreen?: boolean;
-    showPageInfo?: boolean;
-    showRotate?: boolean;
-}
+type PdfZoomLevel = 'auto' | 'page-actual' | 'page-fit' | 'page-width' | number;
 interface PdfLoadEvent {
     totalPages: number;
 }
@@ -2114,7 +2408,58 @@ interface PdfErrorEvent {
     error: Error;
     message: string;
 }
-declare const DEFAULT_TOOLBAR_CONFIG: PdfToolbarConfig;
+type PdfFindState = 'idle' | 'found' | 'not-found' | 'wrapped' | 'pending';
+interface PdfPageMatchInfo {
+    matches: number[];
+    matchesLength: number[];
+}
+type PdfEditorMode = 'none' | 'highlight' | 'freetext' | 'ink' | 'stamp' | 'signature';
+interface PdfEditorAnnotation {
+    id: string;
+    type: 'highlight' | 'freetext' | 'ink' | 'stamp' | 'signature';
+    pageNumber: number;
+    rects?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }[];
+    color?: string;
+    opacity?: number;
+    text?: string;
+    x?: number;
+    y?: number;
+    fontSize?: number;
+    fontColor?: string;
+    strokes?: {
+        x: number;
+        y: number;
+    }[][];
+    strokeWidth?: number;
+    imageDataUrl?: string;
+    width?: number;
+    height?: number;
+    altText?: string;
+    isDecorative?: boolean;
+    description?: string;
+}
+interface PdfSignatureData {
+    id: string;
+    dataUrl: string;
+    description: string;
+    width: number;
+    height: number;
+}
+interface PdfComment {
+    id: string;
+    pageNumber: number;
+    x: number;
+    y: number;
+    text: string;
+    author: string;
+    date: string;
+    color: string;
+}
 declare const ZOOM_LEVELS: {
     label: string;
     value: PdfZoomLevel;
@@ -2123,11 +2468,13 @@ declare const ZOOM_LEVELS: {
 declare const SC_PDF_VIEWER: InjectionToken<ScPdfViewerRoot>;
 declare class ScPdfViewerRoot {
     private readonly destroyRef;
-    private readonly sanitizer;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
     readonly src: _angular_core.InputSignal<string>;
     readonly title: _angular_core.InputSignal<string>;
     readonly initialPage: _angular_core.InputSignal<number>;
     readonly initialZoom: _angular_core.InputSignal<PdfZoomLevel>;
+    readonly workerSrc: _angular_core.InputSignal<string>;
     readonly loaded: _angular_core.OutputEmitterRef<PdfLoadEvent>;
     readonly pageChange: _angular_core.OutputEmitterRef<PdfPageChangeEvent>;
     readonly zoomChange: _angular_core.OutputEmitterRef<PdfZoomChangeEvent>;
@@ -2139,13 +2486,59 @@ declare class ScPdfViewerRoot {
     readonly zoom: _angular_core.WritableSignal<PdfZoomLevel>;
     readonly rotation: _angular_core.WritableSignal<number>;
     readonly isFullscreen: _angular_core.WritableSignal<boolean>;
+    readonly pdfDocument: _angular_core.WritableSignal<pdfjs_dist_types_src_display_api.PDFDocumentProxy | null>;
+    readonly navigateTrigger: _angular_core.WritableSignal<number>;
+    readonly findOpen: _angular_core.WritableSignal<boolean>;
+    readonly findQuery: _angular_core.WritableSignal<string>;
+    readonly findMatchCase: _angular_core.WritableSignal<boolean>;
+    readonly findHighlightAll: _angular_core.WritableSignal<boolean>;
+    readonly findEntireWord: _angular_core.WritableSignal<boolean>;
+    readonly findMatchDiacritics: _angular_core.WritableSignal<boolean>;
+    readonly findState: _angular_core.WritableSignal<PdfFindState>;
+    readonly findCurrentMatchIndex: _angular_core.WritableSignal<number>;
+    readonly findTotalMatches: _angular_core.WritableSignal<number>;
+    readonly pageMatches: _angular_core.WritableSignal<PdfPageMatchInfo[]>;
+    readonly findTrigger: _angular_core.WritableSignal<number>;
+    private pageTexts;
+    readonly editorMode: _angular_core.WritableSignal<PdfEditorMode>;
+    readonly editorAnnotations: _angular_core.WritableSignal<PdfEditorAnnotation[]>;
+    readonly editorTrigger: _angular_core.WritableSignal<number>;
+    readonly highlightColor: _angular_core.WritableSignal<string>;
+    readonly highlightThickness: _angular_core.WritableSignal<number>;
+    readonly highlightShowAll: _angular_core.WritableSignal<boolean>;
+    readonly freetextColor: _angular_core.WritableSignal<string>;
+    readonly freetextSize: _angular_core.WritableSignal<number>;
+    readonly inkColor: _angular_core.WritableSignal<string>;
+    readonly inkThickness: _angular_core.WritableSignal<number>;
+    readonly inkOpacity: _angular_core.WritableSignal<number>;
+    readonly passwordRequired: _angular_core.WritableSignal<boolean>;
+    readonly passwordReason: _angular_core.WritableSignal<"need-password" | "incorrect-password" | null>;
+    private passwordCallback;
+    readonly altTextDialogOpen: _angular_core.WritableSignal<boolean>;
+    readonly altTextAnnotationId: _angular_core.WritableSignal<string | null>;
+    readonly signatureDialogOpen: _angular_core.WritableSignal<boolean>;
+    readonly savedSignatures: _angular_core.WritableSignal<PdfSignatureData[]>;
+    readonly comments: _angular_core.WritableSignal<PdfComment[]>;
+    readonly undoBarVisible: _angular_core.WritableSignal<boolean>;
+    readonly undoBarMessage: _angular_core.WritableSignal<string>;
+    private undoAction;
+    private undoTimeout;
+    readonly printProgress: _angular_core.WritableSignal<number>;
+    readonly printDialogOpen: _angular_core.WritableSignal<boolean>;
+    private printCancelled;
+    readonly sidebarWidth: _angular_core.WritableSignal<number>;
+    private editorIdCounter;
+    private commentIdCounter;
+    readonly findResultsMessage: _angular_core.Signal<string>;
     private containerElement;
     readonly canGoPrev: _angular_core.Signal<boolean>;
     readonly canGoNext: _angular_core.Signal<boolean>;
     readonly hasSource: _angular_core.Signal<boolean>;
     readonly showContent: _angular_core.Signal<boolean>;
-    readonly safePdfUrl: _angular_core.Signal<"" | SafeResourceUrl>;
+    private workerReady;
     constructor();
+    private initWorker;
+    private loadDocument;
     setContainerElement(element: ElementRef<HTMLElement>): void;
     onLoad(): void;
     onError(message?: string): void;
@@ -2158,12 +2551,37 @@ declare class ScPdfViewerRoot {
     setZoom(level: PdfZoomLevel): void;
     rotateLeft(): void;
     rotateRight(): void;
-    download(): void;
+    download(): Promise<void>;
+    printWithProgress(): Promise<void>;
+    cancelPrint(): void;
     print(): void;
     toggleFullscreen(): void;
     setTotalPages(total: number): void;
+    submitPassword(password: string): void;
+    cancelPassword(): void;
+    openSignatureDialog(): void;
+    closeSignatureDialog(): void;
+    addSavedSignature(sig: Omit<PdfSignatureData, 'id'>): void;
+    removeSavedSignature(id: string): void;
+    addComment(comment: Omit<PdfComment, 'id'>): void;
+    removeComment(id: string): void;
+    updateComment(id: string, text: string): void;
+    toggleFind(): void;
+    find(query: string): Promise<void>;
+    findNext(): void;
+    findPrevious(): void;
+    clearFind(): void;
+    private scrollToMatch;
+    setEditorMode(mode: PdfEditorMode): void;
+    addEditorAnnotation(annotation: Omit<PdfEditorAnnotation, 'id'>): void;
+    updateEditorAnnotation(id: string, changes: Partial<Omit<PdfEditorAnnotation, 'id'>>): void;
+    removeEditorAnnotation(id: string): void;
+    clearEditorAnnotations(): void;
+    private showUndoBar;
+    undoLastAction(): void;
+    closeUndoBar(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScPdfViewerRoot, "[scPdfViewer]", ["scPdfViewer"], { "src": { "alias": "src"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "initialPage": { "alias": "initialPage"; "required": false; "isSignal": true; }; "initialZoom": { "alias": "initialZoom"; "required": false; "isSignal": true; }; }, { "loaded": "loaded"; "pageChange": "pageChange"; "zoomChange": "zoomChange"; "errorEvent": "errorEvent"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScPdfViewerRoot, "[scPdfViewer]", ["scPdfViewer"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "initialPage": { "alias": "initialPage"; "required": false; "isSignal": true; }; "initialZoom": { "alias": "initialZoom"; "required": false; "isSignal": true; }; "workerSrc": { "alias": "workerSrc"; "required": false; "isSignal": true; }; }, { "loaded": "loaded"; "pageChange": "pageChange"; "zoomChange": "zoomChange"; "errorEvent": "errorEvent"; }, never, never, true, never>;
 }
 
 declare class ScPdfViewerContainer {
@@ -2176,11 +2594,11 @@ declare class ScPdfViewerContainer {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerContainer, "[scPdfViewerContainer]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class ScPdfViewerToolbar$1 {
+declare class ScPdfViewerToolbar {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerToolbar$1, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerToolbar$1, "[scPdfViewerToolbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerToolbar, "[scPdfViewerToolbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 declare class ScPdfViewerNav {
@@ -2296,29 +2714,99 @@ declare class ScPdfViewerSeparator {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerSeparator, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerSeparator, "[scPdfViewerSeparator]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScPdfViewerSeparator, "[scPdfViewerSeparator]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScPdfViewerSpacer {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerSpacer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerSpacer, "[scPdfViewerSpacer]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScPdfViewerSpacer, "[scPdfViewerSpacer]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScPdfViewerContent {
-    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
-    protected onError(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerContent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerContent, "[scPdfViewerContent]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScPdfViewerContent, "[scPdfViewerContent]", ["scPdfViewerContent"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface PageLayout {
+    pageNumber: number;
+    width: number;
+    height: number;
+}
+declare class ScPdfViewerCanvas {
+    private readonly pdfViewer;
+    private readonly destroyRef;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly scrollContainer;
+    private readonly dpr;
+    readonly pageLayouts: _angular_core.WritableSignal<PageLayout[]>;
+    private readonly pdfDocument;
+    readonly rotation: _angular_core.WritableSignal<number>;
+    private readonly zoom;
+    private readonly navigateTrigger;
+    private readonly findTrigger;
+    private readonly linkService;
+    private activeRenderTasks;
+    private activeTextLayers;
+    private renderedPages;
+    private textLayerData;
+    private observer;
+    private resizeObserver;
+    private renderTimeout;
+    private scrollHandler;
+    private readonly editorMode;
+    private readonly editorTrigger;
+    private inkCurrentStroke;
+    private inkCurrentPage;
+    private inkDrawing;
+    private selectedAnnotationId;
+    private dragState;
+    private resizeState;
+    readonly editorPointerEvents: _angular_core.Signal<"none" | "auto">;
+    readonly editorCursor: _angular_core.Signal<"default" | "text" | "crosshair">;
+    readonly pageCursor: _angular_core.Signal<"" | "text">;
+    private readonly containerSize;
+    readonly scaledValue: _angular_core.Signal<number>;
+    constructor();
+    private scheduleRender;
+    private computePageLayouts;
+    private setupResizeObserver;
+    private setupIntersectionObserver;
+    private renderVisiblePages;
+    private updateCurrentPageFromScroll;
+    private renderPage;
+    private renderAnnotationLayer;
+    private cancelAllRenderTasks;
+    private applyHighlights;
+    private clearPageHighlights;
+    private renderPageHighlights;
+    private readonly onHighlightMouseUp;
+    onEditorPointerDown(event: PointerEvent, pageNumber: number): void;
+    onEditorPointerMove(event: PointerEvent, _pageNumber: number): void;
+    onEditorPointerUp(event: PointerEvent, _pageNumber: number): void;
+    private getOrCreateInkCanvas;
+    private createFreetextEditor;
+    private renderEditorAnnotations;
+    private createInteractiveHighlight;
+    private createInteractiveStamp;
+    private createInteractiveFreetext;
+    private readonly onGlobalPointerDown;
+    private readonly onGlobalPointerMove;
+    private readonly onGlobalPointerUp;
+    private readonly onAnnotationKeyDown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerCanvas, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerCanvas, "sc-pdf-viewer-canvas", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScPdfViewerLoading {
     readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
     readonly classInput: _angular_core.InputSignal<string>;
-    protected readonly overlayClass: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly overlayClass: string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerLoading, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerLoading, "[scPdfViewerLoading]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -2326,7 +2814,8 @@ declare class ScPdfViewerLoading {
 declare class ScPdfViewerError {
     readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
     readonly classInput: _angular_core.InputSignal<string>;
-    protected readonly overlayClass: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly overlayClass: string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerError, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerError, "[scPdfViewerError]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -2334,7 +2823,8 @@ declare class ScPdfViewerError {
 declare class ScPdfViewerEmpty {
     readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
     readonly classInput: _angular_core.InputSignal<string>;
-    protected readonly overlayClass: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly overlayClass: string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerEmpty, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerEmpty, "[scPdfViewerEmpty]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
@@ -2347,135 +2837,235 @@ declare class ScPdfViewerRetry {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerRetry, "button[scPdfViewerRetry]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class ScPdfViewer {
-    private readonly destroyRef;
-    private readonly sanitizer;
-    private readonly containerRef;
-    readonly src: _angular_core.InputSignal<string>;
-    readonly title: _angular_core.InputSignal<string>;
-    readonly showToolbar: _angular_core.InputSignal<boolean>;
-    readonly toolbarConfig: _angular_core.InputSignal<PdfToolbarConfig>;
-    readonly initialPage: _angular_core.InputSignal<number>;
-    readonly initialZoom: _angular_core.InputSignal<PdfZoomLevel>;
-    readonly class: _angular_core.InputSignal<string>;
-    readonly loaded: _angular_core.OutputEmitterRef<PdfLoadEvent>;
-    readonly pageChange: _angular_core.OutputEmitterRef<PdfPageChangeEvent>;
-    readonly zoomChange: _angular_core.OutputEmitterRef<PdfZoomChangeEvent>;
-    readonly errorEvent: _angular_core.OutputEmitterRef<PdfErrorEvent>;
-    protected readonly isLoading: _angular_core.WritableSignal<boolean>;
-    protected readonly error: _angular_core.WritableSignal<string | null>;
-    protected readonly currentPage: _angular_core.WritableSignal<number>;
-    protected readonly totalPages: _angular_core.WritableSignal<number>;
-    protected readonly zoom: _angular_core.WritableSignal<PdfZoomLevel>;
-    protected readonly rotation: _angular_core.WritableSignal<number>;
-    protected readonly isFullscreen: _angular_core.WritableSignal<boolean>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly safePdfUrl: _angular_core.Signal<"" | SafeResourceUrl>;
-    constructor();
-    protected onLoad(): void;
-    protected onError(event: Event): void;
-    protected retry(): void;
-    protected goToPrevPage(): void;
-    protected goToNextPage(): void;
-    protected goToPage(page: number): void;
-    protected handleZoomIn(): void;
-    protected handleZoomOut(): void;
-    protected handleZoomChange(level: PdfZoomLevel): void;
-    protected handleRotateLeft(): void;
-    protected handleRotateRight(): void;
-    protected handleDownload(): void;
-    protected handlePrint(): void;
-    protected toggleFullscreen(): void;
-    setPage(page: number): void;
-    setZoom(level: PdfZoomLevel): void;
-    setTotalPages(total: number): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewer, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewer, "sc-pdf-viewer", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "showToolbar": { "alias": "showToolbar"; "required": false; "isSignal": true; }; "toolbarConfig": { "alias": "toolbarConfig"; "required": false; "isSignal": true; }; "initialPage": { "alias": "initialPage"; "required": false; "isSignal": true; }; "initialZoom": { "alias": "initialZoom"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "loaded": "loaded"; "pageChange": "pageChange"; "zoomChange": "zoomChange"; "errorEvent": "errorEvent"; }, never, never, true, never>;
+declare class ScPdfViewerFindToggle {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerFindToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerFindToggle, "button[scPdfViewerFindToggle]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class ScPdfViewerToolbar {
-    readonly currentPage: _angular_core.InputSignal<number>;
-    readonly totalPages: _angular_core.InputSignal<number>;
-    readonly zoom: _angular_core.InputSignal<PdfZoomLevel>;
-    readonly isFullscreen: _angular_core.InputSignal<boolean>;
-    readonly toolbarConfig: _angular_core.InputSignal<PdfToolbarConfig>;
-    readonly class: _angular_core.InputSignal<string>;
-    readonly prevPage: _angular_core.OutputEmitterRef<void>;
-    readonly nextPage: _angular_core.OutputEmitterRef<void>;
-    readonly goToPage: _angular_core.OutputEmitterRef<number>;
-    readonly zoomIn: _angular_core.OutputEmitterRef<void>;
-    readonly zoomOut: _angular_core.OutputEmitterRef<void>;
-    readonly zoomChange: _angular_core.OutputEmitterRef<PdfZoomLevel>;
-    readonly rotateLeft: _angular_core.OutputEmitterRef<void>;
-    readonly rotateRight: _angular_core.OutputEmitterRef<void>;
-    readonly download: _angular_core.OutputEmitterRef<void>;
-    readonly print: _angular_core.OutputEmitterRef<void>;
-    readonly toggleFullscreen: _angular_core.OutputEmitterRef<void>;
-    protected readonly zoomLevels: {
-        label: string;
-        value: PdfZoomLevel;
-    }[];
-    protected readonly config: _angular_core.Signal<{
-        showNavigation?: boolean;
-        showZoom?: boolean;
-        showDownload?: boolean;
-        showPrint?: boolean;
-        showFullscreen?: boolean;
-        showPageInfo?: boolean;
-        showRotate?: boolean;
+declare class ScPdfViewerFindbar {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerFindbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerFindbar, "[scPdfViewerFindbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPdfViewerFindInput {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected onInput(event: Event): void;
+    protected onShiftEnter(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerFindInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerFindInput, "input[scPdfViewerFindInput]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerFindNext {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerFindNext, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerFindNext, "button[scPdfViewerFindNext]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPdfViewerFindPrevious {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerFindPrevious, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerFindPrevious, "button[scPdfViewerFindPrevious]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPdfViewerFindResultsInfo {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerFindResultsInfo, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerFindResultsInfo, "[scPdfViewerFindResultsInfo]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerEditorHighlightParams {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly colors: string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerEditorHighlightParams, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerEditorHighlightParams, "sc-pdf-viewer-editor-highlight-params", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerEditorFreetextParams {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerEditorFreetextParams, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerEditorFreetextParams, "sc-pdf-viewer-editor-freetext-params", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerEditorInkParams {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly Math: Math;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerEditorInkParams, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerEditorInkParams, "sc-pdf-viewer-editor-ink-params", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerPasswordDialog {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly password: _angular_core.WritableSignal<string>;
+    submit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerPasswordDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerPasswordDialog, "sc-pdf-viewer-password-dialog", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SignatureTab = 'type' | 'draw' | 'image';
+declare class ScPdfViewerSignatureDialog {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly drawCanvasRef;
+    readonly activeTab: _angular_core.WritableSignal<SignatureTab>;
+    readonly typedText: _angular_core.WritableSignal<string>;
+    readonly description: _angular_core.WritableSignal<string>;
+    readonly drawThickness: _angular_core.WritableSignal<number>;
+    readonly hasDrawn: _angular_core.WritableSignal<boolean>;
+    readonly imagePreview: _angular_core.WritableSignal<string | null>;
+    private drawing;
+    private drawPaths;
+    private currentPath;
+    readonly canAdd: _angular_core.Signal<boolean>;
+    onDrawStart(event: PointerEvent): void;
+    onDrawMove(event: PointerEvent): void;
+    onDrawEnd(event: PointerEvent): void;
+    onImageSelected(event: Event): void;
+    clear(): void;
+    close(): void;
+    addSignature(): void;
+    private renderTypedSignature;
+    private redrawCanvas;
+    private resetAll;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerSignatureDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerSignatureDialog, "sc-pdf-viewer-signature-dialog", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerAltTextDialog {
+    private readonly pdfViewer;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly open: _angular_core.InputSignal<boolean>;
+    readonly annotationId: _angular_core.InputSignal<string | null>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly saved: _angular_core.OutputEmitterRef<{
+        annotationId: string;
+        altText: string;
+        isDecorative: boolean;
     }>;
-    protected readonly toolbarClass: _angular_core.Signal<string>;
-    protected readonly zoomLevelValue: _angular_core.Signal<string>;
-    protected onPageInput(event: Event): void;
-    protected onZoomSelect(event: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerToolbar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerToolbar, "sc-pdf-viewer-toolbar", never, { "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "totalPages": { "alias": "totalPages"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "isFullscreen": { "alias": "isFullscreen"; "required": false; "isSignal": true; }; "toolbarConfig": { "alias": "toolbarConfig"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "prevPage": "prevPage"; "nextPage": "nextPage"; "goToPage": "goToPage"; "zoomIn": "zoomIn"; "zoomOut": "zoomOut"; "zoomChange": "zoomChange"; "rotateLeft": "rotateLeft"; "rotateRight": "rotateRight"; "download": "download"; "print": "print"; "toggleFullscreen": "toggleFullscreen"; }, never, never, true, never>;
+    private readonly dialogEl;
+    readonly altText: _angular_core.WritableSignal<string>;
+    readonly isDecorative: _angular_core.WritableSignal<boolean>;
+    readonly dialogX: _angular_core.WritableSignal<number>;
+    readonly dialogY: _angular_core.WritableSignal<number>;
+    constructor();
+    cancel(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerAltTextDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerAltTextDialog, "sc-pdf-viewer-alt-text-dialog", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "annotationId": { "alias": "annotationId"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "saved": "saved"; }, never, never, true, never>;
 }
 
-type QRErrorCorrectionLevel = 'L' | 'M' | 'Q' | 'H';
+declare class ScPdfViewerPrintProgress {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerPrintProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerPrintProgress, "sc-pdf-viewer-print-progress", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerSidebarResizer {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly resizing: _angular_core.WritableSignal<boolean>;
+    private startX;
+    private startWidth;
+    private onPointerMove;
+    private onPointerUp;
+    onPointerDown(event: PointerEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerSidebarResizer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerSidebarResizer, "sc-pdf-viewer-sidebar-resizer", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface LayerItem {
+    id: string;
+    name: string;
+    visible: boolean;
+}
+declare class ScPdfViewerLayersView {
+    private readonly pdfViewer;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly layers: _angular_core.WritableSignal<LayerItem[]>;
+    private optionalContentConfig;
+    constructor();
+    private loadLayers;
+    toggleLayer(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerLayersView, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerLayersView, "sc-pdf-viewer-layers-view", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerCommentSidebar {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly addingComment: _angular_core.WritableSignal<boolean>;
+    readonly newCommentText: _angular_core.WritableSignal<string>;
+    readonly editingId: _angular_core.WritableSignal<string | null>;
+    readonly editText: _angular_core.WritableSignal<string>;
+    submitComment(): void;
+    startEdit(comment: PdfComment): void;
+    saveEdit(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerCommentSidebar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerCommentSidebar, "sc-pdf-viewer-comment-sidebar", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScPdfViewerEditorUndoBar {
+    readonly pdfViewer: _semantic_components_ui_lab.ScPdfViewerRoot;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPdfViewerEditorUndoBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPdfViewerEditorUndoBar, "sc-pdf-viewer-editor-undo-bar", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type ScQrCodeEcc = 'L' | 'M' | 'Q' | 'H';
 declare class ScQrCode {
+    readonly nativeElement: any;
     readonly value: _angular_core.InputSignal<string>;
-    readonly size: _angular_core.InputSignal<number>;
-    readonly errorCorrectionLevel: _angular_core.InputSignal<QRErrorCorrectionLevel>;
-    readonly foregroundColor: _angular_core.InputSignal<string>;
-    readonly backgroundColor: _angular_core.InputSignal<string>;
-    readonly quietZone: _angular_core.InputSignal<number>;
-    readonly logo: _angular_core.InputSignal<string>;
-    readonly logoSize: _angular_core.InputSignal<number>;
-    readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly qrMatrix: _angular_core.Signal<boolean[][]>;
-    protected readonly moduleCount: _angular_core.Signal<number>;
+    readonly ecc: _angular_core.InputSignal<ScQrCodeEcc>;
+    readonly border: _angular_core.InputSignal<number>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
     protected readonly viewBox: _angular_core.Signal<string>;
-    protected readonly logoPosition: _angular_core.Signal<{
-        x: number;
-        y: number;
+    protected readonly qrData: _angular_core.Signal<uqr.QrCodeGenerateResult | {
+        data: boolean[][];
         size: number;
-        padding: number;
     }>;
-    protected readonly containerClass: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScQrCode, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScQrCode, "sc-qr-code", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "errorCorrectionLevel": { "alias": "errorCorrectionLevel"; "required": false; "isSignal": true; }; "foregroundColor": { "alias": "foregroundColor"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "quietZone": { "alias": "quietZone"; "required": false; "isSignal": true; }; "logo": { "alias": "logo"; "required": false; "isSignal": true; }; "logoSize": { "alias": "logoSize"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScQrCode, "svg[scQrCode]", ["scQrCode"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "ecc": { "alias": "ecc"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScQrCodeDownload {
-    readonly value: _angular_core.InputSignal<string>;
-    readonly size: _angular_core.InputSignal<number>;
-    readonly errorCorrectionLevel: _angular_core.InputSignal<QRErrorCorrectionLevel>;
-    readonly foregroundColor: _angular_core.InputSignal<string>;
-    readonly backgroundColor: _angular_core.InputSignal<string>;
-    readonly quietZone: _angular_core.InputSignal<number>;
-    readonly logo: _angular_core.InputSignal<string>;
-    readonly logoSize: _angular_core.InputSignal<number>;
-    readonly showDownload: _angular_core.InputSignal<boolean>;
-    readonly downloadLabel: _angular_core.InputSignal<string>;
+    readonly for: _angular_core.InputSignal<ScQrCode>;
     readonly filename: _angular_core.InputSignal<string>;
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly buttonClass: _angular_core.Signal<string>;
-    download(): void;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected download(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScQrCodeDownload, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScQrCodeDownload, "sc-qr-code-download", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "errorCorrectionLevel": { "alias": "errorCorrectionLevel"; "required": false; "isSignal": true; }; "foregroundColor": { "alias": "foregroundColor"; "required": false; "isSignal": true; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; "isSignal": true; }; "quietZone": { "alias": "quietZone"; "required": false; "isSignal": true; }; "logo": { "alias": "logo"; "required": false; "isSignal": true; }; "logoSize": { "alias": "logoSize"; "required": false; "isSignal": true; }; "showDownload": { "alias": "showDownload"; "required": false; "isSignal": true; }; "downloadLabel": { "alias": "downloadLabel"; "required": false; "isSignal": true; }; "filename": { "alias": "filename"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScQrCodeDownload, "button[scQrCodeDownload]", never, { "for": { "alias": "for"; "required": true; "isSignal": true; }; "filename": { "alias": "filename"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface ScSignaturePoint {
@@ -2514,15 +3104,15 @@ declare class ScSignaturePadCanvas {
     readonly signaturePad: _semantic_components_ui_lab.ScSignaturePad;
     private readonly elementRef;
     private readonly destroyRef;
-    readonly width: _angular_core.InputSignal<number>;
-    readonly height: _angular_core.InputSignal<number>;
     readonly ariaLabel: _angular_core.InputSignal<string>;
     readonly classInput: _angular_core.InputSignal<string>;
     readonly value: _angular_core.ModelSignal<string>;
     readonly signatureChange: _angular_core.OutputEmitterRef<string>;
     readonly strokeEnd: _angular_core.OutputEmitterRef<void>;
     protected readonly class: _angular_core.Signal<string>;
+    private resizeObserver;
     constructor();
+    private syncCanvasSize;
     private getCanvasPoint;
     protected onPointerDown(event: MouseEvent): void;
     protected onPointerMove(event: MouseEvent): void;
@@ -2535,14 +3125,14 @@ declare class ScSignaturePadCanvas {
     private redraw;
     private emitSignature;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSignaturePadCanvas, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSignaturePadCanvas, "canvas[scSignaturePadCanvas]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "signatureChange": "signatureChange"; "strokeEnd": "strokeEnd"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSignaturePadCanvas, "canvas[scSignaturePadCanvas]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "signatureChange": "signatureChange"; "strokeEnd": "strokeEnd"; }, never, never, true, never>;
 }
 
 declare class ScSignaturePadControls {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSignaturePadControls, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSignaturePadControls, "div[scSignaturePadControls]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSignaturePadControls, "div[scSignaturePadControls]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSignaturePadUndoButton {
@@ -2553,7 +3143,7 @@ declare class ScSignaturePadUndoButton {
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSignaturePadUndoButton, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSignaturePadUndoButton, "button[scSignaturePadUndo]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSignaturePadUndoButton, "button[scSignaturePadUndo]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSignaturePadClearButton {
@@ -2564,14 +3154,14 @@ declare class ScSignaturePadClearButton {
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSignaturePadClearButton, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSignaturePadClearButton, "button[scSignaturePadClear]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSignaturePadClearButton, "button[scSignaturePadClear]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSignaturePadToolbar {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSignaturePadToolbar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSignaturePadToolbar, "div[scSignaturePadToolbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSignaturePadToolbar, "div[scSignaturePadToolbar]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSignaturePadColorButton {
@@ -2584,7 +3174,7 @@ declare class ScSignaturePadColorButton {
     protected readonly class: _angular_core.Signal<string>;
     protected onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSignaturePadColorButton, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSignaturePadColorButton, "button[scSignaturePadPenColor]", never, { "color": { "alias": "color"; "required": true; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSignaturePadColorButton, "button[scSignaturePadPenColor]", never, { "color": { "alias": "color"; "required": true; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSignaturePadWidthButton {
@@ -2597,72 +3187,116 @@ declare class ScSignaturePadWidthButton {
     protected readonly class: _angular_core.Signal<string>;
     protected onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSignaturePadWidthButton, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSignaturePadWidthButton, "button[scSignaturePadPenWidth]", never, { "width": { "alias": "width"; "required": true; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSignaturePadWidthButton, "button[scSignaturePadPenWidth]", never, { "width": { "alias": "width"; "required": true; "isSignal": true; }; "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type SpeedDialDirection = 'up' | 'down' | 'left' | 'right';
-interface SpeedDialAction {
-    id: string;
-    icon: Type<unknown>;
-    label: string;
-    disabled?: boolean;
-    ariaLabel?: string;
-}
-interface SpeedDialActionClickEvent {
-    action: SpeedDialAction;
-    index: number;
+declare class ScSpeedDialAction {
+    readonly speedDial: _semantic_components_ui_lab.ScSpeedDial;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly index: _angular_core.Signal<number>;
+    protected readonly transitionDelay: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpeedDialAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpeedDialAction, "[scSpeedDialAction]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+type SpeedDialDirection = 'up' | 'down' | 'left' | 'right';
+type SpeedDialSize = 'sm' | 'md' | 'lg';
+
 declare class ScSpeedDial {
     private readonly elementRef;
     private readonly destroyRef;
-    readonly actions: _angular_core.InputSignal<SpeedDialAction[]>;
+    readonly classInput: _angular_core.InputSignal<string>;
     readonly direction: _angular_core.InputSignal<SpeedDialDirection>;
-    readonly icon: _angular_core.InputSignal<Type<unknown> | null>;
-    readonly closeIcon: _angular_core.InputSignal<Type<unknown> | null>;
-    readonly label: _angular_core.InputSignal<string>;
-    readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly showLabels: _angular_core.InputSignal<boolean>;
-    readonly closeOnActionClick: _angular_core.InputSignal<boolean>;
-    readonly closeOnOutsideClick: _angular_core.InputSignal<boolean>;
-    readonly size: _angular_core.InputSignal<"sm" | "lg" | "md">;
-    readonly actionSize: _angular_core.InputSignal<"sm" | "lg" | "md">;
-    readonly class: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<SpeedDialSize>;
     readonly open: _angular_core.ModelSignal<boolean>;
-    readonly actionClick: _angular_core.OutputEmitterRef<SpeedDialActionClickEvent>;
-    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly actionsContainerClass: _angular_core.Signal<string>;
-    protected readonly fabClass: _angular_core.Signal<string>;
-    protected readonly fabIconClass: _angular_core.Signal<string>;
-    protected actionWrapperClass(index: number): string;
-    private fabSizeClasses;
+    readonly actions: _angular_core.Signal<readonly ScSpeedDialAction[]>;
+    protected readonly class: _angular_core.Signal<string>;
     constructor();
     toggle(): void;
     close(): void;
-    onActionClick(action: SpeedDialAction, index: number): void;
     onEscape(): void;
     private setupOutsideClickHandler;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpeedDial, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpeedDial, "sc-speed-dial", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "closeIcon": { "alias": "closeIcon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; "closeOnActionClick": { "alias": "closeOnActionClick"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "actionSize": { "alias": "actionSize"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "actionClick": "actionClick"; "openChange": "openChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpeedDial, "[scSpeedDial]", ["scSpeedDial"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, ["actions"], never, true, never>;
 }
 
-declare class ScSpeedDialAction {
-    readonly icon: _angular_core.InputSignal<Type<unknown>>;
-    readonly label: _angular_core.InputSignal<string>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    readonly showLabel: _angular_core.InputSignal<boolean>;
-    readonly labelVisible: _angular_core.InputSignal<boolean>;
-    readonly size: _angular_core.InputSignal<"sm" | "lg" | "md">;
-    readonly class: _angular_core.InputSignal<string>;
-    readonly actionClick: _angular_core.OutputEmitterRef<void>;
-    protected readonly buttonClass: _angular_core.Signal<string>;
-    protected readonly iconClass: _angular_core.Signal<string>;
-    protected readonly labelClass: _angular_core.Signal<string>;
+declare class ScSpeedDialActionButton {
+    private readonly speedDial;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
     private sizeClasses;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpeedDialAction, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpeedDialAction, "sc-speed-dial-action", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "labelVisible": { "alias": "labelVisible"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "actionClick": "actionClick"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpeedDialActionButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpeedDialActionButton, "button[scSpeedDialActionButton]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScSpeedDialActionLabel {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpeedDialActionLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpeedDialActionLabel, "[scSpeedDialActionLabel]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScSpeedDialActionList {
+    readonly speedDial: _semantic_components_ui_lab.ScSpeedDial;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpeedDialActionList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpeedDialActionList, "[scSpeedDialActionList]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScSpeedDialTrigger {
+    readonly speedDial: _semantic_components_ui_lab.ScSpeedDial;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private sizeClasses;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpeedDialTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpeedDialTrigger, "button[scSpeedDialTrigger]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TargetRect$1 {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+declare class ScSpotlightState {
+    private readonly destroyRef;
+    readonly maskId: string;
+    onOpened: (() => void) | undefined;
+    onClosed: (() => void) | undefined;
+    readonly isActive: _angular_core.WritableSignal<boolean>;
+    readonly targetRect: _angular_core.WritableSignal<TargetRect$1 | null>;
+    private targetElement;
+    private resizeObserver;
+    readonly padding: _angular_core.WritableSignal<number>;
+    readonly borderRadius: _angular_core.WritableSignal<number>;
+    readonly overlayOpacity: _angular_core.WritableSignal<number>;
+    readonly animationDuration: _angular_core.WritableSignal<number>;
+    readonly showClose: _angular_core.WritableSignal<boolean>;
+    readonly closeOnOverlayClick: _angular_core.WritableSignal<boolean>;
+    readonly closeOnEscape: _angular_core.WritableSignal<boolean>;
+    readonly scrollIntoView: _angular_core.WritableSignal<boolean>;
+    readonly scrollBehavior: _angular_core.WritableSignal<ScrollBehavior>;
+    readonly contentPlacement: _angular_core.WritableSignal<"bottom" | "left" | "right" | "top" | "auto">;
+    readonly tooltipStyle: _angular_core.Signal<{
+        top?: undefined;
+        left?: undefined;
+        maxWidth?: undefined;
+    } | {
+        top: string;
+        left: string;
+        maxWidth: string;
+    }>;
+    constructor();
+    show(target: string | Element): void;
+    hide(): void;
+    toggle(target: string | Element): void;
+    close(): void;
+    updateTargetRect(): void;
+    private setupResizeObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScSpotlightState>;
 }
 
 interface SpotlightOptions {
@@ -2677,14 +3311,8 @@ interface SpotlightOptions {
     scrollIntoView?: boolean;
     scrollBehavior?: ScrollBehavior;
 }
-interface TargetRect$1 {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-}
 declare class ScSpotlight {
-    private readonly destroyRef;
+    readonly classInput: _angular_core.InputSignal<string>;
     readonly target: _angular_core.InputSignal<string | Element | null>;
     readonly padding: _angular_core.InputSignal<number>;
     readonly borderRadius: _angular_core.InputSignal<number>;
@@ -2696,58 +3324,81 @@ declare class ScSpotlight {
     readonly scrollIntoView: _angular_core.InputSignal<boolean>;
     readonly scrollBehavior: _angular_core.InputSignal<ScrollBehavior>;
     readonly contentPlacement: _angular_core.InputSignal<"bottom" | "left" | "right" | "top" | "auto">;
-    readonly class: _angular_core.InputSignal<string>;
     readonly opened: _angular_core.OutputEmitterRef<void>;
     readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly state: ScSpotlightState;
+    private readonly elementRef;
     readonly isActive: _angular_core.WritableSignal<boolean>;
     readonly targetRect: _angular_core.WritableSignal<TargetRect$1 | null>;
-    private targetElement;
-    private resizeObserver;
-    private readonly container;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly highlightClass: _angular_core.Signal<string>;
-    protected readonly contentClass: _angular_core.Signal<string>;
-    protected readonly contentStyle: _angular_core.Signal<{
-        top?: undefined;
-        left?: undefined;
-        maxWidth?: undefined;
-    } | {
-        top: string;
-        left: string;
-        maxWidth: string;
-    }>;
+    protected readonly class: _angular_core.Signal<string>;
     constructor();
     show(target: string | Element): void;
     hide(): void;
     toggle(target: string | Element): void;
-    updateTargetRect(): void;
-    private setupResizeObserver;
+    close(): void;
     protected onOverlayClick(event: MouseEvent): void;
     protected onKeydown(event: KeyboardEvent): void;
-    close(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlight, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpotlight, "sc-spotlight", never, { "target": { "alias": "target"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "overlayOpacity": { "alias": "overlayOpacity"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "closeOnOverlayClick": { "alias": "closeOnOverlayClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "scrollIntoView": { "alias": "scrollIntoView"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; "contentPlacement": { "alias": "contentPlacement"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpotlight, "div[scSpotlight]", ["scSpotlight"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "overlayOpacity": { "alias": "overlayOpacity"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "closeOnOverlayClick": { "alias": "closeOnOverlayClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "scrollIntoView": { "alias": "scrollIntoView"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; "contentPlacement": { "alias": "contentPlacement"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class ScSpotlightMask {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScSpotlightState;
+    protected readonly overlayFill: _angular_core.Signal<string>;
+    protected readonly maskUrl: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightMask, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpotlightMask, "svg[scSpotlightMask]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScSpotlightHighlight {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScSpotlightState;
+    protected readonly top: _angular_core.Signal<number>;
+    protected readonly left: _angular_core.Signal<number>;
+    protected readonly width: _angular_core.Signal<number>;
+    protected readonly height: _angular_core.Signal<number>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightHighlight, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpotlightHighlight, "div[scSpotlightHighlight]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScSpotlightClose {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScSpotlightState;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightClose, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpotlightClose, "button[scSpotlightClose]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScSpotlightTooltip {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScSpotlightState;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpotlightTooltip, "div[scSpotlightTooltip]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSpotlightTitle {
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly computedClass: _angular_core.Signal<string>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightTitle, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpotlightTitle, "sc-spotlight-title", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpotlightTitle, "[scSpotlightTitle]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSpotlightDescription {
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly computedClass: _angular_core.Signal<string>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightDescription, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpotlightDescription, "sc-spotlight-description", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpotlightDescription, "[scSpotlightDescription]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScSpotlightActions {
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly computedClass: _angular_core.Signal<string>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSpotlightActions, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSpotlightActions, "sc-spotlight-actions", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSpotlightActions, "[scSpotlightActions]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type StatCardTrend = 'up' | 'down' | 'neutral';
@@ -2804,7 +3455,7 @@ declare class ScStatCardDescription {
 
 declare class ScStepper {
     readonly classInput: _angular_core.InputSignal<string>;
-    readonly orientation: _angular_core.InputSignal<StepperOrientation>;
+    readonly orientation: _angular_core.InputSignal<ScStepperOrientation>;
     readonly activeStep: _angular_core.ModelSignal<number>;
     protected readonly class: _angular_core.Signal<string>;
     goToStep(step: number): void;
@@ -2823,12 +3474,23 @@ declare class ScStepperItem {
     readonly state: _angular_core.Signal<"complete" | "active" | "inactive">;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepperItem, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperItem, "[scStepperItem]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperItem, "[scStepperItem]", ["scStepperItem"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScStepperPanel {
+    private readonly stepper;
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly isActive: _angular_core.Signal<boolean>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepperPanel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperPanel, "[scStepperPanel]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type StepperOrientation = 'horizontal' | 'vertical';
+type ScStepperOrientation = 'horizontal' | 'vertical';
 declare const SC_STEPPER: InjectionToken<ScStepper>;
 declare const SC_STEPPER_ITEM: InjectionToken<ScStepperItem>;
+declare const SC_STEPPER_PANEL: InjectionToken<ScStepperPanel>;
 
 declare class ScStepperList {
     private readonly stepper;
@@ -2845,27 +3507,27 @@ declare class ScStepperTrigger {
     protected readonly class: _angular_core.Signal<string>;
     onClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepperTrigger, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScStepperTrigger, "button[scStepperTrigger]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperTrigger, "button[scStepperTrigger]", ["scStepperTrigger"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScStepperSeparator {
     private readonly stepper;
     private readonly stepperItem;
     readonly classInput: _angular_core.InputSignal<string>;
+    readonly step: _angular_core.InputSignal<number | undefined>;
     protected readonly state: _angular_core.Signal<"complete" | "inactive">;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepperSeparator, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperSeparator, "[scStepperSeparator]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperSeparator, "[scStepperSeparator]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScStepperContent {
-    private readonly stepper;
-    readonly classInput: _angular_core.InputSignal<string>;
-    readonly step: _angular_core.InputSignal<number>;
-    protected readonly isActive: _angular_core.Signal<boolean>;
-    protected readonly class: _angular_core.Signal<string>;
+    private readonly panel;
+    private readonly templateRef;
+    private readonly viewContainerRef;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepperContent, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperContent, "[scStepperContent]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperContent, "ng-template[scStepperContent]", never, {}, {}, never, never, true, never>;
 }
 
 declare class ScStepperTitle {
@@ -2887,7 +3549,7 @@ declare class ScStepperPrevious {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepperPrevious, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScStepperPrevious, "button[scStepperPrevious]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperPrevious, "button[scStepperPrevious]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScStepperNext {
@@ -2895,11 +3557,11 @@ declare class ScStepperNext {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepperNext, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScStepperNext, "button[scStepperNext]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScStepperNext, "button[scStepperNext]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare const SC_TAG_INPUT: InjectionToken<ScTagInput>;
-declare class ScTagInput {
+declare const SC_TAGS_INPUT: InjectionToken<ScTagsInput>;
+declare class ScTagsInput {
     readonly classInput: _angular_core.InputSignal<string>;
     readonly tags: _angular_core.ModelSignal<string[]>;
     readonly placeholder: _angular_core.InputSignal<string>;
@@ -2913,63 +3575,91 @@ declare class ScTagInput {
     readonly tagRemove: _angular_core.OutputEmitterRef<string>;
     readonly isFocused: _angular_core.WritableSignal<boolean>;
     readonly inputValue: _angular_core.WritableSignal<string>;
-    private inputRef;
+    readonly focusedTagIndex: _angular_core.WritableSignal<number>;
+    private readonly inputRef;
     protected readonly class: _angular_core.Signal<string>;
     readonly canAddMore: _angular_core.Signal<boolean>;
     setInputRef(ref: ElementRef<HTMLInputElement>): void;
     focusInput(): void;
+    focusTag(index: number): void;
     addTag(value: string): boolean;
     removeTag(tag: string): void;
     removeTagAtIndex(index: number): void;
     removeLastTag(): void;
     clearAll(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagInput, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTagInput, "[scTagInput]", ["scTagInput"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "tags": { "alias": "tags"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "maxTags": { "alias": "maxTags"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "delimiters": { "alias": "delimiters"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, { "tags": "tagsChange"; "tagAdd": "tagAdd"; "tagRemove": "tagRemove"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagsInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTagsInput, "[scTagsInput]", ["scTagsInput"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "tags": { "alias": "tags"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "maxTags": { "alias": "maxTags"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "delimiters": { "alias": "delimiters"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, { "tags": "tagsChange"; "tagAdd": "tagAdd"; "tagRemove": "tagRemove"; }, never, never, true, never>;
 }
 
-declare class ScTagInputField {
-    readonly tagInput: _semantic_components_ui_lab.ScTagInput;
+declare class ScTagsInputControl {
+    readonly tagsInput: _semantic_components_ui_lab.ScTagsInput;
+    private readonly field;
     private readonly elementRef;
+    private readonly fallbackId;
     readonly classInput: _angular_core.InputSignal<string>;
+    readonly idInput: _angular_core.InputSignal<string>;
     readonly addOnBlur: _angular_core.InputSignal<boolean>;
+    readonly id: _angular_core.Signal<string>;
+    readonly ariaDescribedBy: _angular_core.Signal<string | null>;
+    protected readonly displayValue: _angular_core.Signal<string>;
     protected readonly class: _angular_core.Signal<string>;
     constructor();
     onInput(event: Event): void;
+    onFocus(): void;
     onKeydown(event: KeyboardEvent): void;
     onBlur(): void;
     onPaste(event: ClipboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagInputField, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTagInputField, "input[scTagInputField]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagsInputControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTagsInputControl, "input[scTagsInputControl]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ScTagInputTag {
-    readonly tagInput: _semantic_components_ui_lab.ScTagInput;
+declare const SC_TAGS_INPUT_ITEM: InjectionToken<ScTagsInputItem>;
+declare class ScTagsInputItem {
+    private readonly elementRef;
+    private readonly tagsInput;
     readonly classInput: _angular_core.InputSignal<string>;
     readonly tag: _angular_core.InputSignal<string>;
+    readonly index: _angular_core.InputSignal<number>;
     readonly variant: _angular_core.InputSignal<"default" | "outline" | "secondary">;
+    protected readonly isFocused: _angular_core.Signal<boolean>;
+    protected readonly tabIndex: _angular_core.Signal<0 | -1>;
     protected readonly class: _angular_core.Signal<string>;
-    remove(event: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagInputTag, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTagInputTag, "[scTagInputTag]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "tag": { "alias": "tag"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    constructor();
+    protected onFocus(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagsInputItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTagsInputItem, "[scTagsInputItem]", ["scTagsInputItem"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "tag": { "alias": "tag"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTagsInputItemDelete {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly tagsInput;
+    private readonly tagRef;
+    protected readonly isDisabled: _angular_core.InputSignal<boolean>;
+    protected readonly ariaLabel: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagsInputItemDelete, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTagsInputItemDelete, "button[scTagsInputItemDelete]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ScTagInputClear {
-    readonly tagInput: _semantic_components_ui_lab.ScTagInput;
+declare class ScTagsInputClear {
+    readonly tagsInput: _semantic_components_ui_lab.ScTagsInput;
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     onClick(event: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagInputClear, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTagInputClear, "button[scTagInputClear]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagsInputClear, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTagsInputClear, "button[scTagsInputClear]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class ScTagInputCount {
-    readonly tagInput: _semantic_components_ui_lab.ScTagInput;
+declare class ScTagsInputCount {
+    readonly tagsInput: _semantic_components_ui_lab.ScTagsInput;
     readonly classInput: _angular_core.InputSignal<string>;
     readonly showMax: _angular_core.InputSignal<boolean>;
     protected readonly class: _angular_core.Signal<string>;
-    protected readonly maxText: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagInputCount, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTagInputCount, "[scTagInputCount]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "showMax": { "alias": "showMax"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    protected readonly countText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTagsInputCount, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTagsInputCount, "[scTagsInputCount]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "showMax": { "alias": "showMax"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScTimePickerClock {
@@ -3026,7 +3716,7 @@ declare class ScTimelineConnector {
 
 declare class ScTimelineDot {
     readonly classInput: _angular_core.InputSignal<string>;
-    readonly variant: _angular_core.InputSignal<"default" | "outline" | "error" | "warning" | "success">;
+    readonly variant: _angular_core.InputSignal<"default" | "outline" | "error" | "success" | "warning">;
     readonly size: _angular_core.InputSignal<"default" | "sm" | "lg">;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTimelineDot, never>;
@@ -3088,6 +3778,162 @@ interface TargetRect {
     width: number;
     height: number;
 }
+
+declare class ScTourGuideState {
+    private readonly tourService;
+    onStepChange: ((step: number) => void) | undefined;
+    onTourComplete: (() => void) | undefined;
+    onTourClosed: (() => void) | undefined;
+    readonly targetRect: _angular_core.WritableSignal<TargetRect | null>;
+    readonly isActive: _angular_core.Signal<boolean>;
+    readonly currentStep: _angular_core.Signal<_semantic_components_ui_lab.TourStep>;
+    readonly currentStepIndex: _angular_core.Signal<number>;
+    readonly totalSteps: _angular_core.Signal<number>;
+    readonly progress: _angular_core.Signal<number>;
+    readonly isFirstStep: _angular_core.Signal<boolean>;
+    readonly isLastStep: _angular_core.Signal<boolean>;
+    readonly overlayOpacity: _angular_core.Signal<number>;
+    readonly highlightPadding: _angular_core.Signal<number>;
+    readonly showProgress: _angular_core.Signal<boolean>;
+    readonly showStepNumbers: _angular_core.Signal<boolean>;
+    readonly allowClose: _angular_core.Signal<boolean>;
+    readonly allowKeyboard: _angular_core.Signal<boolean>;
+    readonly tooltipStyle: _angular_core.Signal<{
+        top?: undefined;
+        left?: undefined;
+    } | {
+        top: string;
+        left: string;
+    }>;
+    updateTargetRect(): void;
+    next(): void;
+    previous(): void;
+    finish(): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScTourGuideState>;
+}
+
+declare class ScTourGuide implements DoCheck {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly state: ScTourGuideState;
+    private readonly tourService;
+    readonly stepChange: _angular_core.OutputEmitterRef<number>;
+    readonly tourComplete: _angular_core.OutputEmitterRef<void>;
+    readonly tourClosed: _angular_core.OutputEmitterRef<void>;
+    readonly targetRect: _angular_core.WritableSignal<_semantic_components_ui_lab.TargetRect | null>;
+    readonly currentStep: _angular_core.Signal<_semantic_components_ui_lab.TourStep>;
+    readonly allowClose: _angular_core.Signal<boolean>;
+    readonly showStepNumbers: _angular_core.Signal<boolean>;
+    readonly showProgress: _angular_core.Signal<boolean>;
+    readonly isFirstStep: _angular_core.Signal<boolean>;
+    readonly isLastStep: _angular_core.Signal<boolean>;
+    protected readonly class: _angular_core.Signal<string>;
+    constructor();
+    ngDoCheck(): void;
+    protected onOverlayClick(event: MouseEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuide, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuide, "div[scTourGuide]", ["scTourGuide"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, { "stepChange": "stepChange"; "tourComplete": "tourComplete"; "tourClosed": "tourClosed"; }, never, never, true, never>;
+}
+
+declare class ScTourGuideMask {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScTourGuideState;
+    protected readonly overlayFill: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideMask, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTourGuideMask, "svg[scTourGuideMask]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideHighlight {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly state;
+    private readonly padding;
+    protected readonly top: _angular_core.Signal<number>;
+    protected readonly left: _angular_core.Signal<number>;
+    protected readonly width: _angular_core.Signal<number>;
+    protected readonly height: _angular_core.Signal<number>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideHighlight, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTourGuideHighlight, "div[scTourGuideHighlight]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideTooltip {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScTourGuideState;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideTooltip, "div[scTourGuideTooltip]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideClose {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScTourGuideState;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideClose, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideClose, "button[scTourGuideClose]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideStepNumber {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly state;
+    protected readonly stepNumber: _angular_core.Signal<number>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideStepNumber, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideStepNumber, "[scTourGuideStepNumber]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideTitle {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScTourGuideState;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideTitle, "h3[scTourGuideTitle]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideDescription {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScTourGuideState;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideDescription, "p[scTourGuideDescription]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideProgress {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScTourGuideState;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTourGuideProgress, "div[scTourGuideProgress]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideNavigation {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideNavigation, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideNavigation, "div[scTourGuideNavigation]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideCounter {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly state;
+    protected readonly counterText: _angular_core.Signal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideCounter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideCounter, "[scTourGuideCounter]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTourGuideAction {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly action: _angular_core.InputSignal<"next" | "previous" | "finish">;
+    private readonly state;
+    protected readonly class: _angular_core.Signal<string>;
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuideAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTourGuideAction, "button[scTourGuideAction]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare class TourService {
     private readonly _isActive;
     private readonly _currentStep;
@@ -3109,41 +3955,6 @@ declare class TourService {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TourService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<TourService>;
 }
-declare class ScTourGuide implements DoCheck {
-    readonly tourService: TourService;
-    private readonly destroyRef;
-    readonly stepChange: _angular_core.OutputEmitterRef<number>;
-    readonly tourComplete: _angular_core.OutputEmitterRef<void>;
-    readonly tourClosed: _angular_core.OutputEmitterRef<void>;
-    readonly targetRect: _angular_core.WritableSignal<TargetRect | null>;
-    private resizeObserver;
-    protected readonly currentStep: _angular_core.Signal<TourStep>;
-    protected readonly overlayOpacity: _angular_core.Signal<number>;
-    protected readonly highlightPadding: _angular_core.Signal<number>;
-    protected readonly showProgress: _angular_core.Signal<boolean>;
-    protected readonly showStepNumbers: _angular_core.Signal<boolean>;
-    protected readonly allowClose: _angular_core.Signal<boolean>;
-    protected readonly overlayClass: _angular_core.Signal<string>;
-    protected readonly tooltipClass: _angular_core.Signal<string>;
-    protected readonly tooltipStyle: _angular_core.Signal<{
-        top?: undefined;
-        left?: undefined;
-    } | {
-        top: string;
-        left: string;
-    }>;
-    constructor();
-    ngDoCheck(): void;
-    updateTargetRect(): void;
-    protected onOverlayClick(event: MouseEvent): void;
-    protected onKeydown(event: KeyboardEvent): void;
-    next(): void;
-    previous(): void;
-    finish(): void;
-    close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTourGuide, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTourGuide, "sc-tour-guide", never, {}, { "stepChange": "stepChange"; "tourComplete": "tourComplete"; "tourClosed": "tourClosed"; }, never, never, true, never>;
-}
 
 interface TransferListItem {
     id: string;
@@ -3157,44 +3968,149 @@ interface TransferListState {
 }
 
 declare class ScTransferList {
+    readonly classInput: _angular_core.InputSignal<string>;
     readonly sourceItems: _angular_core.ModelSignal<TransferListItem[]>;
     readonly targetItems: _angular_core.ModelSignal<TransferListItem[]>;
-    readonly sourceTitle: _angular_core.InputSignal<string>;
-    readonly targetTitle: _angular_core.InputSignal<string>;
-    readonly searchable: _angular_core.InputSignal<boolean>;
-    readonly height: _angular_core.InputSignal<string>;
-    readonly class: _angular_core.InputSignal<string>;
-    readonly change: _angular_core.OutputEmitterRef<{
-        source: TransferListItem[];
-        target: TransferListItem[];
-    }>;
-    protected readonly selectedSourceIds: _angular_core.WritableSignal<Set<string>>;
-    protected readonly selectedTargetIds: _angular_core.WritableSignal<Set<string>>;
-    protected readonly sourceSearch: _angular_core.WritableSignal<string>;
-    protected readonly targetSearch: _angular_core.WritableSignal<string>;
-    protected readonly filteredSourceItems: _angular_core.Signal<TransferListItem[]>;
-    protected readonly filteredTargetItems: _angular_core.Signal<TransferListItem[]>;
-    protected readonly allSourceSelected: _angular_core.Signal<boolean>;
-    protected readonly someSourceSelected: _angular_core.Signal<boolean>;
-    protected readonly allTargetSelected: _angular_core.Signal<boolean>;
-    protected readonly someTargetSelected: _angular_core.Signal<boolean>;
-    protected readonly containerClass: _angular_core.Signal<string>;
-    protected readonly listContainerClass: _angular_core.Signal<string>;
-    protected readonly listHeaderClass: _angular_core.Signal<string>;
-    protected readonly listClass: _angular_core.Signal<string>;
-    protected itemClass(item: TransferListItem, selected: boolean): string;
-    protected readonly buttonClass: _angular_core.Signal<string>;
-    toggleSourceItem(item: TransferListItem): void;
-    toggleTargetItem(item: TransferListItem): void;
-    toggleAllSource(): void;
-    toggleAllTarget(): void;
+    readonly transferChange: _angular_core.OutputEmitterRef<TransferListState>;
+    private readonly state;
+    protected readonly class: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferList, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTransferList, "div[scTransferList]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "sourceItems": { "alias": "sourceItems"; "required": false; "isSignal": true; }; "targetItems": { "alias": "targetItems"; "required": false; "isSignal": true; }; }, { "sourceItems": "sourceItemsChange"; "targetItems": "targetItemsChange"; "transferChange": "transferChange"; }, never, never, true, never>;
+}
+
+declare class ScTransferListState {
+    sourceItems: WritableSignal<TransferListItem[]>;
+    targetItems: WritableSignal<TransferListItem[]>;
+    onTransfer: (() => void) | undefined;
+    readonly selectedSourceIds: WritableSignal<Set<string>>;
+    readonly selectedTargetIds: WritableSignal<Set<string>>;
+    readonly sourceSearch: WritableSignal<string>;
+    readonly targetSearch: WritableSignal<string>;
+    readonly filteredSourceItems: _angular_core.Signal<TransferListItem[]>;
+    readonly filteredTargetItems: _angular_core.Signal<TransferListItem[]>;
+    readonly allSourceSelected: _angular_core.Signal<boolean>;
+    readonly someSourceSelected: _angular_core.Signal<boolean>;
+    readonly allTargetSelected: _angular_core.Signal<boolean>;
+    readonly someTargetSelected: _angular_core.Signal<boolean>;
+    toggleItem(side: 'source' | 'target', item: TransferListItem): void;
+    toggleAll(side: 'source' | 'target'): void;
     moveToTarget(): void;
     moveToSource(): void;
     moveAllToTarget(): void;
     moveAllToSource(): void;
-    private emitChange;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferList, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTransferList, "sc-transfer-list", never, { "sourceItems": { "alias": "sourceItems"; "required": false; "isSignal": true; }; "targetItems": { "alias": "targetItems"; "required": false; "isSignal": true; }; "sourceTitle": { "alias": "sourceTitle"; "required": false; "isSignal": true; }; "targetTitle": { "alias": "targetTitle"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "sourceItems": "sourceItemsChange"; "targetItems": "targetItemsChange"; "change": "change"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScTransferListState>;
+}
+
+declare class ScTransferListActions {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly state: ScTransferListState;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly buttonClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListActions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTransferListActions, "div[scTransferListActions]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTransferListCount {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly panel;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly countText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListCount, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTransferListCount, "[scTransferListCount]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTransferListHeader {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTransferListHeader, "div[scTransferListHeader]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTransferListItem {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly item: _angular_core.InputSignal<TransferListItem>;
+    private readonly panel;
+    protected readonly isSelected: _angular_core.Signal<boolean>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTransferListItem, "label[scTransferListItem]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTransferListItems {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListItems, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTransferListItems, "div[scTransferListItems]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface ScTransferListPanelRef {
+    readonly filteredItems: Signal<TransferListItem[]>;
+    readonly selectedIds: Signal<Set<string>>;
+    readonly allSelected: Signal<boolean>;
+    readonly someSelected: Signal<boolean>;
+    readonly selectedCount: Signal<number>;
+    readonly totalCount: Signal<number>;
+    readonly searchValue: Signal<string>;
+    toggleAll(): void;
+    toggleItem(item: TransferListItem): void;
+    onSearchInput(value: string): void;
+}
+
+declare class ScTransferListSearch {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly panel: ScTransferListPanelRef;
+    protected readonly class: _angular_core.Signal<string>;
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListSearch, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTransferListSearch, "input[scTransferListSearch]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTransferListSelectAll {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly panel: ScTransferListPanelRef;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListSelectAll, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTransferListSelectAll, "label[scTransferListSelectAll]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTransferListSource implements ScTransferListPanelRef {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly state;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly filteredItems: _angular_core.Signal<TransferListItem[]>;
+    readonly selectedIds: _angular_core.Signal<Set<string>>;
+    readonly allSelected: _angular_core.Signal<boolean>;
+    readonly someSelected: _angular_core.Signal<boolean>;
+    readonly selectedCount: _angular_core.Signal<number>;
+    readonly totalCount: _angular_core.Signal<number>;
+    readonly searchValue: _angular_core.Signal<string>;
+    toggleAll(): void;
+    toggleItem(item: TransferListItem): void;
+    onSearchInput(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListSource, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTransferListSource, "div[scTransferListSource]", ["scTransferListSource"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTransferListTarget implements ScTransferListPanelRef {
+    readonly classInput: _angular_core.InputSignal<string>;
+    private readonly state;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly filteredItems: _angular_core.Signal<TransferListItem[]>;
+    readonly selectedIds: _angular_core.Signal<Set<string>>;
+    readonly allSelected: _angular_core.Signal<boolean>;
+    readonly someSelected: _angular_core.Signal<boolean>;
+    readonly selectedCount: _angular_core.Signal<number>;
+    readonly totalCount: _angular_core.Signal<number>;
+    readonly searchValue: _angular_core.Signal<string>;
+    toggleAll(): void;
+    toggleItem(item: TransferListItem): void;
+    onSearchInput(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTransferListTarget, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTransferListTarget, "div[scTransferListTarget]", ["scTransferListTarget"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class ScTree {
@@ -3202,7 +4118,7 @@ declare class ScTree {
     readonly classInput: _angular_core.InputSignal<string>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTree, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTree, "ul[scTree]", ["scTree"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.Tree; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTree, "ul[scTree]", ["scTree"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$3.Tree; inputs: {}; outputs: {}; }]>;
 }
 
 declare class ScTreeItemTrigger {
@@ -3241,7 +4157,7 @@ declare class ScTreeItem {
     readonly hasChildren: _angular_core.Signal<boolean>;
     protected readonly class: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTreeItem, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTreeItem, "li[scTreeItem]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["groupContent"], ["*"], true, [{ directive: typeof i1$2.TreeItem; inputs: { "value": "value"; "parent": "parent"; "label": "label"; "disabled": "disabled"; "expanded": "expanded"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTreeItem, "li[scTreeItem]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["groupContent"], ["*"], true, [{ directive: typeof i1$3.TreeItem; inputs: { "value": "value"; "parent": "parent"; "label": "label"; "disabled": "disabled"; "expanded": "expanded"; }; outputs: {}; }]>;
 }
 
 declare class ScTreeItemIcon {
@@ -3575,5 +4491,139 @@ declare class ScButtonPattern {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScButtonPattern, "[scButtonPattern]", never, { "enabled": { "alias": "scButtonPattern"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { AuthLayout, DEFAULT_BREAKPOINTS, DEFAULT_CATEGORIES, DEFAULT_CONFIG, DEFAULT_COUNTER_OPTIONS, DEFAULT_DOCK_OPTIONS, DEFAULT_TOOLBAR_CONFIG, SC_AUDIO_PLAYER, SC_BARCODE_SCANNER, SC_COLOR_PICKER, SC_COUNTDOWN, SC_DATA_TABLE, SC_IMAGE_COMPARE, SC_IMAGE_CROPPER, SC_INFINITE_SCROLL, SC_KANBAN_BOARD, SC_LANGUAGE_CONFIG, SC_LIGHTBOX_PROVIDER, SC_NOTIFICATION_CENTER, SC_PDF_VIEWER, SC_SIGNATURE_PAD, SC_STEPPER, SC_STEPPER_ITEM, SC_TAG_INPUT, SC_TREE_ITEM, ScAnimatedCounter, ScAudioPlayer, ScAudioPlayerControls, ScAudioPlayerCover, ScAudioPlayerNext, ScAudioPlayerPlay, ScAudioPlayerPrevious, ScAudioPlayerProgress, ScAudioPlayerRepeat, ScAudioPlayerShuffle, ScAudioPlayerTrackInfo, ScAudioPlayerVolume, ScBarcodeScanner, ScBarcodeVideo, ScButtonPattern, ScColorPicker, ScColorPickerArea, ScColorPickerEyeDropper, ScColorPickerHue, ScColorPickerInput, ScColorPickerPreview, ScColorPickerSwatches, ScCountdown, ScDataTable, ScDataTableBody, ScDataTableCell, ScDataTableColumnToggle, ScDataTableFilter, ScDataTableHead, ScDataTableHeader, ScDataTablePagination, ScDataTableRow, ScDateRangePicker, ScDiffViewer, ScDock, ScDockBadge, ScDockItem, ScDockItems, ScEmojiPicker, ScEmojiPickerCategoryTabs, ScEmojiPickerEmpty, ScEmojiPickerGrid, ScEmojiPickerItem, ScEmojiPickerRecent, ScEmojiPickerSearch, ScEmojiPickerState, ScEmojiPickerTrigger, ScImageAnnotator, ScImageCompare, ScImageCompareAfter, ScImageCompareArea, ScImageCompareBefore, ScImageCompareLabel, ScImageCompareSlider, ScImageCropper, ScImageCropperAspectRatio, ScImageCropperCanvas, ScImageCropperDragRegion, ScImageCropperFileInput, ScImageCropperFlipH, ScImageCropperFlipV, ScImageCropperGrid, ScImageCropperHandle, ScImageCropperImage, ScImageCropperOverlay, ScImageCropperPreview, ScImageCropperReset, ScImageCropperRotateLeft, ScImageCropperRotateRight, ScImageCropperSelection, ScImageCropperZoomIn, ScImageCropperZoomOut, ScImageCropperZoomSlider, ScInfiniteScroll, ScInfiniteScrollEnd, ScInfiniteScrollLoader, ScKanbanBoard, ScKanbanCard, ScKanbanColumn, ScLanguageButton, ScLanguageSelect, ScLanguageService, ScLanguageToggle, ScLightbox, ScLightboxClose, ScLightboxCounter, ScLightboxGallery, ScLightboxGalleryItem, ScLightboxImage, ScLightboxNext, ScLightboxPortal, ScLightboxPrev, ScLightboxProvider, ScLightboxThumbnail, ScLightboxThumbnailBar, ScLightboxToolbar, ScLightboxTrigger, ScLightboxZoomControls, ScLightboxZoomIn, ScLightboxZoomOut, ScLightboxZoomReset, ScMarquee, ScMarqueeContent, ScMarqueeFade, ScMarqueeItem, ScMarqueeText, ScMasonryGrid, ScMasonryItem, ScMentionInput, ScNativeDialog, ScNativeDialogBody, ScNativeDialogClose, ScNativeDialogContent, ScNativeDialogDescription, ScNativeDialogFooter, ScNativeDialogHeader, ScNativeDialogProvider, ScNativeDialogTitle, ScNativeDialogTrigger, ScNavbar, ScNavbarActions, ScNavbarBrand, ScNavbarGroup, ScNavbarMobileLink, ScNavbarMobileMenu, ScNavbarMobilePortal, ScNavbarMobileTrigger, ScNavbarProvider, ScNotificationCenter, ScNotificationCenterContainer, ScNotificationGroup, ScNotificationItem, ScOrgChart, ScOrgChartNode, ScPdfViewer, ScPdfViewerContainer, ScPdfViewerContent, ScPdfViewerDownload, ScPdfViewerEmpty, ScPdfViewerError, ScPdfViewerFullscreen, ScPdfViewerLoading, ScPdfViewerNav, ScPdfViewerNextPage, ScPdfViewerPageInfo, ScPdfViewerPrevPage, ScPdfViewerPrint, ScPdfViewerRetry, ScPdfViewerRoot, ScPdfViewerRotateLeft, ScPdfViewerRotateRight, ScPdfViewerSeparator, ScPdfViewerSpacer, ScPdfViewerToolbar$1 as ScPdfViewerToolbar, ScPdfViewerToolbar as ScPdfViewerToolbarLegacy, ScPdfViewerZoom, ScPdfViewerZoomIn, ScPdfViewerZoomOut, ScPdfViewerZoomSelect, ScQrCode, ScQrCodeDownload, ScSidebarLayout, ScSignaturePad, ScSignaturePadCanvas, ScSignaturePadClearButton, ScSignaturePadColorButton, ScSignaturePadControls, ScSignaturePadToolbar, ScSignaturePadUndoButton, ScSignaturePadWidthButton, ScSpeedDial, ScSpeedDialAction, ScSpotlight, ScSpotlightActions, ScSpotlightDescription, ScSpotlightTitle, ScStackedLayout, ScStatCard, ScStatCardChange, ScStatCardDescription, ScStatCardIcon, ScStatCardLabel, ScStatCardValue, ScStepper, ScStepperContent, ScStepperDescription, ScStepperItem, ScStepperList, ScStepperNext, ScStepperPrevious, ScStepperSeparator, ScStepperTitle, ScStepperTrigger, ScTagInput, ScTagInputClear, ScTagInputCount, ScTagInputField, ScTagInputTag, ScTimePickerClock, ScTimeline, ScTimelineConnector, ScTimelineContent, ScTimelineDescription, ScTimelineDot, ScTimelineItem, ScTimelineTime, ScTimelineTitle, ScTourGuide, ScTransferList, ScTree, ScTreeItem, ScTreeItemGroup, ScTreeItemIcon, ScTreeItemTrigger, ScTreeItemTriggerIcon, ScVideoPlayer, ScVideoPlayerBigPlay, ScVideoPlayerBufferingIndicator, ScVideoPlayerControls, ScVideoPlayerFullscreen, ScVideoPlayerPip, ScVideoPlayerPlayPause, ScVideoPlayerProgress, ScVideoPlayerSkip, ScVideoPlayerSpacer, ScVideoPlayerSpeed, ScVideoPlayerTime, ScVideoPlayerToolbar, ScVideoPlayerVideo, ScVideoPlayerVolume, TourService, ZOOM_LEVELS, computeDiff, computeWordDiff, createScDateRangePresets, createUnifiedDiff };
-export type { AnimatedCounterEasing, AnimatedCounterOptions, Annotation, AnnotationPoint, AnnotationTool, BarcodeFormat, BarcodeResult, ColumnDef, ColumnVisibilityState, CountdownTime, DiffLine, DiffOptions, DiffResult, DiffViewMode, DockItem, DockOptions, DockPosition, DockSize, Emoji, EmojiCategory, HSL, HSV, ImageAnnotatorState, KanbanAssignee, KanbanCard, KanbanCardAddEvent, KanbanCardDeleteEvent, KanbanColumn, KanbanDragEvent, KanbanLabel, Language, LanguageConfig, MasonryBreakpoint, MasonryConfig, MasonryLayoutMode, MentionUser, Notification, NotificationAction, NotificationActionEvent, NotificationDismissEvent, NotificationFilter, NotificationGroup, NotificationGroupCollapseEvent, NotificationMarkReadEvent, NotificationType, OrgChartDirection, OrgChartNode, OrgChartNodeClickEvent, OrgChartNodeExpandEvent, PdfErrorEvent, PdfLoadEvent, PdfPageChangeEvent, PdfToolbarConfig, PdfZoomChangeEvent, PdfZoomLevel, QRErrorCorrectionLevel, RGB, ScAudioTrack, ScDateRangePreset, ScImageCropperArea, ScImageCropperHandlePosition, ScImageCropperResult, ScLightboxImageData, ScNotificationCenterApi, ScSignatureLine, ScSignaturePoint, ScVideoSource, ScVideoTrack, SortDirection, SortingState, SpeedDialAction, SpeedDialActionClickEvent, SpeedDialDirection, SpotlightOptions, StatCardSize, StatCardTrend, StatCardVariant, StepperOrientation, TourOptions, TourStep, TransferListItem, TransferListState };
+interface Parser<T> {
+    parse(raw: string): T | null;
+    serialize(value: T): string;
+}
+interface QueryParamOptions {
+    /** 'replace' (default) or 'push' — controls browser history behaviour */
+    history?: 'replace' | 'push';
+}
+interface ParserBuilder<T> extends Parser<T> {
+    withDefault(defaultValue: T): ParserBuilderWithDefault<T>;
+    withOptions(opts: QueryParamOptions): ParserBuilder<T>;
+    _options?: QueryParamOptions;
+    _default?: undefined;
+}
+interface ParserBuilderWithDefault<T> extends Parser<T> {
+    withOptions(opts: QueryParamOptions): ParserBuilderWithDefault<T>;
+    _options?: QueryParamOptions;
+    _default: T;
+}
+interface QueryParamState<T> {
+    /** Signal holding the current parsed value (or default / null). */
+    value: WritableSignal<T>;
+    /**
+     * Set the query param.
+     * Pass `null` to remove the key from the URL entirely.
+     */
+    set(value: T | null): void;
+    /** Remove the param from the URL (same as set(null)). */
+    clear(): void;
+}
+
+declare function createParser<T>(parse: (raw: string) => T | null, serialize: (value: T) => string, opts?: QueryParamOptions): ParserBuilder<T>;
+
+/** Stores a plain string value. */
+declare const parseAsString: ParserBuilder<string>;
+/** Parses to a JavaScript integer (base-10). */
+declare const parseAsInteger: ParserBuilder<number>;
+/** Parses to a JavaScript float. */
+declare const parseAsFloat: ParserBuilder<number>;
+/** Parses 'true' / 'false' strings to booleans. */
+declare const parseAsBoolean: ParserBuilder<boolean>;
+/**
+ * Parses an ISO-8601 date-time string (e.g. 2024-03-01T12:00:00.000Z).
+ * Serialises back with `.toISOString()`.
+ */
+declare const parseAsIsoDateTime: ParserBuilder<Date>;
+/**
+ * Parses an ISO-8601 date string (e.g. 2024-03-01).
+ * Time is set to 00:00:00 UTC.
+ */
+declare const parseAsIsoDate: ParserBuilder<Date>;
+/** Parses milliseconds since Unix epoch. */
+declare const parseAsTimestamp: ParserBuilder<Date>;
+/**
+ * Parses a JSON-encoded value.
+ * Pass a validator/reviver if you want runtime validation (e.g. Zod).
+ *
+ * @example
+ * const parseAsFilter = parseAsJson<{ active: boolean }>();
+ * const filter = injectQueryParam('filter', parseAsFilter.withDefault({ active: false }));
+ */
+declare function parseAsJson<T>(validate?: (raw: unknown) => T): ParserBuilder<T>;
+/**
+ * Parses a comma-separated (or custom separator) list of values using another parser.
+ *
+ * @example
+ * const parseAsTags = parseAsArrayOf(parseAsString);
+ * const tags = injectQueryParam('tags', parseAsTags.withDefault([]));
+ */
+declare function parseAsArrayOf<T>(itemParser: Parser<T>, separator?: string): ParserBuilder<T[]>;
+/**
+ * Restricts a string param to a set of allowed enum values.
+ *
+ * @example
+ * const parseAsSort = parseAsStringEnum(['asc', 'desc'] as const);
+ * const sort = injectQueryParam('sort', parseAsSort.withDefault('asc'));
+ */
+declare function parseAsStringEnum<T extends string>(values: readonly T[]): ParserBuilder<T>;
+
+/**
+ * `injectQueryParam` — nuqs-style, signal-based URL query param hook for Angular.
+ *
+ * Must be called in an injection context (constructor, field initialiser, or
+ * inside `runInInjectionContext`).
+ *
+ * @example — no default (nullable)
+ * ```ts
+ * const name = injectQueryParam('name', parseAsString);
+ * name.value() // string | null
+ * name.set('Alice');
+ * name.clear(); // removes ?name from URL
+ * ```
+ *
+ * @example — with default (never null)
+ * ```ts
+ * const page = injectQueryParam('page', parseAsInteger.withDefault(1));
+ * page.value() // number
+ * page.set(2);
+ * ```
+ */
+declare function injectQueryParam<T>(key: string, parser: ParserBuilderWithDefault<T>): QueryParamState<T>;
+declare function injectQueryParam<T>(key: string, parser: ParserBuilder<T>): QueryParamState<T | null>;
+
+type ParserMap = Record<string, ParserBuilder<unknown> | ParserBuilderWithDefault<unknown>>;
+type InferParserMapValues<M extends ParserMap> = {
+    [K in keyof M]: M[K] extends ParserBuilderWithDefault<infer T> ? QueryParamState<T> : M[K] extends ParserBuilder<infer T> ? QueryParamState<T | null> : never;
+};
+type InferParserMapSetAll<M extends ParserMap> = {
+    [K in keyof M]?: M[K] extends ParserBuilderWithDefault<infer T> ? T | null : M[K] extends ParserBuilder<infer T> ? T | null : never;
+};
+type QueryParamsState<M extends ParserMap> = InferParserMapValues<M> & {
+    /** Update multiple params at once in a single navigation call. */
+    setAll(values: InferParserMapSetAll<M>, opts?: QueryParamOptions): void;
+    /** Remove all managed params from the URL. */
+    clearAll(): void;
+};
+/**
+ * `injectQueryParams` — manage multiple query params at once.
+ *
+ * @example
+ * ```ts
+ * const filters = injectQueryParams({
+ *   q:    parseAsString.withDefault(''),
+ *   page: parseAsInteger.withDefault(1),
+ *   sort: parseAsStringEnum(['asc', 'desc'] as const).withDefault('asc'),
+ * });
+ *
+ * filters.q.value()    // string
+ * filters.page.value() // number
+ * filters.setAll({ q: 'angular', page: 1 }); // batch update
+ * ```
+ */
+declare function injectQueryParams<M extends ParserMap>(parserMap: M): QueryParamsState<M>;
+
+export { AuthLayout, DEFAULT_BREAKPOINTS, DEFAULT_CATEGORIES, DEFAULT_CONFIG, DEFAULT_DOCK_OPTIONS, SC_AUDIO_PLAYER, SC_BARCODE_SCANNER, SC_COLOR_PICKER, SC_COUNTDOWN, SC_DATA_TABLE, SC_DIFF_VIEWER, SC_IMAGE_COMPARE, SC_IMAGE_CROPPER, SC_INFINITE_SCROLL, SC_KANBAN_BOARD, SC_LANGUAGE_CONFIG, SC_LIGHTBOX_PROVIDER, SC_MASONRY_GRID, SC_MASONRY_ITEM, SC_MENTION_INPUT, SC_NOTIFICATION_CENTER, SC_ORG_CHART, SC_PDF_VIEWER, SC_SIGNATURE_PAD, SC_STEPPER, SC_STEPPER_ITEM, SC_STEPPER_PANEL, SC_TAGS_INPUT, SC_TAGS_INPUT_ITEM, SC_TREE_ITEM, ScAudioPlayer, ScAudioPlayerControls, ScAudioPlayerCover, ScAudioPlayerNext, ScAudioPlayerPlay, ScAudioPlayerPrevious, ScAudioPlayerProgress, ScAudioPlayerRepeat, ScAudioPlayerShuffle, ScAudioPlayerTrackInfo, ScAudioPlayerVolume, ScBarcodeScanner, ScBarcodeVideo, ScButtonPattern, ScColorPicker, ScColorPickerArea, ScColorPickerAreaBrightness, ScColorPickerAreaCursor, ScColorPickerAreaSaturation, ScColorPickerEyeDropper, ScColorPickerHue, ScColorPickerHueCursor, ScColorPickerInput, ScColorPickerPreview, ScColorPickerSwatch, ScColorPickerSwatches, ScCountdown, ScDataTable, ScDataTableBody, ScDataTableCell, ScDataTableColumnToggle, ScDataTableFilter, ScDataTableHead, ScDataTableHeader, ScDataTablePagination, ScDataTableRow, ScDateRangePicker, ScDateRangePickerFooter, ScDateRangePickerPreset, ScDateRangePickerPresets, ScDateRangePickerTrigger, ScDiffViewer, ScDiffViewerContent, ScDiffViewerEmpty, ScDiffViewerFooter, ScDiffViewerHeader, ScDiffViewerLine, ScDiffViewerLineContent, ScDiffViewerLineNumber, ScDiffViewerLinePlaceholder, ScDiffViewerLineSign, ScDiffViewerModeSwitch, ScDiffViewerPane, ScDiffViewerPaneHeader, ScDiffViewerSplit, ScDock, ScDockBadge, ScDockItem, ScDockItems, ScEmojiPicker, ScEmojiPickerCategoryTab, ScEmojiPickerCategoryTabs, ScEmojiPickerGrid, ScEmojiPickerItem, ScEmojiPickerRecent, ScEmojiPickerSearch, ScEmojiPickerState, ScEmojiPickerTrigger, ScImageAnnotator, ScImageAnnotatorAction, ScImageAnnotatorCanvas, ScImageAnnotatorColorButton, ScImageAnnotatorLineWidth, ScImageAnnotatorToolButton, ScImageAnnotatorToolbar, ScImageCompare, ScImageCompareAfter, ScImageCompareArea, ScImageCompareBefore, ScImageCompareLabel, ScImageCompareSlider, ScImageCropper, ScImageCropperAspectRatio, ScImageCropperCanvas, ScImageCropperDragRegion, ScImageCropperFileInput, ScImageCropperFlipH, ScImageCropperFlipV, ScImageCropperGrid, ScImageCropperHandle, ScImageCropperImage, ScImageCropperOverlay, ScImageCropperPreview, ScImageCropperReset, ScImageCropperRotateLeft, ScImageCropperRotateRight, ScImageCropperSelection, ScImageCropperZoomIn, ScImageCropperZoomOut, ScImageCropperZoomSlider, ScInfiniteScroll, ScInfiniteScrollEnd, ScInfiniteScrollLoader, ScKanbanBoard, ScKanbanCard, ScKanbanColumn, ScLanguageButton, ScLanguageSelect, ScLanguageService, ScLanguageToggle, ScLightbox, ScLightboxClose, ScLightboxCounter, ScLightboxGallery, ScLightboxGalleryItem, ScLightboxImage, ScLightboxNext, ScLightboxPortal, ScLightboxPrev, ScLightboxProvider, ScLightboxThumbnail, ScLightboxThumbnailBar, ScLightboxToolbar, ScLightboxTrigger, ScLightboxZoomControls, ScLightboxZoomIn, ScLightboxZoomOut, ScLightboxZoomReset, ScMarquee, ScMarqueeContent, ScMarqueeFade, ScMarqueeItem, ScMarqueeText, ScMarqueeTextSegment, ScMarqueeTextSeparator, ScMarqueeTextTrack, ScMasonryGrid, ScMasonryItem, ScMentionInput, ScMentionInputControl, ScMentionInputSuggestionItem, ScMentionInputSuggestions, ScNativeDialog, ScNativeDialogBody, ScNativeDialogClose, ScNativeDialogContent, ScNativeDialogDescription, ScNativeDialogFooter, ScNativeDialogHeader, ScNativeDialogProvider, ScNativeDialogTitle, ScNativeDialogTrigger, ScNavbar, ScNavbarActions, ScNavbarBrand, ScNavbarGroup, ScNavbarMobileLink, ScNavbarMobileMenu, ScNavbarMobilePortal, ScNavbarMobileTrigger, ScNavbarProvider, ScNotificationCenter, ScNotificationCenterContainer, ScNotificationGroup, ScNotificationItem, ScOrgChart, ScOrgChartCard, ScOrgChartNode, ScOrgChartNodeDef, ScPdfViewerAltTextDialog, ScPdfViewerCanvas, ScPdfViewerCommentSidebar, ScPdfViewerContainer, ScPdfViewerContent, ScPdfViewerDownload, ScPdfViewerEditorFreetextParams, ScPdfViewerEditorHighlightParams, ScPdfViewerEditorInkParams, ScPdfViewerEditorUndoBar, ScPdfViewerEmpty, ScPdfViewerError, ScPdfViewerFindInput, ScPdfViewerFindNext, ScPdfViewerFindPrevious, ScPdfViewerFindResultsInfo, ScPdfViewerFindToggle, ScPdfViewerFindbar, ScPdfViewerFullscreen, ScPdfViewerLayersView, ScPdfViewerLoading, ScPdfViewerNav, ScPdfViewerNextPage, ScPdfViewerPageInfo, ScPdfViewerPasswordDialog, ScPdfViewerPrevPage, ScPdfViewerPrint, ScPdfViewerPrintProgress, ScPdfViewerRetry, ScPdfViewerRoot, ScPdfViewerRotateLeft, ScPdfViewerRotateRight, ScPdfViewerSeparator, ScPdfViewerSidebarResizer, ScPdfViewerSignatureDialog, ScPdfViewerSpacer, ScPdfViewerToolbar, ScPdfViewerZoom, ScPdfViewerZoomIn, ScPdfViewerZoomOut, ScPdfViewerZoomSelect, ScQrCode, ScQrCodeDownload, ScSidebarLayout, ScSignaturePad, ScSignaturePadCanvas, ScSignaturePadClearButton, ScSignaturePadColorButton, ScSignaturePadControls, ScSignaturePadToolbar, ScSignaturePadUndoButton, ScSignaturePadWidthButton, ScSpeedDial, ScSpeedDialAction, ScSpeedDialActionButton, ScSpeedDialActionLabel, ScSpeedDialActionList, ScSpeedDialTrigger, ScSpotlight, ScSpotlightActions, ScSpotlightClose, ScSpotlightDescription, ScSpotlightHighlight, ScSpotlightMask, ScSpotlightState, ScSpotlightTitle, ScSpotlightTooltip, ScStackedLayout, ScStatCard, ScStatCardChange, ScStatCardDescription, ScStatCardIcon, ScStatCardLabel, ScStatCardValue, ScStepper, ScStepperContent, ScStepperDescription, ScStepperItem, ScStepperList, ScStepperNext, ScStepperPanel, ScStepperPrevious, ScStepperSeparator, ScStepperTitle, ScStepperTrigger, ScTagsInput, ScTagsInputClear, ScTagsInputControl, ScTagsInputCount, ScTagsInputItem, ScTagsInputItemDelete, ScTimePickerClock, ScTimeline, ScTimelineConnector, ScTimelineContent, ScTimelineDescription, ScTimelineDot, ScTimelineItem, ScTimelineTime, ScTimelineTitle, ScTourGuide, ScTourGuideAction, ScTourGuideClose, ScTourGuideCounter, ScTourGuideDescription, ScTourGuideHighlight, ScTourGuideMask, ScTourGuideNavigation, ScTourGuideProgress, ScTourGuideStepNumber, ScTourGuideTitle, ScTourGuideTooltip, ScTransferList, ScTransferListActions, ScTransferListCount, ScTransferListHeader, ScTransferListItem, ScTransferListItems, ScTransferListSearch, ScTransferListSelectAll, ScTransferListSource, ScTransferListTarget, ScTree, ScTreeItem, ScTreeItemGroup, ScTreeItemIcon, ScTreeItemTrigger, ScTreeItemTriggerIcon, ScVideoPlayer, ScVideoPlayerBigPlay, ScVideoPlayerBufferingIndicator, ScVideoPlayerControls, ScVideoPlayerFullscreen, ScVideoPlayerPip, ScVideoPlayerPlayPause, ScVideoPlayerProgress, ScVideoPlayerSkip, ScVideoPlayerSpacer, ScVideoPlayerSpeed, ScVideoPlayerTime, ScVideoPlayerToolbar, ScVideoPlayerVideo, ScVideoPlayerVolume, TourService, ZOOM_LEVELS, computeDiff, computeWordDiff, createParser, createScDateRangePresets, createUnifiedDiff, injectQueryParam, injectQueryParams, parseAsArrayOf, parseAsBoolean, parseAsFloat, parseAsInteger, parseAsIsoDate, parseAsIsoDateTime, parseAsJson, parseAsString, parseAsStringEnum, parseAsTimestamp };
+export type { Annotation, AnnotationPoint, AnnotationTool, BarcodeFormat, BarcodeResult, ColumnDef, ColumnVisibilityState, CountdownTime, DiffLine, DiffOptions, DiffResult, DiffViewMode, DockItem, DockOptions, DockPosition, DockSize, Emoji, EmojiCategory, HSL, HSV, ImageAnnotatorState, InferParserMapSetAll, InferParserMapValues, KanbanAssignee, KanbanCard, KanbanCardAddEvent, KanbanCardDeleteEvent, KanbanColumn, KanbanDragEvent, KanbanLabel, Language, LanguageConfig, MasonryBreakpoint, MasonryConfig, MasonryGridRef, MasonryItemRef, MasonryLayoutMode, MentionUser, Notification, NotificationAction, NotificationActionEvent, NotificationDismissEvent, NotificationFilter, NotificationGroup, NotificationGroupCollapseEvent, NotificationMarkReadEvent, NotificationType, OKLCH, OrgChartNode, Parser, ParserBuilder, ParserBuilderWithDefault, ParserMap, PdfComment, PdfEditorAnnotation, PdfEditorMode, PdfErrorEvent, PdfFindState, PdfLoadEvent, PdfPageChangeEvent, PdfPageMatchInfo, PdfSignatureData, PdfZoomChangeEvent, PdfZoomLevel, QueryParamOptions, QueryParamState, QueryParamsState, RGB, ScAudioTrack, ScDateRangePreset, ScImageCropperArea, ScImageCropperHandlePosition, ScImageCropperResult, ScLightboxImageData, ScNotificationCenterApi, ScOrgChartDirection, ScOrgChartNodeDefContext, ScOrgChartNodeExpandEvent, ScQrCodeEcc, ScSignatureLine, ScSignaturePoint, ScStepperOrientation, ScVideoSource, ScVideoTrack, SortDirection, SortingState, SpeedDialDirection, SpeedDialSize, SpotlightOptions, StatCardSize, StatCardTrend, StatCardVariant, TargetRect, TourOptions, TourStep, TransferListItem, TransferListState };