@semantic-components/ui 0.37.0 → 0.38.0

package/lib/components/file-upload/file-upload.d.ts

@@ -1,9 +1,32 @@
+import { HttpClient } from '@angular/common/http';
+import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class ScFileUpload {
-    readonly class: import("@angular/core").InputSignal<string>;
-    protected readonly _class: import("@angular/core").Signal<string>;
-    selectedFile: import("@angular/core").WritableSignal<unknown>;
-    handleFileChange(event: Event): void;
+    private readonly http;
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    acceptedFileTypes: string;
+    maxFileSize: number;
+    multiple: boolean;
+    uploadUrl: string;
+    uploadComplete: EventEmitter<any>;
+    files: File[];
+    isDragging: boolean;
+    uploadProgress: number;
+    isUploading: boolean;
+    uploadError: string | null;
+    uploadSuccess: boolean;
+    constructor(http: HttpClient);
+    onFileSelected(event: any): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    processFiles(fileList: FileList): void;
+    uploadFiles(): void;
+    removeFile(index: number): void;
+    resetStatus(): void;
+    clearFiles(): void;
+    formatFileSize(bytes: number): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScFileUpload, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScFileUpload, "sc-file-upload", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScFileUpload, "sc-file-upload", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "acceptedFileTypes": { "alias": "acceptedFileTypes"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "uploadUrl": { "alias": "uploadUrl"; "required": false; }; }, { "uploadComplete": "uploadComplete"; }, never, never, true, never>;
 }

package/lib/components/file-upload/index.d.ts

@@ -1,3 +1 @@
 export * from './file-upload';
-export * from './file-uploader';
-export * from './single-file-uploader';

package/lib/components/full-calendar/full-calendar.d.ts

