@semantic-components/ui 0.36.0 → 0.38.0

package/lib/components/code-highlighter/shiki.service.d.ts

@@ -1,5 +1,9 @@
 import { Highlighter } from 'shiki';
 import * as i0 from "@angular/core";
+export declare const defaultThemes: {
+    light: string;
+    dark: string;
+};
 export declare class ShikiService {
     private highlighter;
     initializeHighlighter(): Promise<Highlighter>;

package/lib/components/color-picker/color-picker.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ScColorPicker implements OnInit {
+    initialColor: string;
+    readonly colorChange: import("@angular/core").OutputEmitterRef<string>;
+    red: number;
+    green: number;
+    blue: number;
+    selectedColor: string;
+    presetColors: string[];
+    ngOnInit(): void;
+    setInitialColor(): void;
+    updateColor(): void;
+    componentToHex(c: number): string;
+    selectPresetColor(color: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScColorPicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScColorPicker, "sc-color-picker", never, { "initialColor": { "alias": "initialColor"; "required": false; }; }, { "colorChange": "colorChange"; }, never, never, true, never>;
+}

package/lib/components/color-picker/index.d.ts

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

package/lib/components/combobox/combobox.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter, OnInit } from '@angular/core';
+import { OnInit } from '@angular/core';
 import { FormControl } from '@angular/forms';
 import * as i0 from "@angular/core";
 export declare class ScCombobox implements OnInit {
@@ -10,8 +10,8 @@ export declare class ScCombobox implements OnInit {
     readonly optionTemplate: import("@angular/core").InputSignal<any>;
     readonly loading: import("@angular/core").InputSignal<boolean>;
     readonly labelKey: import("@angular/core").InputSignal<string>;
-    optionSelected: EventEmitter<any>;
-    search: EventEmitter<string>;
+    readonly optionSelected: import("@angular/core").OutputEmitterRef<any>;
+    readonly search: import("@angular/core").OutputEmitterRef<string>;
     searchControl: FormControl<string | null>;
     isOpen: boolean;
     activeIndex: number;

package/lib/components/comments/comment.d.ts

@@ -1,7 +1,7 @@
 import { ScCommentModel } from './comment-model';
 import * as i0 from "@angular/core";
 export declare class ScComment {
-    comment: import("@angular/core").InputSignal<ScCommentModel>;
+    readonly comment: import("@angular/core").InputSignal<ScCommentModel>;
     likeComment(comment: ScCommentModel): void;
     toggleReplyForm(comment: ScCommentModel): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScComment, never>;

package/lib/components/comments/comments.d.ts

@@ -3,9 +3,9 @@ import { ScCommentModel, ScUserModel } from './comment-model';
 import * as i0 from "@angular/core";
 export declare class ScComments {
     private readonly fb;
-    comments: import("@angular/core").InputSignal<ScCommentModel[]>;
-    currentUser: import("@angular/core").InputSignal<ScUserModel>;
-    commentForm: FormGroup;
+    readonly comments: import("@angular/core").InputSignal<ScCommentModel[]>;
+    readonly currentUser: import("@angular/core").InputSignal<ScUserModel>;
+    protected readonly commentForm: FormGroup;
     constructor();
     onSubmit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScComments, never>;

package/lib/components/date-picker/date-picker-toggle.d.ts

@@ -0,0 +1,10 @@
+import { ScButtonBase } from '../button';
+import * as i0 from "@angular/core";
+export declare class ScDatePickerToggle extends ScButtonBase {
+    readonly variantInput: import("@angular/core").InputSignal<"outline" | "link" | "primary" | "destructive" | "secondary" | "ghost" | null | undefined>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    readonly toggled: import("@angular/core").OutputEmitterRef<void>;
+    protected toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScDatePickerToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScDatePickerToggle, "button[sc-date-picker-toggle]", never, { "variantInput": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "toggled": "toggled"; }, never, ["*"], true, never>;
+}

package/lib/components/date-picker/date-picker.d.ts

@@ -1,30 +1,38 @@
-import { OutputEmitterRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Temporal } from '@js-temporal/polyfill';
 import * as i0 from "@angular/core";
-export declare class ScDatePicker {
-    class: import("@angular/core").InputSignal<string>;
-    classes: import("@angular/core").Signal<string>;
+export declare class ScDatePicker implements ControlValueAccessor {
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    readonly value: import("@angular/core").ModelSignal<Temporal.PlainDate | undefined>;
+    readonly minDate: import("@angular/core").InputSignal<Temporal.PlainDate | undefined>;
+    readonly maxDate: import("@angular/core").InputSignal<Temporal.PlainDate | undefined>;
+    private readonly localeId;
     private readonly host;
-    private readonly _injector;
-    private readonly _dir;
-    private readonly _overlay;
-    private readonly _isOpen;
-    private readonly _input;
-    private _overlayRef;
-    private _portal;
-    /** Emits when the datepicker is opened. */
-    readonly opened: OutputEmitterRef<void>;
-    /** Emits when the datepicker is closed. */
-    readonly closed: OutputEmitterRef<void>;
-    /** Emits when the user selects a date. */
-    readonly selected: OutputEmitterRef<string>;
+    private readonly dir;
+    private readonly overlay;
+    private readonly isOpen;
+    private overlayRef;
+    private portal;
+    private readonly scDatePickerToggle;
+    private readonly scInput;
+    constructor();
     /** Opens the datepicker. */
     open(): void;
     /** Closes the datepicker. */
     close(): void;
     /** Creates an overlay reference for the datepicker panel. */
-    private _getOverlayRef;
+    private getOverlayRef;
     /** Selects a specific date value. */
-    protected _selectValue(value: string): void;
+    protected selectValue(value: Temporal.PlainDate): void;
+    onChange: (value: Temporal.PlainDate) => void;
+    onTouched: () => void;
+    writeValue(value: Temporal.PlainDate): void;
+    registerOnChange(fn: (value: Temporal.PlainDate) => 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<ScDatePicker, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScDatePicker, "sc-date-picker", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "opened": "opened"; "closed": "closed"; "selected": "selected"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScDatePicker, "sc-date-picker", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["scDatePickerToggle", "scInput"], ["*"], true, never>;
 }

package/lib/components/date-picker/index.d.ts

@@ -1 +1,2 @@
 export * from './date-picker';
+export * from './date-picker-toggle';

package/lib/components/date-range-picker/date-range-picker.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { Temporal } from '@js-temporal/polyfill';
+import * as i0 from "@angular/core";
+export declare class ScDateRangePicker implements OnInit {
+    startDate: Temporal.PlainDate;
+    endDate: Temporal.PlainDate;
+    minDate: Temporal.PlainDate | null;
+    maxDate: Temporal.PlainDate | null;
+    dateRangeSelected: EventEmitter<{
+        startDate: Temporal.PlainDate;
+        endDate: Temporal.PlainDate;
+    }>;
+    currentMonth: Temporal.PlainYearMonth;
+    calendarDays: Array<{
+        date: Temporal.PlainDate;
+        isCurrentMonth: boolean;
+        isToday: boolean;
+        isSelected: boolean;
+        isInRange: boolean;
+        isDisabled: boolean;
+    }>;
+    weekdays: string[];
+    months: string[];
+    years: number[];
+    selectedStartDate: Temporal.PlainDate | null;
+    selectedEndDate: Temporal.PlainDate | null;
+    isSelectingEndDate: boolean;
+    showCalendar: boolean;
+    today: Temporal.PlainDate;
+    constructor();
+    ngOnInit(): void;
+    toggleCalendar(): void;
+    generateCalendarDays(): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    setMonth(month: number): void;
+    setYear(year: number): void;
+    selectDate(date: Temporal.PlainDate, isDisabled: boolean): void;
+    applyDateRange(): void;
+    cancelSelection(): void;
+    setLastWeek(): void;
+    setLastMonth(): void;
+    setLastThreeMonths(): void;
+    formatDate(date: Temporal.PlainDate | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScDateRangePicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScDateRangePicker, "sc-date-range-picker", never, { "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "dateRangeSelected": "dateRangeSelected"; }, never, never, true, never>;
+}

package/lib/components/date-range-picker/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+export declare class ScDualRangeSlider {
+    readonly min: import("@angular/core").InputSignal<number>;
+    readonly max: import("@angular/core").InputSignal<number>;
+    minValue: number;
+    maxValue: number;
+    readonly minValueChange: import("@angular/core").OutputEmitterRef<number>;
+    readonly maxValueChange: import("@angular/core").OutputEmitterRef<number>;
+    get minPercentage(): number;
+    get maxPercentage(): number;
+    onMinChange(event: Event): void;
+    onMaxChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScDualRangeSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScDualRangeSlider, "sc-dual-range-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; }, { "minValueChange": "minValueChange"; "maxValueChange": "maxValueChange"; }, never, never, true, never>;
+}

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

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

package/lib/components/editor/editor.d.ts

@@ -24,5 +24,5 @@ export declare class ScEditor implements ControlValueAccessor {
     setDisabledState?(isDisabled: boolean): void;
     setHtmlContent(htmlContent: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScEditor, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScEditor, "sc-editor", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "editorClass": { "alias": "editorClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScEditor, "sc-editor", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "editorClass": { "alias": "editorClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

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

@@ -1 +1,28 @@
 export * from './editor';
+export * from './actions/editor-blockquote';
+export * from './actions/editor-bold';
+export * from './actions/editor-bullet-list';
+export * from './actions/editor-code';
+export * from './actions/editor-highlight';
+export * from './actions/editor-horizontal-rule';
+export * from './actions/editor-italic';
+export * from './actions/editor-ordered-list';
+export * from './actions/editor-paragraph';
+export * from './actions/editor-redo';
+export * from './actions/editor-strike';
+export * from './actions/editor-text-align-center';
+export * from './actions/editor-text-align-left';
+export * from './actions/editor-text-align-right';
+export * from './actions/editor-underline';
+export * from './actions/editor-undo';
+export * from './actions/editor-unset-link';
+export * from './editor-group';
+export * from './editor-toolbar';
+export * from './extensions/extension-color';
+export * from './extensions/extension-font-family';
+export * from './extensions/extension-heading';
+export * from './extensions/extension-image';
+export * from './extensions/extension-link';
+export * from './extensions/extension-table';
+export * from './extensions/extension-text-style';
+export * from './extensions/extension-youtube';

package/lib/components/fieldset/description.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class ScDescription {
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScDescription, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScDescription, "p[sc-description]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/fieldset/error-message.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class ScErrorMessage {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScErrorMessage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScErrorMessage, "sc-error-message", never, {}, {}, never, never, true, never>;
+}

package/lib/components/fieldset/field.d.ts

@@ -0,0 +1,13 @@
+import { ScInput } from '../input';
+import { ScLabel } from '../label';
+import * as i0 from "@angular/core";
+export declare class ScField {
+    readonly classInput: import("@angular/core").InputSignal<string>;
+    protected readonly class: import("@angular/core").Signal<string>;
+    readonly id: import("@angular/core").WritableSignal<string>;
+    readonly scLabel: import("@angular/core").Signal<ScLabel | undefined>;
+    readonly scInput: import("@angular/core").Signal<ScInput | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScField, "sc-field", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["scLabel", "scInput"], ["*"], true, never>;
+}

package/lib/components/fieldset/fieldset.d.ts

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

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

@@ -0,0 +1,5 @@
+export * from './description';
+export * from './error-message';
+export * from './field';
+export * from './fieldset';
+export * from './legend';

package/lib/components/fieldset/legend.d.ts

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

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

@@ -5,6 +5,10 @@ export declare class ScInput {
     readonly classInput: import("@angular/core").InputSignal<string>;
     protected readonly class: import("@angular/core").Signal<string>;
     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; }; }, { "value": "valueChange"; }, never, ["*"], true, [{ directive: typeof i1.ScPlainInput; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+    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/label/label.d.ts

@@ -2,6 +2,8 @@ import * as i0 from "@angular/core";
 export declare class ScLabel {
     readonly classInput: import("@angular/core").InputSignal<string>;
     protected readonly class: import("@angular/core").Signal<string>;
+    readonly forInput: import("@angular/core").InputSignal<string>;
+    readonly for: import("@angular/core").WritableSignal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScLabel, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScLabel, "label[sc-label]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScLabel, "label[sc-label]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "forInput": { "alias": "for"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

package/lib/components/link/link.d.ts

@@ -1,7 +1,8 @@
 import { ScButtonBase } from '../button';
 import * as i0 from "@angular/core";
 export declare class ScLink extends ScButtonBase {
+    readonly variantInput: import("@angular/core").InputSignal<"outline" | "link" | "primary" | "destructive" | "secondary" | "ghost" | null | undefined>;
     protected readonly tabindex: import("@angular/core").Signal<0 | -1>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScLink, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ScLink, "a[sc-link]", never, {}, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScLink, "a[sc-link]", never, { "variantInput": { "alias": "variantInput"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }

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

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