@@ -6,7 +6,7 @@ export declare class ScFullCalendar implements OnInit {
     currentDate: Date;
     currentMonth: number;
     currentYear: number;
-    currentView: 'month' | 'week' | 'day';
+    readonly currentView: import("@angular/core").WritableSignal<"day" | "month" | "week">;
     daysInMonth: number[];
     weekdays: string[];
     events: {

package/lib/components/input/input.d.ts

@@ -7,6 +7,8 @@ export declare class ScInput {
     readonly value: import("@angular/core").ModelSignal<string>;
     readonly idInput: import("@angular/core").InputSignal<string>;
     readonly id: import("@angular/core").WritableSignal<string>;
+    private readonly host;
+    get nativeElement(): any;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScInput, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ScInput, "input[sc-input]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, [{ directive: typeof i1.ScPlainInput; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
 }

package/lib/components/input/plain-input.d.ts

@@ -4,5 +4,5 @@ export declare class ScPlainInput {
     readonly value: import("@angular/core").ModelSignal<string>;
     handleInput(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScPlainInput, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ScPlainInput, "input[sc-plain-input]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScPlainInput, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }

package/lib/components/input-number/index.d.ts

@@ -0,0 +1,3 @@
+export * from './input-number';
+export * from './input-number-incrementer';
+export * from './input-number-decrementer';

package/lib/components/input-number/input-number-decrementer.d.ts

@@ -0,0 +1,9 @@
+import { ScButtonBase } from '../button';
+import * as i0 from "@angular/core";
+export declare class ScInputNumberDecrementer extends ScButtonBase {
+    readonly decremented: import("@angular/core").OutputEmitterRef<void>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    protected handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScInputNumberDecrementer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputNumberDecrementer, "button[sc-input-number-decrementer]", never, {}, { "decremented": "decremented"; }, never, ["*"], true, never>;
+}

package/lib/components/input-number/input-number-incrementer.d.ts

@@ -0,0 +1,9 @@
+import { ScButtonBase } from '../button';
+import * as i0 from "@angular/core";
+export declare class ScInputNumberIncrementer extends ScButtonBase {
+    readonly incremented: import("@angular/core").OutputEmitterRef<void>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    protected handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScInputNumberIncrementer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputNumberIncrementer, "button[sc-input-number-incrementer]", never, {}, { "incremented": "incremented"; }, never, ["*"], true, never>;
+}

package/lib/components/input-number/input-number.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class ScInputNumber {
+    private readonly hostRef;
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    readonly value: import("@angular/core").ModelSignal<number>;
+    readonly type: import("@angular/core").InputSignal<"number">;
+    handleInput(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScInputNumber, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputNumber, "input[sc-input-number]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}

package/lib/components/input-number-group/index.d.ts

@@ -0,0 +1 @@
+export * from './input-number-group';

package/lib/components/input-number-group/input-number-group.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class ScInputNumberGroup {
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    private readonly scInputNumberIncrementer;
+    private readonly scInputNumberDecrementer;
+    private readonly scInputNumber;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScInputNumberGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputNumberGroup, "div[sc-input-number-group]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["scInputNumberIncrementer", "scInputNumberDecrementer", "scInputNumber"], ["*"], true, never>;
+}

package/lib/components/input-otp/input-otp-slot.d.ts

@@ -1,17 +1,25 @@
-import { FormControl } from '@angular/forms';
-import { InputOtpHandler } from './input-otp-handler';
+import { ElementRef } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class ScInputOTPSlot {
-    inputOtpHandler: InputOtpHandler;
     readonly classInput: import("@angular/core").InputSignal<string>;
     protected readonly class: import("@angular/core").Signal<string>;
-    formControl: import("@angular/core").WritableSignal<FormControl<any> | null>;
-    index: number;
-    isActive: import("@angular/core").WritableSignal<boolean>;
-    readonly input: import("@angular/core").Signal<HTMLInputElement>;
-    protected handleKeydown(event: KeyboardEvent): void;
-    private autoFocusNext;
-    private autoFocusPrev;
+    protected readonly showFakeCaret: import("@angular/core").Signal<boolean>;
+    protected readonly isActive: import("@angular/core").WritableSignal<boolean>;
+    readonly disabled: import("@angular/core").WritableSignal<boolean>;
+    readonly inputRef: import("@angular/core").Signal<ElementRef<HTMLInputElement>>;
+    readonly focus: import("@angular/core").OutputEmitterRef<string>;
+    readonly blur: import("@angular/core").OutputEmitterRef<void>;
+    readonly backspace: import("@angular/core").OutputEmitterRef<void>;
+    readonly arrowLeft: import("@angular/core").OutputEmitterRef<void>;
+    readonly arrowRight: import("@angular/core").OutputEmitterRef<void>;
+    readonly paste: import("@angular/core").OutputEmitterRef<string>;
+    readonly value: import("@angular/core").ModelSignal<string>;
+    protected onInput(event: Event): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onPaste(event: ClipboardEvent): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    setActive(active?: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScInputOTPSlot, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputOTPSlot, "sc-input-otp-slot", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputOTPSlot, "sc-input-otp-slot", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "focus": "focus"; "blur": "blur"; "backspace": "backspace"; "arrowLeft": "arrowLeft"; "arrowRight": "arrowRight"; "paste": "paste"; "value": "valueChange"; }, never, never, true, never>;
 }

package/lib/components/input-otp/input-otp.d.ts

@@ -1,35 +1,33 @@
-import { OnDestroy } from '@angular/core';
-import { ControlValueAccessor, FormArray, FormGroup } from '@angular/forms';
-import { Subject } from 'rxjs';
+import { AfterContentInit } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, ValidationErrors } from '@angular/forms';
 import { ScInputOTPSlot } from './input-otp-slot';
 import * as i0 from "@angular/core";
-export declare class ScInputOtp implements ControlValueAccessor, OnDestroy {
-    private readonly inputOtpHandler;
-    private readonly focusMonitor;
+export declare class ScInputOtp implements AfterContentInit, ControlValueAccessor {
+    readonly disabledInput: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    protected readonly disabled: import("@angular/core").WritableSignal<boolean>;
     private readonly changeDetectorRef;
     readonly classInput: import("@angular/core").InputSignal<string>;
     protected readonly class: import("@angular/core").Signal<string>;
-    readonly required: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    readonly formGroup: FormGroup<{
-        inputs: FormArray<never>;
-    }>;
-    get inputs(): FormArray;
     readonly slots: import("@angular/core").Signal<readonly ScInputOTPSlot[]>;
+    readonly currentIndex: import("@angular/core").WritableSignal<number>;
+    readonly value: import("@angular/core").ModelSignal<string>;
+    type: import("@angular/core").InputSignal<"numeric" | "alphanumeric">;
     constructor();
-    private _updateValue;
-    readonly _value: import("@angular/core").ModelSignal<string | null>;
-    readonly disabledByInput: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
-    private readonly disabledByCva;
-    private readonly _disabled;
+    ngAfterContentInit(): void;
+    private setupDigitComponents;
+    setCurrentPosition(position: number): void;
+    private findFirstSlotToHighlight;
+    private handleMultiDigitPaste;
+    private updateOtpValue;
+    validate(control: AbstractControl): ValidationErrors | null;
+    clear(): void;
+    setValue(value: string): void;
+    writeValue(value: string): void;
     onChange: (_: any) => void;
     onTouched: () => void;
-    writeValue(tel: string | null): void;
     registerOnChange(fn: any): void;
     registerOnTouched(fn: any): void;
     setDisabledState(isDisabled: boolean): void;
-    private readonly _elementRef;
-    readonly stateChanges: Subject<void>;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScInputOtp, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputOtp, "sc-input-otp", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "_value": { "alias": "value"; "required": false; "isSignal": true; }; "disabledByInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "_value": "valueChange"; }, ["slots"], ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScInputOtp, "sc-input-otp", never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["slots"], ["*"], true, never>;
 }

package/lib/components/input-password/input-password.d.ts

@@ -6,23 +6,23 @@ export declare class ScInputPassword implements OnInit {
     readonly classInput: import("@angular/core").InputSignal<string>;
     protected readonly class: import("@angular/core").Signal<string>;
     protected control: FormControl<any>;
-    private destroyRef;
+    private readonly destroyRef;
     ngOnInit(): void;
     readonly password: import("@angular/core").WritableSignal<string>;
     readonly isVisible: import("@angular/core").WritableSignal<boolean>;
-    requirements: {
+    readonly requirements: {
         regex: RegExp;
         text: string;
     }[];
-    strength: import("@angular/core").Signal<{
+    readonly strength: import("@angular/core").Signal<{
         met: boolean;
         text: string;
     }[]>;
-    strengthScore: import("@angular/core").Signal<number>;
-    protected readonly indicatorClass: import("@angular/core").Signal<string>;
-    strengthColor: import("@angular/core").Signal<"bg-border" | "bg-red-500" | "bg-orange-500" | "bg-amber-500" | "bg-emerald-500">;
-    strengthText: import("@angular/core").Signal<"Enter a password" | "Weak password" | "Medium password" | "Strong password">;
-    toggleVisibility(): void;
+    readonly strengthScore: import("@angular/core").Signal<number>;
+    protected readonly progressClass: import("@angular/core").Signal<string>;
+    readonly strengthColor: import("@angular/core").Signal<"[&>[data-slot=indicator]]:bg-border" | "[&>[data-slot=indicator]]:bg-red-500" | "[&>[data-slot=indicator]]:bg-orange-500" | "[&>[data-slot=indicator]]:bg-amber-500" | "[&>[data-slot=indicator]]:bg-emerald-500">;
+    readonly strengthText: import("@angular/core").Signal<"Enter a password" | "Weak password" | "Medium password" | "Strong password">;
+    protected toggleVisibility(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScInputPassword, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ScInputPassword, "sc-input-password", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/components/multi-select/index.d.ts

@@ -0,0 +1 @@
+export * from './multi-select';

package/lib/components/multi-select/multi-select.d.ts

@@ -0,0 +1,41 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ScOptionModel {
+    id: string | number;
+    label: string;
+    selected?: boolean;
+}
+export declare class ScMultiSelect implements OnInit {
+    private readonly elementRef;
+    options: ScOptionModel[];
+    placeholder: string;
+    searchable: boolean;
+    label: string;
+    required: boolean;
+    showError: boolean;
+    errorMessage: string;
+    selectionChange: EventEmitter<ScOptionModel[]>;
+    protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    searchText: string;
+    filteredOptions: ScOptionModel[];
+    focusedIndex: number;
+    uniqueId: string;
+    labelId: string;
+    listboxId: string;
+    descriptionId: string;
+    get activeDescendant(): string | null;
+    constructor(elementRef: ElementRef);
+    ngOnInit(): void;
+    get selectedOptions(): ScOptionModel[];
+    toggleDropdown(): void;
+    toggleOption(option: ScOptionModel, event?: Event): void;
+    isSelected(option: ScOptionModel): boolean;
+    onSearch(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    scrollToOption(): void;
+    announceForScreenReader(message: string): void;
+    clickOutside(event: Event): void;
+    f(option: ScOptionModel): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScMultiSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScMultiSelect, "sc-multi-select", never, { "options": { "alias": "options"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showError": { "alias": "showError"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}

package/lib/components/on-this-page/index.d.ts

@@ -0,0 +1 @@
+export * from './on-this-page';

package/lib/components/on-this-page/on-this-page.d.ts

@@ -0,0 +1,31 @@
+import { ElementRef, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+interface NavItem {
+    id: string;
+    text: string;
+    level: number;
+    children: NavItem[];
+}
+export declare class ScOnThisPage implements OnInit, OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    private observer;
+    private readonly observedElements;
+    protected readonly navItems: import("@angular/core").WritableSignal<NavItem[]>;
+    protected readonly activeItem: import("@angular/core").WritableSignal<string>;
+    private readonly destroy$;
+    private isObserving;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initNavItems;
+    getPaddingClass(level: number): string;
+    scrollToSection(id: string): void;
+    private initIntersectionObserver;
+    private setupScrollListener;
+    private startObserving;
+    private stopObserving;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScOnThisPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScOnThisPage, "sc-on-this-page", never, {}, {}, never, never, true, never>;
+}
+export {};

package/lib/components/progress/index.d.ts

@@ -1,2 +1 @@
 export * from './progress';
-export * from './circular-progress';

package/lib/components/progress/progress.d.ts

@@ -2,8 +2,6 @@ import * as i0 from "@angular/core";
 export declare class ScProgress {
     readonly classInput: import("@angular/core").InputSignal<string>;
     protected readonly class: import("@angular/core").Signal<string>;
-    readonly indicatorClassInput: import("@angular/core").InputSignal<string>;
-    protected readonly indicatorClass: import("@angular/core").Signal<string>;
     /** Current value of the progressbar. */
     readonly value: import("@angular/core").InputSignal<number>;
     readonly mode: import("@angular/core").InputSignal<"determinate" | "indeterminate">;
@@ -11,5 +9,5 @@ export declare class ScProgress {
     readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
     protected readonly transform: import("@angular/core").Signal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScProgress, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScProgress, "sc-progress", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "indicatorClassInput": { "alias": "indicatorClass"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScProgress, "sc-progress", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/components/range-calendar/days-selector.d.ts

@@ -0,0 +1,19 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { CalendarDay } from '../calendar/types';
+import { ScRange } from './types';
+import * as i0 from "@angular/core";
+export declare class ScDaysSelector {
+    readonly calendarDays: import("@angular/core").InputSignal<CalendarDay[]>;
+    readonly weekdays: import("@angular/core").InputSignal<string[]>;
+    readonly rangeSelected: import("@angular/core").OutputEmitterRef<ScRange>;
+    readonly selectedRange: import("@angular/core").InputSignal<ScRange | undefined>;
+    readonly focusedDate: import("@angular/core").InputSignal<Temporal.PlainDate | undefined>;
+    protected getVariant(day: CalendarDay): "primary" | "outline" | "secondary" | "ghost";
+    protected selectDay(day: CalendarDay): void;
+    isSelected(date: Temporal.PlainDate): boolean;
+    isFocused(date: Temporal.PlainDate): boolean;
+    isDateInRange(date: Temporal.PlainDate): boolean;
+    selectDate(day: CalendarDay): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScDaysSelector, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScDaysSelector, "sc-days-selector", never, { "calendarDays": { "alias": "calendarDays"; "required": true; "isSignal": true; }; "weekdays": { "alias": "weekdays"; "required": true; "isSignal": true; }; "selectedRange": { "alias": "selectedRange"; "required": false; "isSignal": true; }; "focusedDate": { "alias": "focusedDate"; "required": false; "isSignal": true; }; }, { "rangeSelected": "rangeSelected"; }, never, never, true, never>;
+}

package/lib/components/range-calendar/index.d.ts

@@ -0,0 +1 @@
+export * from './range-calendar';

package/lib/components/range-calendar/range-calendar.d.ts

@@ -0,0 +1,41 @@
+import { ControlValueAccessor } from '@angular/forms';
+import { Temporal } from '@js-temporal/polyfill';
+import { ScRange } from './types';
+import * as i0 from "@angular/core";
+export declare class ScRangeCalendar implements ControlValueAccessor {
+    readonly value: import("@angular/core").ModelSignal<ScRange | undefined>;
+    readonly minDate: import("@angular/core").InputSignal<Temporal.PlainDate | undefined>;
+    readonly maxDate: import("@angular/core").InputSignal<Temporal.PlainDate | undefined>;
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    private readonly today;
+    protected readonly focusedDate: import("@angular/core").WritableSignal<Temporal.PlainDate | ScRange | undefined>;
+    protected readonly currentYear: import("@angular/core").WritableSignal<number>;
+    protected readonly currentMonth: import("@angular/core").WritableSignal<Temporal.PlainYearMonth>;
+    private readonly firstDayOfMonth;
+    private readonly lastDayOfMonth;
+    private readonly localeId;
+    protected readonly calendarDays: import("@angular/core").Signal<import("../calendar/types").CalendarDay[]>;
+    isToday(date: Temporal.PlainDate): boolean;
+    isDateDisabled(date: Temporal.PlainDate): boolean;
+    selectRange(range: ScRange): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    protected readonly view: import("@angular/core").WritableSignal<"months" | "years" | "days">;
+    protected toggleView(): void;
+    weekdays: string[];
+    private readonly scYearSelector;
+    protected setMonthYear(n: number): void;
+    protected selectYear(year: number): void;
+    protected selectMonth(month: Temporal.PlainYearMonth): void;
+    onChange: (value: ScRange) => void;
+    onTouched: () => void;
+    writeValue(value: ScRange): void;
+    registerOnChange(fn: (value: ScRange) => void): void;
+    registerOnTouched(fn: () => void): void;
+    readonly disabledInput: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: import("@angular/core").WritableSignal<boolean>;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScRangeCalendar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScRangeCalendar, "sc-range-calendar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}

package/lib/components/range-calendar/types.d.ts

@@ -0,0 +1,5 @@
+import { Temporal } from '@js-temporal/polyfill';
+export interface ScRange {
+    start: Temporal.PlainDate;
+    end: Temporal.PlainDate;
+}

package/lib/components/range-slider/index.d.ts

@@ -0,0 +1 @@
+export * from './range-slider';

package/lib/components/range-slider/range-slider.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class ScRangeSlider {
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    readonly type: import("@angular/core").InputSignal<"range">;
+    readonly min: import("@angular/core").InputSignal<number>;
+    readonly max: import("@angular/core").InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScRangeSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScRangeSlider, "input[sc-range-slider]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/rating/index.d.ts

@@ -0,0 +1 @@
+export * from './rating';

package/lib/components/rating/rating.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, OnChanges, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ScRating implements OnInit, OnChanges {
+    maxRating: number;
+    rating: number;
+    interactive: boolean;
+    showRatingValue: boolean;
+    allowHalfStars: boolean;
+    ratingChange: EventEmitter<number>;
+    positions: number[];
+    hoverRating: number;
+    Math: Math;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    generatePositions(): void;
+    onHover(position: number): void;
+    onRate(position: number): void;
+    isHalfOrFullStar(position: number): boolean;
+    isHalfStar(position: number): boolean;
+    isHalfValue(value: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScRating, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScRating, "sc-rating", never, { "maxRating": { "alias": "maxRating"; "required": false; }; "rating": { "alias": "rating"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "showRatingValue": { "alias": "showRatingValue"; "required": false; }; "allowHalfStars": { "alias": "allowHalfStars"; "required": false; }; }, { "ratingChange": "ratingChange"; }, never, never, true, never>;
+}

package/lib/components/scroll-area/hover-scrollbar.component.d.ts

@@ -0,0 +1,14 @@
+import { AfterViewInit, ElementRef, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class HoverScrollbarComponent implements AfterViewInit, OnChanges {
+    width: number;
+    height: number;
+    border: boolean;
+    contentContainer: ElementRef;
+    isScrollable: boolean;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    checkIfScrollable(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HoverScrollbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HoverScrollbarComponent, "sc-hover-scrollbar", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "border": { "alias": "border"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/scroll-area/index.d.ts

@@ -1 +1,2 @@
 export * from './scroll-area';
+export * from './hover-scrollbar.component';

package/lib/components/scroll-area/scroll-area.d.ts

@@ -1,10 +1,10 @@
-import { AfterViewInit } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare class ScScrollArea implements AfterViewInit {
-    private readonly host;
+export declare class ScScrollArea {
     readonly classInput: import("@angular/core").InputSignal<string>;
     protected readonly class: import("@angular/core").Signal<string>;
-    ngAfterViewInit(): void;
+    private readonly state;
+    protected mouseover(): void;
+    protected mouseout(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScScrollArea, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ScScrollArea, "div[sc-scroll-area]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/lib/components/scroll-spy/scroll-spy.d.ts

@@ -1,12 +1,12 @@
-import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ElementRef, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
 export declare class ScScrollSpy implements OnInit {
     private readonly el;
-    spySections: string[];
-    sectionChange: EventEmitter<string>;
+    readonly spySections: import("@angular/core").InputSignal<string[]>;
+    readonly sectionChange: import("@angular/core").OutputEmitterRef<string>;
     private observer;
     constructor(el: ElementRef);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScScrollSpy, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ScScrollSpy, "[scScrollSpy]", never, { "spySections": { "alias": "spySections"; "required": false; }; }, { "sectionChange": "sectionChange"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScScrollSpy, "[scScrollSpy]", never, { "spySections": { "alias": "spySections"; "required": false; "isSignal": true; }; }, { "sectionChange": "sectionChange"; }, never, never, true, never>;
 }

package/lib/components/scroll-to-top/index.d.ts

@@ -0,0 +1,2 @@
+export * from './scroll-to-top';
+export * from './scroll-to-top-button';

package/lib/components/scroll-to-top/scroll-to-top-button.d.ts

@@ -0,0 +1,10 @@
+import { ScButtonBase } from '../button';
+import * as i0 from "@angular/core";
+export declare class ScScrollToTopButton extends ScButtonBase {
+    protected readonly class: import("@angular/core").Signal<string>;
+    protected readonly showScrollButton: import("@angular/core").WritableSignal<boolean>;
+    protected onWindowScroll(): void;
+    protected scrollToTop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScScrollToTopButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScScrollToTopButton, "button[sc-scroll-to-top-button]", never, {}, {}, never, never, true, never>;
+}

package/lib/components/scroll-to-top/scroll-to-top-button2.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export type ButtonState = 'initial' | 'visible' | 'hidden';
+export declare class ScScrollToTopButton2 {
+    readonly scrollToTop: import("@angular/core").OutputEmitterRef<void>;
+    readonly animationDone: import("@angular/core").OutputEmitterRef<void>;
+    readonly state: import("@angular/core").WritableSignal<ButtonState>;
+    protected onScrollToTop(): void;
+    protected onTransitionEnd(event: TransitionEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScScrollToTopButton2, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScScrollToTopButton2, "sc-scroll-to-top-button2", never, {}, { "scrollToTop": "scrollToTop"; "animationDone": "animationDone"; }, never, never, true, never>;
+}

package/lib/components/scroll-to-top/scroll-to-top.d.ts

@@ -0,0 +1,18 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ScScrollToTop {
+    private readonly overlay;
+    private readonly injector;
+    private readonly destroyRef;
+    private overlayRef;
+    private componentRef;
+    private readonly scrollThreshold;
+    constructor(overlay: Overlay, injector: Injector);
+    init(): void;
+    private show;
+    private hide;
+    private scrollToTop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScScrollToTop, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScScrollToTop>;
+}

package/lib/components/select/option.d.ts

@@ -10,8 +10,7 @@ export declare class ScOption implements Highlightable {
     private readonly labelEl;
     readonly label: import("@angular/core").Signal<string>;
     private readonly element;
-    /** Gets the host DOM element. */
-    getHostElement(): HTMLElement;
+    get nativeElement(): HTMLElement;
     readonly active: import("@angular/core").WritableSignal<boolean>;
     setActiveStyles(): void;
     setInactiveStyles(): void;