@semantic-components/ui 0.54.0 → 0.55.0

package/index.d.ts

@@ -1,79 +1,2682 @@
-export * from './lib/utils';
-export * from './lib/components/tooltip';
-export * from './lib/components/paginator';
-export * from './lib/components/calendar';
-export * from './lib/components/range-calendar';
-export * from './lib/components/full-calendar';
-export * from './lib/components/date-picker';
-export * from './lib/components/date-range-picker';
-export * from './lib/components/nav';
-export * from './lib/components/theme-toggler';
-export * from './lib/components/link';
-export * from './lib/components/button';
-export * from './lib/components/input';
-export * from './lib/components/input-number';
-export * from './lib/components/input-number-group';
-export * from './lib/components/input-group';
-export * from './lib/components/input-password';
-export * from './lib/components/input-otp';
-export * from './lib/components/label';
-export * from './lib/components/textarea';
-export * from './lib/components/select';
-export * from './lib/components/multi-select';
-export * from './lib/components/scroll-to-top';
-export * from './lib/components/progress';
-export * from './lib/components/circular-progress';
-export * from './lib/components/sheet';
-export * from './lib/components/breadcrumb';
-export * from './lib/components/toggle';
-export * from './lib/components/toggle-group';
-export * from './lib/components/dialog';
-export * from './lib/components/alert';
-export * from './lib/components/alert-dialog';
-export * from './lib/components/badge';
-export * from './lib/components/scroll-area';
-export * from './lib/components/card';
-export * from './lib/components/toast';
-export * from './lib/components/slider';
-export * from './lib/components/checkbox';
-export * from './lib/components/checkbox-group';
-export * from './lib/components/accordion';
-export * from './lib/components/switch';
-export * from './lib/components/radio-group';
-export * from './lib/components/hover-card';
-export * from './lib/components/avatar';
-export * from './lib/components/aspect-ratio';
-export * from './lib/components/skeleton';
-export * from './lib/components/table';
-export * from './lib/components/data-table';
-export * from './lib/components/popover';
-export * from './lib/components/context-menu';
-export * from './lib/components/menu';
-export * from './lib/components/menu-bar';
-export * from './lib/components/command';
-export * from './lib/components/collapsible';
-export * from './lib/components/sidebar';
-export * from './lib/components/autocomplete';
-export * from './lib/components/time-picker';
-export * from './lib/components/separator';
-export * from './lib/components/file-upload';
-export * from './lib/components/page';
-export * from './lib/components/typography';
-export * from './lib/components/cookie-consent';
-export * from './lib/components/comments';
-export * from './lib/components/tags';
-export * from './lib/components/combobox';
-export * from './lib/components/clock-picker';
-export * from './lib/components/image-placeholder';
-export * from './lib/components/fieldset';
-export * from './lib/components/touch-area';
-export * from './lib/components/scroll-spy';
-export * from './lib/components/color-picker';
-export * from './lib/components/toggle-switch';
-export * from './lib/components/range-slider';
-export * from './lib/components/dual-range-slider';
-export * from './lib/components/table-of-contents';
-export * from './lib/components/stepper';
-export * from './lib/components/rating';
-export * from './lib/components/on-this-page';
-export * from './lib/components/tabs';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, EventEmitter, ElementRef, AfterContentInit, TemplateRef, AfterViewInit, OnChanges, SimpleChanges, InputSignal, Signal, OutputEmitterRef } from '@angular/core';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import { FormControl, ControlValueAccessor, AbstractControl, ValidationErrors, FormGroup } from '@angular/forms';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { Temporal } from '@js-temporal/polyfill';
+import { Highlightable } from '@angular/cdk/a11y';
+import * as i1 from '@angular/cdk/accordion';
+import { CdkAccordionItem } from '@angular/cdk/accordion';
+import * as i1$1 from '@angular/cdk/menu';
+import * as i1$2 from '@angular/router';
+import { RouterLinkActive } from '@angular/router';
+import { CdkStepper, CdkStep } from '@angular/cdk/stepper';
+
+declare class ScSettings {
+    clock: _angular_core.WritableSignal<"am-pm" | "24-hour">;
+    dateFormatPattern: _angular_core.WritableSignal<string>;
+    private readonly localeId;
+    constructor();
+    getDateFormatPattern(localeId: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSettings, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScSettings>;
+}
+
+declare class ScTooltip implements OnInit, OnDestroy {
+    private readonly elementRef;
+    private readonly overlay;
+    private overlayRef;
+    private tooltipRef;
+    readonly message: _angular_core.InputSignal<string>;
+    readonly position: _angular_core.InputSignal<"left" | "right" | "above" | "below">;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected showTooltip(): void;
+    protected hideTooltip(): void;
+    private attachTooltip;
+    private getPositionStrategy;
+    getPositions(): ConnectedPosition[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTooltip, "[scTooltip]", never, { "message": { "alias": "scTooltip"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Change event object that is emitted when the user selects a
+ * different page size or navigates to another page.
+ */
+interface ScPageEvent {
+    /** The current page index. */
+    page: number;
+    /** The current page size. */
+    pageSize: number;
+}
+
+declare class PaginatorService {
+    /** The one-based page index of the displayed list of items. Defaulted to 1. */
+    readonly currentPage: _angular_core.WritableSignal<number>;
+    /** The total number of items that are being paginated. */
+    readonly totalSize: _angular_core.WritableSignal<number>;
+    /** The set of provided page size options to display to the user. */
+    readonly pageSizeOptions: _angular_core.WritableSignal<number[]>;
+    /** Number of items to display on a page. By default, set to 10. */
+    readonly pageSize: _angular_core.WritableSignal<number>;
+    /** Event emitted when the paginator changes the page index. */
+    readonly pageChanged: _angular_core.WritableSignal<ScPageEvent>;
+    readonly pageSizeFormControl: FormControl<number | null>;
+    readonly numberOfPages: _angular_core.Signal<number>;
+    readonly firstItemPage: _angular_core.Signal<number>;
+    readonly lastItemPage: _angular_core.Signal<number>;
+    readonly isNextPageDisabled: _angular_core.Signal<boolean>;
+    readonly isPrevPageDisabled: _angular_core.Signal<boolean>;
+    readonly paginationLinkVariant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly paginationActiveLinkVariant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PaginatorService>;
+}
+
+declare class ScPaginator implements OnInit {
+    protected readonly paginatorService: PaginatorService;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    /** The one-based page index of the displayed list of items. Defaulted to 1. */
+    readonly currentPage: _angular_core.InputSignal<number>;
+    /** The total number of items that are being paginated. */
+    readonly totalSize: _angular_core.InputSignal<number>;
+    /** The set of provided page size options to display to the user. */
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    /** Number of items to display on a page. By default, set to 10. */
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly paginationLinkVariant: _angular_core.InputSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly paginationActiveLinkVariant: _angular_core.InputSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    /** Event emitted when the paginator changes the page index. */
+    readonly pageChanged: _angular_core.OutputEmitterRef<ScPageEvent>;
+    constructor();
+    ngOnInit(): void;
+    readonly firstItemPage: _angular_core.Signal<number>;
+    readonly lastItemPage: _angular_core.Signal<number>;
+    private range;
+    pages: _angular_core.Signal<(number | "...")[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginator, "sc-paginator", ["scPaginator"], { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; "totalSize": { "alias": "totalSize"; "required": true; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "paginationLinkVariant": { "alias": "paginationLinkVariant"; "required": false; "isSignal": true; }; "paginationActiveLinkVariant": { "alias": "paginationActiveLinkVariant"; "required": false; "isSignal": true; }; }, { "pageChanged": "pageChanged"; }, never, ["*"], true, never>;
+}
+
+declare class ScPaginatorContainer {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginatorContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginatorContainer, "sc-paginator-container", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPageSizeSelect {
+    protected readonly paginatorService: PaginatorService;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPageSizeSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPageSizeSelect, "div[sc-page-size-select]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScPagination {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPagination, "nav[sc-pagination]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPaginationList {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginationList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginationList, "ul[sc-pagination-list]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const buttonVariants: (props?: ({
+    variant?: "primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariants = VariantProps<typeof buttonVariants>;
+declare class ScButtonBase {
+    readonly variantInput: _angular_core.InputSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    protected readonly variant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly sizeInput: _angular_core.InputSignal<"default" | "sm" | "lg" | "icon" | null | undefined>;
+    protected readonly size: _angular_core.WritableSignal<"default" | "sm" | "lg" | "icon" | null | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly type: _angular_core.InputSignal<"submit" | "reset" | "button">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScButtonBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScButtonBase, never, never, { "variantInput": { "alias": "variant"; "required": false; "isSignal": true; }; "sizeInput": { "alias": "size"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScButton extends ScButtonBase {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScButton, "button[sc-button]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScPaginationFirst extends ScButtonBase {
+    readonly variant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    protected readonly paginatorService: PaginatorService;
+    protected firstPage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginationFirst, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginationFirst, "a[sc-pagination-first]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScPaginationLast extends ScButtonBase {
+    readonly variant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    private readonly paginatorService;
+    protected lastPage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginationLast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginationLast, "a[sc-pagination-last]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScPaginationPrevious extends ScButtonBase {
+    readonly variant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    protected readonly paginatorService: PaginatorService;
+    protected prevPage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginationPrevious, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginationPrevious, "a[sc-pagination-previous]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScPaginationNext extends ScButtonBase {
+    readonly variant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    private readonly paginatorService;
+    protected nextPage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginationNext, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginationNext, "a[sc-pagination-next]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScPaginationLink extends ScButtonBase {
+    protected readonly paginatorService: PaginatorService;
+    readonly page: _angular_core.InputSignal<number | "...">;
+    protected readonly isActive: _angular_core.Signal<boolean>;
+    protected readonly variant: _angular_core.WritableSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly size: _angular_core.WritableSignal<"default" | "sm" | "lg" | "icon" | null | undefined>;
+    protected selectPage(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginationLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginationLink, "a[sc-pagination-link]", never, { "page": { "alias": "page"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPaginationEllipsis {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPaginationEllipsis, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPaginationEllipsis, "span[sc-pagination-ellipsis]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface CalendarDay {
+    date: Temporal.PlainDate;
+    dayOfMonth: number;
+    isInCurrentMonth: boolean;
+}
+type View = 'days' | 'years' | 'months';
+
+declare class ScCalendar implements ControlValueAccessor {
+    readonly value: _angular_core.ModelSignal<Temporal.PlainDate | undefined>;
+    readonly min: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
+    readonly max: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly today;
+    protected readonly date: _angular_core.Signal<Temporal.PlainDate>;
+    protected readonly currentYear: _angular_core.WritableSignal<number>;
+    protected readonly previewYear: _angular_core.WritableSignal<number>;
+    protected readonly currentMonth: _angular_core.WritableSignal<Temporal.PlainYearMonth>;
+    protected readonly firstDayOfMonth: _angular_core.Signal<Temporal.PlainDate>;
+    protected readonly lastDayOfMonth: _angular_core.Signal<Temporal.PlainDate>;
+    private readonly localeId;
+    protected readonly calendarDays: _angular_core.Signal<CalendarDay[]>;
+    isToday(date: Temporal.PlainDate): boolean;
+    isDateDisabled(date: Temporal.PlainDate): boolean;
+    protected setValue(date: Temporal.PlainDate): void;
+    protected prevMonth(): void;
+    protected nextMonth(): void;
+    protected readonly view: _angular_core.WritableSignal<View>;
+    protected toggleView(): void;
+    weekdays: string[];
+    protected setMonthYear(n: number): void;
+    protected selectYear(year: number): void;
+    protected selectMonth(month: Temporal.PlainYearMonth): 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: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCalendar, "sc-calendar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+interface ScRange {
+    start: Temporal.PlainDate;
+    end: Temporal.PlainDate;
+}
+
+declare class ScRangeCalendar implements ControlValueAccessor {
+    readonly value: _angular_core.ModelSignal<ScRange | undefined>;
+    readonly minDate: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
+    readonly maxDate: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly today;
+    protected readonly focusedDate: _angular_core.WritableSignal<Temporal.PlainDate | ScRange | undefined>;
+    protected readonly currentYear: _angular_core.WritableSignal<number>;
+    protected readonly previewYear: _angular_core.WritableSignal<number>;
+    protected readonly currentMonth: _angular_core.WritableSignal<Temporal.PlainYearMonth>;
+    private readonly firstDayOfMonth;
+    private readonly lastDayOfMonth;
+    private readonly localeId;
+    protected readonly calendarDays: _angular_core.Signal<CalendarDay[]>;
+    isToday(date: Temporal.PlainDate): boolean;
+    isDateDisabled(date: Temporal.PlainDate): boolean;
+    selectRange(range: ScRange): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    protected readonly view: _angular_core.WritableSignal<"days" | "years" | "months">;
+    protected toggleView(): void;
+    weekdays: string[];
+    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: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScRangeCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+declare class ScFullCalendar implements OnInit {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    currentDate: Date;
+    currentMonth: number;
+    currentYear: number;
+    readonly currentView: _angular_core.WritableSignal<"day" | "month" | "week">;
+    daysInMonth: number[];
+    weekdays: string[];
+    events: {
+        date: string;
+        title: string;
+    }[];
+    ngOnInit(): void;
+    generateCalendar(): void;
+    goToPreviousMonth(): void;
+    goToNextMonth(): void;
+    setView(view: 'month' | 'week' | 'day'): void;
+    formatDate(day: number | null): string;
+    addEvent(date: string): void;
+    isToday(day: number | null): boolean;
+    getEventsForDate(day: number | null): {
+        date: string;
+        title: string;
+    }[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScFullCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScFullCalendar, "sc-full-calendar", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScMobileCalendar implements OnInit {
+    currentDate: Date;
+    hoursInDay: number[];
+    events: {
+        [key: string]: string[];
+    };
+    constructor();
+    ngOnInit(): void;
+    goToPreviousDay(): void;
+    goToNextDay(): void;
+    onKeydown(event: KeyboardEvent, direction: string): void;
+    addEvent(hour: number): void;
+    getEventsForTime(hour: number): string[];
+    isNow(hour: number): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMobileCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMobileCalendar, "sc-mobile-calendar", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScWeekView implements OnInit {
+    currentDate: Date;
+    weekDays: Date[];
+    constructor();
+    ngOnInit(): void;
+    getWeekDays(date: Date): Date[];
+    goToPreviousWeek(): void;
+    goToNextWeek(): void;
+    onKeydown(event: KeyboardEvent, direction: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScWeekView, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScWeekView, "sc-week-view", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScDatePicker implements ControlValueAccessor {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.ModelSignal<Temporal.PlainDate | undefined>;
+    readonly minDate: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
+    readonly maxDate: _angular_core.InputSignal<Temporal.PlainDate | undefined>;
+    private readonly localeId;
+    private readonly host;
+    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;
+    /** Selects a specific date value. */
+    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: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDatePicker, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+declare class ScDatePickerToggle extends ScButtonBase {
+    readonly variantInput: _angular_core.InputSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly toggled: _angular_core.OutputEmitterRef<void>;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDatePickerToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDatePickerToggle, "button[sc-date-picker-toggle]", never, { "variantInput": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "toggled": "toggled"; }, never, ["*"], true, never>;
+}
+
+declare class ScDateRangePicker implements OnInit {
+    readonly startDate: _angular_core.InputSignal<Temporal.PlainDate>;
+    readonly endDate: _angular_core.InputSignal<Temporal.PlainDate>;
+    readonly minDate: _angular_core.InputSignal<Temporal.PlainDate | null>;
+    readonly maxDate: _angular_core.InputSignal<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: _angular_core.ɵɵFactoryDeclaration<ScDateRangePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDateRangePicker, "sc-date-range-picker", never, { "startDate": { "alias": "startDate"; "required": false; "isSignal": true; }; "endDate": { "alias": "endDate"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; }, { "dateRangeSelected": "dateRangeSelected"; }, never, never, true, never>;
+}
+
+declare class ScNav {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScNav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNav, "nav[sc-nav]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScNavList {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScNavList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNavList, "ul[sc-nav-list]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScNavButtonBase {
+    baseClass: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScNavButtonBase, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNavButtonBase, "sc-nav-button-base", never, { "baseClass": { "alias": "baseClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScNavLink extends ScNavButtonBase {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScNavLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNavLink, "a[sc-nav-link]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScNavItem {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScNavItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNavItem, "sc-nav-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScNavItemDropdown {
+    title: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScNavItemDropdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScNavItemDropdown, "li[sc-nav-item-dropdown]", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTheme {
+    private readonly document;
+    private readonly isDarkModeSignal;
+    readonly isDarkMode: _angular_core.Signal<boolean>;
+    readonly theme: _angular_core.Signal<"light" | "dark">;
+    constructor();
+    private initializeTheme;
+    toggleTheme(): void;
+    private applyTheme;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTheme, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScTheme>;
+}
+
+declare class ScThemeToggler {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly themeService;
+    protected readonly isDarkMode: _angular_core.Signal<boolean>;
+    protected toggleTheme(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScThemeToggler, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScThemeToggler, "sc-theme-toggler", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScLink extends ScButtonBase {
+    readonly variantInput: _angular_core.InputSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    protected readonly tabindex: _angular_core.Signal<0 | -1>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScLink, "a[sc-link]", never, { "variantInput": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPlainInput {
+    private readonly hostRef;
+    readonly value: _angular_core.ModelSignal<string>;
+    handleInput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPlainInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScPlainInput, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare const scInputStyles: _angular_core.WritableSignal<string>;
+declare class ScInput {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly idInput: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.WritableSignal<string>;
+    private readonly host;
+    get nativeElement(): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInput, never>;
+    static ɵcmp: _angular_core.ɵɵ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 ScPlainInput; inputs: { "value": "value"; }; outputs: { "valueChange": "valueChange"; }; }]>;
+}
+
+declare class ScAutoResizeInput implements ControlValueAccessor {
+    private readonly changeDetectorRef;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly input: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly sizer: _angular_core.Signal<ElementRef<HTMLSpanElement>>;
+    readonly type: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly minWidth: _angular_core.InputSignal<number>;
+    readonly maxWidth: _angular_core.InputSignal<number>;
+    readonly inputClass: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.ModelSignal<string>;
+    protected readonly sizerWidth: _angular_core.WritableSignal<number>;
+    setSizerWidth(): void;
+    width: _angular_core.Signal<number>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly disabled: _angular_core.WritableSignal<boolean>;
+    constructor();
+    onChange: any;
+    onTouch: any;
+    getFont(): string;
+    onInput(event: Event): void;
+    onBlur(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAutoResizeInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAutoResizeInput, "sc-auto-resize-input", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class ScInputNumber {
+    private readonly hostRef;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.ModelSignal<number>;
+    readonly type: _angular_core.InputSignal<"number">;
+    handleInput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputNumber, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+declare class ScInputNumberIncrementer extends ScButtonBase {
+    readonly incremented: _angular_core.OutputEmitterRef<void>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputNumberIncrementer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInputNumberIncrementer, "button[sc-input-number-incrementer]", never, {}, { "incremented": "incremented"; }, never, ["*"], true, never>;
+}
+
+declare class ScInputNumberDecrementer extends ScButtonBase {
+    readonly decremented: _angular_core.OutputEmitterRef<void>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputNumberDecrementer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInputNumberDecrementer, "button[sc-input-number-decrementer]", never, {}, { "decremented": "decremented"; }, never, ["*"], true, never>;
+}
+
+declare class ScInputNumberGroup {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly scInputNumberIncrementer;
+    private readonly scInputNumberDecrementer;
+    private readonly scInputNumber;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputNumberGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInputNumberGroup, "div[sc-input-number-group]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["scInputNumberIncrementer", "scInputNumberDecrementer", "scInputNumber"], ["*"], true, never>;
+}
+
+declare class ScInputGroup {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInputGroup, "sc-input-group", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScInputPassword implements OnInit {
+    protected readonly id: string;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected control: FormControl<any>;
+    private readonly destroyRef;
+    ngOnInit(): void;
+    readonly password: _angular_core.WritableSignal<string>;
+    readonly isVisible: _angular_core.WritableSignal<boolean>;
+    readonly requirements: {
+        regex: RegExp;
+        text: string;
+    }[];
+    readonly strength: _angular_core.Signal<{
+        met: boolean;
+        text: string;
+    }[]>;
+    readonly strengthScore: _angular_core.Signal<number>;
+    protected readonly progressClass: _angular_core.Signal<string>;
+    readonly strengthColor: _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: _angular_core.Signal<"Enter a password" | "Weak password" | "Medium password" | "Strong password">;
+    protected toggleVisibility(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputPassword, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInputPassword, "sc-input-password", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScInputOTPSlot {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly showFakeCaret: _angular_core.Signal<boolean>;
+    protected readonly isActive: _angular_core.WritableSignal<boolean>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly inputRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly focus: _angular_core.OutputEmitterRef<string>;
+    readonly blur: _angular_core.OutputEmitterRef<void>;
+    readonly backspace: _angular_core.OutputEmitterRef<void>;
+    readonly arrowLeft: _angular_core.OutputEmitterRef<void>;
+    readonly arrowRight: _angular_core.OutputEmitterRef<void>;
+    readonly paste: _angular_core.OutputEmitterRef<string>;
+    readonly value: _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: _angular_core.ɵɵFactoryDeclaration<ScInputOTPSlot, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+declare class ScInputOtp implements AfterContentInit, ControlValueAccessor {
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly disabled: _angular_core.WritableSignal<boolean>;
+    private readonly changeDetectorRef;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly slots: _angular_core.Signal<readonly ScInputOTPSlot[]>;
+    readonly currentIndex: _angular_core.WritableSignal<number>;
+    readonly value: _angular_core.ModelSignal<string>;
+    type: _angular_core.InputSignal<"numeric" | "alphanumeric">;
+    constructor();
+    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;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputOtp, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+declare class ScInputOTPGroup {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputOTPGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInputOTPGroup, "sc-input-otp-group", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScInputOTPSeparator {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScInputOTPSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScInputOTPSeparator, "sc-input-otp-separator", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScLabel {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly forInput: _angular_core.InputSignal<string>;
+    readonly for: _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLabel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScLabel, "label[sc-label]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "forInput": { "alias": "for"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTextarea {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTextarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTextarea, "textarea[sc-textarea]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScOption implements Highlightable {
+    readonly id: _angular_core.WritableSignal<string>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly scSelect;
+    protected isSelected: _angular_core.Signal<boolean>;
+    readonly value: _angular_core.InputSignal<unknown>;
+    private readonly labelEl;
+    readonly label: _angular_core.Signal<string>;
+    private readonly element;
+    get nativeElement(): HTMLElement;
+    readonly active: _angular_core.WritableSignal<boolean>;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    disabled: boolean | undefined;
+    getLabel(): string;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly _disabled: _angular_core.Signal<boolean>;
+    protected toggle(): void;
+    private select;
+    private deselect;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScOption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScOption, "sc-option", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSelect implements ControlValueAccessor {
+    private readonly changeDetectorRef;
+    private readonly overlay;
+    private readonly directionality;
+    private readonly viewContainerRef;
+    private portal;
+    readonly scSelectTrigger: _angular_core.Signal<ElementRef<HTMLButtonElement>>;
+    protected readonly panelId: string;
+    readonly panelTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly options: _angular_core.Signal<readonly ScOption[]>;
+    private readonly activeDescendant;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /**
+     * Scrolls an option into view.
+     * @param option Option to be scrolled into view.
+     * @param position Position to which to align the option relative to the scrollable container.
+     */
+    scrollOptionIntoView(option: ScOption, position: ScrollLogicalPosition): void;
+    private readonly injector;
+    private readonly keyManager;
+    readonly value: _angular_core.ModelSignal<unknown>;
+    writeValue(value: unknown): void;
+    setValue(value: unknown): void;
+    onChange: (value: unknown) => void;
+    onTouched: () => void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    label: _angular_core.Signal<string | undefined>;
+    isExpanded: _angular_core.Signal<boolean>;
+    private _overlayRef;
+    private _getOverlayRef;
+    open(): void;
+    close(): void;
+    focusOnTrigger(): void;
+    /**
+     * Synchronizes the internal state of the component based on a specific selected date.
+     * @param value Currently selected date.
+     * @param options Options rendered out in the timepicker.
+     * @param fallback Option to set as active if no option is selected.
+     */
+    private syncSelectedState;
+    /** Handles keyboard events while the overlay is open. */
+    private _handleKeydown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSelect, "sc-select", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["options"], ["*"], true, never>;
+}
+
+interface ScOptionModel {
+    id: string | number;
+    label: string;
+    selected?: boolean;
+}
+declare class ScMultiSelect implements OnInit {
+    private readonly elementRef;
+    readonly options: _angular_core.InputSignal<ScOptionModel[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly searchable: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly showError: _angular_core.InputSignal<boolean>;
+    readonly errorMessage: _angular_core.InputSignal<string>;
+    selectionChange: EventEmitter<ScOptionModel[]>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    searchText: string;
+    filteredOptions: ScOptionModel[];
+    focusedIndex: number;
+    uniqueId: string;
+    labelId: string;
+    listboxId: string;
+    descriptionId: string;
+    get activeDescendant(): string | null;
+    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: _angular_core.ɵɵFactoryDeclaration<ScMultiSelect, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMultiSelect, "sc-multi-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "showError": { "alias": "showError"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+declare class ScScrollToTop {
+    private readonly overlay;
+    private readonly injector;
+    private readonly destroyRef;
+    private overlayRef;
+    private componentRef;
+    private readonly scrollThreshold;
+    init(): void;
+    private show;
+    private hide;
+    private scrollToTop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScScrollToTop, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScScrollToTop>;
+}
+
+declare class ScScrollToTopButton extends ScButtonBase {
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly showScrollButton: _angular_core.WritableSignal<boolean>;
+    protected onWindowScroll(): void;
+    protected scrollToTop(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScScrollToTopButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScScrollToTopButton, "button[sc-scroll-to-top-button]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScProgress {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    /** Current value of the progressbar. */
+    readonly value: _angular_core.InputSignal<number>;
+    readonly mode: _angular_core.InputSignal<"determinate" | "indeterminate">;
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly transform: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScProgress, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+declare class ScCircularProgress {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    protected readonly radius: _angular_core.WritableSignal<number>;
+    protected readonly stroke: _angular_core.WritableSignal<number>;
+    protected readonly normalizedRadius: _angular_core.Signal<number>;
+    protected readonly circumference: _angular_core.Signal<number>;
+    protected readonly strokeDashoffset: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCircularProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCircularProgress, "sc-circular-progress", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const sheetVariants: (props?: ({
+    side?: "left" | "right" | "top" | "bottom" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SheetVariants = VariantProps<typeof sheetVariants>;
+declare class ScSheet {
+    private readonly scSheetManager;
+    readonly state: _angular_core.Signal<"open" | "closed">;
+    readonly side: _angular_core.Signal<"left" | "right" | "top" | "bottom">;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected handleAnimationEnd(event: AnimationEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSheet, "div[sc-sheet]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSheetConfig {
+    side: 'top' | 'bottom' | 'left' | 'right';
+    width: string;
+    height: string;
+}
+
+declare class ScSheetManager {
+    private readonly overlayContainer;
+    private readonly overlay;
+    private overlayRef;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly state: _angular_core.WritableSignal<"open" | "closed">;
+    readonly side: _angular_core.WritableSignal<"left" | "right" | "top" | "bottom">;
+    constructor();
+    open(templateRef: TemplateRef<unknown>, config: ScSheetConfig): void;
+    close(): void;
+    private getOverlayConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSheetManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScSheetManager>;
+}
+
+declare class ScSheetClose {
+    private readonly scSheetManager;
+    readonly state: _angular_core.Signal<"open" | "closed">;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSheetClose, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSheetClose, "button[sc-sheet-close]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBreadcrumb {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBreadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBreadcrumb, "nav[sc-breadcrumb]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBreadcrumbList {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBreadcrumbList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBreadcrumbList, "ol[sc-breadcrumb-list]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBreadcrumbItem {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBreadcrumbItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBreadcrumbItem, "li[sc-breadcrumb-item]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBreadcrumbLink {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBreadcrumbLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBreadcrumbLink, "a[sc-breadcrumb-link]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBreadcrumbPage {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBreadcrumbPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBreadcrumbPage, "span[sc-breadcrumb-page]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBreadcrumbSeparator {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBreadcrumbSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBreadcrumbSeparator, "li[sc-breadcrumb-separator]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBreadcrumbEllipsis {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBreadcrumbEllipsis, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBreadcrumbEllipsis, "span[sc-breadcrumb-ellipsis], button[sc-breadcrumb-ellipsis]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScToggleBase {
+    readonly variant: _angular_core.InputSignal<"outline" | "default" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "sm" | "lg" | null | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly active: _angular_core.WritableSignal<boolean>;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToggleBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScToggleBase, never, never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScToggle extends ScToggleBase {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToggle, "button[sc-toggle]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScToggleGroup {
+    readonly type: _angular_core.InputSignal<"single" | "multiple">;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.InputSignal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToggleGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToggleGroup, "sc-toggle-group", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScToggleItem extends ScToggleBase {
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToggleItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToggleItem, "button[sc-toggle-item]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialog {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDialog, "div[sc-dialog]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialogHeader {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialogHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDialogHeader, "div[sc-dialog-header]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialogTitle {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialogTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDialogTitle, "h2[sc-dialog-title]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialogDescription {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialogDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDialogDescription, "p[sc-dialog-description]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialogFooter {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialogFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDialogFooter, "div[sc-dialog-footer]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialogClose {
+    private readonly scDialogManager;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialogClose, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDialogClose, "button[sc-dialog-close]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialogContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialogContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDialogContent, "div[sc-dialog-content]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDialogManager {
+    private readonly overlayContainer;
+    private readonly dialog;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly state: _angular_core.WritableSignal<"open" | "closed">;
+    constructor();
+    open(templateRef: TemplateRef<unknown>): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDialogManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScDialogManager>;
+}
+
+declare class ScAlert {
+    readonly variant: _angular_core.InputSignal<"destructive" | "default" | null | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAlert, "div[sc-alert]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAlertTitle {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAlertTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAlertTitle, "h5[sc-alert-title]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAlertDescription {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAlertDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAlertDescription, "p[sc-alert-description]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAlertDialogManager {
+    private readonly overlayContainer;
+    private readonly dialog;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly state: _angular_core.WritableSignal<"open" | "closed">;
+    constructor();
+    open(title: string, description: string, action: string): Promise<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAlertDialogManager, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScAlertDialogManager>;
+}
+
+declare class ScBadge {
+    readonly variant: _angular_core.InputSignal<"primary" | "destructive" | "outline" | "secondary" | null | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBadge, "div[sc-badge]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScScrollArea {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly state;
+    protected mouseover(): void;
+    protected mouseout(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScScrollArea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScScrollArea, "div[sc-scroll-area]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class HoverScrollbarComponent implements AfterViewInit, OnChanges {
+    readonly width: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly border: _angular_core.InputSignal<boolean>;
+    readonly contentContainer: _angular_core.Signal<ElementRef<any>>;
+    isScrollable: boolean;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    checkIfScrollable(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoverScrollbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoverScrollbarComponent, "sc-hover-scrollbar", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "border": { "alias": "border"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScrollAreaComponent implements OnDestroy, AfterViewInit {
+    readonly viewportRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    readonly thumbRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    isScrolling: boolean;
+    isHovering: boolean;
+    isDragging: boolean;
+    scrollTimeout: any;
+    thumbHeight: number;
+    thumbTop: number;
+    startY: number;
+    startScrollTop: number;
+    constructor();
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    onScroll(): void;
+    updateThumb(): void;
+    startDragging(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScrollAreaComponent, "sc-scroll-area3", never, {}, {}, never, never, true, never>;
+}
+
+declare class HorizontalScrollAreaComponent implements OnDestroy, AfterViewInit {
+    readonly viewportRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    readonly thumbRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    isScrolling: boolean;
+    isHovering: boolean;
+    isDragging: boolean;
+    scrollTimeout: any;
+    thumbWidth: number;
+    thumbLeft: number;
+    startX: number;
+    startScrollLeft: number;
+    canScrollLeft: boolean;
+    canScrollRight: boolean;
+    items: {
+        title: string;
+        description: string;
+        category: string;
+    }[];
+    constructor();
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    onScroll(): void;
+    updateThumb(): void;
+    updateScrollButtonsState(): void;
+    startDragging(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    scrollLeft(): void;
+    scrollRight(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HorizontalScrollAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HorizontalScrollAreaComponent, "sc-horizontal-scroll-area", never, {}, {}, never, never, true, never>;
+}
+
+declare class FlexibleScrollAreaComponent implements OnInit, OnDestroy, AfterViewInit {
+    readonly orientationInput: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly orientation: _angular_core.WritableSignal<"vertical" | "horizontal">;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly showNavButtons: _angular_core.InputSignal<boolean>;
+    readonly viewportRef: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    isScrolling: boolean;
+    isHovering: boolean;
+    isDragging: boolean;
+    scrollTimeout: any;
+    thumbSize: number;
+    thumbPosition: number;
+    startPoint: number;
+    startScrollPosition: number;
+    canScrollStart: boolean;
+    canScrollEnd: boolean;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    onScroll(): void;
+    updateThumb(): void;
+    updateScrollButtonsState(): void;
+    startDragging(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(): void;
+    scrollPrev(): void;
+    scrollNext(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlexibleScrollAreaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlexibleScrollAreaComponent, "sc-flexible-scroll-area", never, { "orientationInput": { "alias": "orientation"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "showNavButtons": { "alias": "showNavButtons"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCard {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCard, "div[sc-card]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCardHeader {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCardHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCardHeader, "div[sc-card-header]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCardTitle {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCardTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCardTitle, "h2[sc-card-title]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCardDescription {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCardDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCardDescription, "p[sc-card-description]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCardContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCardContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCardContent, "div[sc-card-content]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCardFooter {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCardFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCardFooter, "div[sc-card-footer]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type ToastState = 'open' | 'closed';
+
+declare class ScToast implements OnInit {
+    private readonly toaster;
+    private readonly toastService;
+    private readonly toastId;
+    readonly variant: _angular_core.InputSignal<"destructive" | "default" | null | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly state: _angular_core.Signal<ToastState | undefined>;
+    protected readonly swipe: _angular_core.WritableSignal<"start" | "end" | "cancel" | "move" | undefined>;
+    private readonly animationState;
+    constructor();
+    ngOnInit(): void;
+    protected animationend(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToast, "div[sc-toast]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScToastContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToastContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToastContent, "div[sc-toast-content]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScToastTitle {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToastTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToastTitle, "h2[sc-toast-title]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScToastDescription {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToastDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToastDescription, "p[sc-toast-description], div[sc-toast-description]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScToastAction {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToastAction, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToastAction, "button[sc-toast-action]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScToastClose {
+    private readonly toastService;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToastClose, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToastClose, "button[sc-toast-close]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class Toaster {
+    private readonly toastRefs;
+    private readonly maxToasts;
+    private readonly overlay;
+    private readonly idGenerator;
+    private readonly injector;
+    /**
+     * Show a toast notification
+     * @returns The ID of the created toast
+     */
+    show(toastTemplate: TemplateRef<unknown>): string;
+    /**
+     * Remove a specific toast by ID
+     */
+    remove(id: string): boolean;
+    /**
+     * Remove all currently displayed toasts
+     */
+    clear(): void;
+    private createToast;
+    private closeToast;
+    private updateToastPositions;
+    private createInjector;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Toaster, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Toaster>;
+}
+
+declare class ScSlider {
+    private readonly host;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.ModelSignal<number>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly type: _angular_core.InputSignal<"range">;
+    constructor();
+    protected handleInput(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSlider, "input[sc-slider]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}
+
+interface ScCheckboxChange {
+    checked: boolean;
+    value: string;
+}
+declare class ScCheckbox {
+    private readonly hostRef;
+    readonly idInput: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.WritableSignal<string>;
+    readonly type: _angular_core.InputSignal<"checkbox">;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly indeterminateInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly indeterminate;
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly change: _angular_core.OutputEmitterRef<ScCheckboxChange>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    protected handleClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCheckbox, "input[sc-checkbox]", never, { "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "indeterminateInput": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; "change": "change"; }, never, ["*"], true, never>;
+}
+
+declare class ScCheckboxGroup implements AfterContentInit, ControlValueAccessor {
+    private readonly changeDetectorRef;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<string[]>;
+    readonly checkboxes: _angular_core.Signal<readonly ScCheckbox[]>;
+    ngAfterContentInit(): void;
+    private setValue;
+    private onChange;
+    private onTouched;
+    writeValue(value: string[]): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCheckboxGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCheckboxGroup, "sc-checkbox-group", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["checkboxes"], ["*"], true, never>;
+}
+
+declare class ScCheckboxItem {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCheckboxItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCheckboxItem, "label[sc-checkbox-item]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAccordion {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAccordion, "sc-accordion", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.CdkAccordion; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScAccordionItem implements OnInit {
+    private readonly scAccordionItemState;
+    protected readonly open: _angular_core.Signal<boolean>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected readonly cdkAccordionItem: CdkAccordionItem;
+    toggle(): void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAccordionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAccordionItem, "sc-accordion-item", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["sc-accordion-header", "sc-accordion-content"], true, [{ directive: typeof i1.CdkAccordionItem; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScAccordionHeader {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAccordionHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAccordionHeader, "sc-accordion-header", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAccordionToggle {
+    private readonly scAccordionItem;
+    private readonly scAccordionItemState;
+    protected readonly state: _angular_core.Signal<"open" | "closed">;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAccordionToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAccordionToggle, "sc-accordion-toggle", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAccordionContent {
+    private readonly scAccordionItemState;
+    protected readonly state: _angular_core.Signal<"open" | "closed">;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected handleAnimationEnd(event: AnimationEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAccordionContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAccordionContent, "sc-accordion-content", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSwitch {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly idInput: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.WritableSignal<string>;
+    readonly checkedInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly checked: _angular_core.WritableSignal<boolean>;
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly type: _angular_core.InputSignal<"checkbox">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSwitch, "input[sc-switch]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "checkedInput": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+declare class ScRadioGroup implements ControlValueAccessor {
+    private readonly changeDetectorRef;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.ModelSignal<string | undefined>;
+    setValue(newValue: string): void;
+    writeValue(value: string): void;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScRadioGroup, "sc-radio-group", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}
+
+declare class ScRadio {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly type: _angular_core.InputSignal<"radio">;
+    private readonly scRadioGroup;
+    protected readonly name: _angular_core.Signal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly idInput: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.WritableSignal<string>;
+    protected readonly checked: _angular_core.Signal<boolean>;
+    protected select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScRadio, "input[sc-radio]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScRadioItem {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly id: _angular_core.WritableSignal<string>;
+    readonly scLabel: _angular_core.Signal<ScLabel | undefined>;
+    readonly scRadio: _angular_core.Signal<ScRadio | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScRadioItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScRadioItem, "sc-radio-item", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["scLabel", "scRadio"], ["*"], true, never>;
+}
+
+declare class ScHoverCard {
+    readonly templateRef: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScHoverCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScHoverCard, "sc-hover-card", never, { "templateRef": { "alias": "templateRef"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScHoverCardTriggerFor implements OnDestroy {
+    private readonly element;
+    private readonly overlay;
+    private readonly viewContainer;
+    readonly scHoverCardTriggerFor: _angular_core.InputSignal<TemplateRef<unknown>>;
+    private overlayRef;
+    showCard(): void;
+    hideCard(): void;
+    ngOnDestroy(): void;
+    private attachTooltip;
+    private getPositionStrategy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScHoverCardTriggerFor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScHoverCardTriggerFor, "[scHoverCardTriggerFor]", never, { "scHoverCardTriggerFor": { "alias": "scHoverCardTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScAvatar {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAvatar, "sc-avatar", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class AvatarState {
+    readonly state: _angular_core.WritableSignal<"error" | "loading" | "loaded">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AvatarState>;
+}
+
+declare class ScAvatarImage {
+    readonly avatarState: AvatarState;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    protected handleLoad(): void;
+    protected handleError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAvatarImage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAvatarImage, "img[sc-avatar-image]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAvatarFallback {
+    readonly avatarState: AvatarState;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAvatarFallback, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAvatarFallback, "div[sc-avatar-fallback]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAspectRatio {
+    readonly ratio: _angular_core.InputSignal<number>;
+    protected readonly padding: _angular_core.Signal<string>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAspectRatio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAspectRatio, "sc-aspect-ratio", never, { "ratio": { "alias": "ratio"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSkeleton {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSkeleton, "sc-skeleton", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTable {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTable, "table[sc-table]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableContainer {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableContainer, "div[sc-table-container]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableHeaderGroup {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableHeaderGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableHeaderGroup, "thead[sc-table-header-group]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableBody {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableBody, "tbody[sc-table-body]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableFooter {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableFooter, "tfoot[sc-table-footer]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableHeader {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableHeader, "th[sc-table-header]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableRow {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableRow, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableRow, "tr[sc-table-row]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableCell {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableCell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableCell, "td[sc-table-cell]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTableCaption {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableCaption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableCaption, "caption[sc-table-caption]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDataTable {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDataTable, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDataTable, "sc-data-table", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScPopoverTriggerFor implements OnDestroy {
+    private readonly element;
+    private readonly overlay;
+    private readonly viewContainer;
+    readonly scPopoverTriggerFor: _angular_core.InputSignal<TemplateRef<unknown>>;
+    private overlayRef;
+    open(): void;
+    close(): void;
+    ngOnDestroy(): void;
+    private attachTooltip;
+    private getPositionStrategy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPopoverTriggerFor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScPopoverTriggerFor, "[scPopoverTriggerFor]", never, { "scPopoverTriggerFor": { "alias": "scPopoverTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScContextMenuTriggerFor {
+    readonly scContextMenuTriggerFor: _angular_core.InputSignal<TemplateRef<unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScContextMenuTriggerFor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScContextMenuTriggerFor, "[scContextMenuTriggerFor]", never, { "scContextMenuTriggerFor": { "alias": "scContextMenuTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.CdkContextMenuTrigger; inputs: { "cdkContextMenuTriggerFor": "scContextMenuTriggerFor"; }; outputs: {}; }]>;
+}
+
+declare class ScMenu {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenu, "div[sc-menu]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenu; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScMenuLabel {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    readonly _inset: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuLabel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuLabel, "sc-menu-label", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "_inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScMenuShortcut {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuShortcut, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuShortcut, "span[sc-menu-shortcut]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScMenuSeparator {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuSeparator, "hr[sc-menu-separator]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScMenuGroup {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly _class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuGroup, "sc-menu-group", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScMenuItem {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    readonly _inset: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuItem, "button[sc-menu-item]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "_inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItem; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScMenuCheckboxItem {
+    private readonly _cdkMenuItemCheckbox;
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    readonly scChecked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly scTriggered: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuCheckboxItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuCheckboxItem, "button[sc-menu-checkbox-item]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "scChecked": { "alias": "scChecked"; "required": false; "isSignal": true; }; }, { "scTriggered": "scTriggered"; }, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItemCheckbox; inputs: { "cdkMenuItemChecked": "scChecked"; }; outputs: { "cdkMenuItemTriggered": "scTriggered"; }; }]>;
+}
+
+declare class ScMenuRadioGroup {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuRadioGroup, "div[sc-menu-radio-group]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScMenuRadioItem {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    value: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuRadioItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuRadioItem, "button[sc-menu-radio-item]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItemRadio; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScMenuTriggerFor {
+    readonly scMenuTriggerFor: _angular_core.InputSignal<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuTriggerFor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScMenuTriggerFor, "[scMenuTriggerFor]", never, { "scMenuTriggerFor": { "alias": "scMenuTriggerFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "scMenuTriggerFor"; }; outputs: {}; }]>;
+}
+
+declare class ScMenuCheckboxGroup {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuCheckboxGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuCheckboxGroup, "div[sc-menu-checkbox-group]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScMenuBar {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuBar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuBar, "div[sc-menu-bar]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuBar; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScMenuBarItem {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScMenuBarItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScMenuBarItem, "button[sc-menu-bar-item]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1$1.CdkMenuItem; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScCommand {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommand, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommand, "sc-command", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandInput {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    placeholder: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandInput, "sc-command-input", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScCommandList {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandList, "sc-command-list", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandEmpty {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandEmpty, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandEmpty, "sc-command-empty", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandGroup {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    heading: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandGroup, "sc-command-group", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandItem {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandItem, "sc-command-item", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandShortcut {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandShortcut, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandShortcut, "sc-command-shortcut", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandSeparator {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandSeparator, "sc-command-separator", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandDialog {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandDialog, "sc-command-dialog", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandError {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandError, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandError, "sc-command-error", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCommandLoading {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCommandLoading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCommandLoading, "sc-command-loading", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCollapsible {
+    private readonly state;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCollapsible, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCollapsible, "sc-collapsible", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScCollapsibleToggle {
+    private readonly state;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCollapsibleToggle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScCollapsibleToggle, "[sc-collapsible-toggle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScCollapsibleContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly el;
+    readonly template: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    private readonly state;
+    private readonly open;
+    protected readonly contentShown: _angular_core.Signal<boolean | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCollapsibleContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCollapsibleContent, "sc-collapsible-content", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["template"], ["*"], true, never>;
+}
+
+declare class ScSidebarState {
+    open: _angular_core.WritableSignal<boolean>;
+    openMobile: _angular_core.WritableSignal<boolean>;
+    isMobile: _angular_core.WritableSignal<boolean>;
+    toggleSidebar(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScSidebarState>;
+}
+
+declare class ScSidebar {
+    private readonly observer;
+    sidebarState: ScSidebarState;
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    side: _angular_core.InputSignal<"left" | "right">;
+    variant: _angular_core.InputSignal<"inset" | "sidebar" | "floating">;
+    collapsible: _angular_core.InputSignal<"icon" | "offcanvas" | "none">;
+    isMobile: _angular_core.Signal<boolean>;
+    openMobile: _angular_core.Signal<boolean>;
+    state: _angular_core.Signal<"expanded" | "collapsed">;
+    classes1: _angular_core.WritableSignal<string>;
+    classes2: _angular_core.WritableSignal<string>;
+    constructor();
+    private readonly scSheetTrigger;
+    readonly sheetRef: _angular_core.Signal<TemplateRef<unknown>>;
+    openSheet(side: 'top' | 'bottom' | 'left' | 'right'): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebar, "sc-sidebar", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarContent, "sc-sidebar-content", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarProvider {
+    sidebarState: ScSidebarState;
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    styles: _angular_core.WritableSignal<string>;
+    stateMobile: _angular_core.Signal<"open" | "closed">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarProvider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarProvider, "sc-sidebar-provider", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarToggler extends ScButtonBase {
+    private readonly sidebarState;
+    readonly variantInput: _angular_core.InputSignal<"primary" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined>;
+    readonly sizeInput: _angular_core.InputSignal<"default" | "sm" | "lg" | "icon" | null | undefined>;
+    protected toggleSidebar(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarToggler, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarToggler, "button[sc-sidebar-toggler]", never, { "variantInput": { "alias": "variantInput"; "required": false; "isSignal": true; }; "sizeInput": { "alias": "sizeInput"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarGroup {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarGroup, "sc-sidebar-group", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarGroupLabel {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarGroupLabel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarGroupLabel, "sc-sidebar-group-label", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarGroupAction {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarGroupAction, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarGroupAction, "sc-sidebar-group-action", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarGroupContent {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarGroupContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarGroupContent, "div[sc-sidebar-group-content]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarMenu {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarMenu, "ul[sc-sidebar-menu]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarMenuItem {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarMenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarMenuItem, "li[sc-sidebar-menu-item]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScSidebarMenuBase {
+    readonly classInput: _angular_core.InputSignal<string>;
+    readonly variant: _angular_core.InputSignal<"outline" | "default" | null | undefined>;
+    readonly size: _angular_core.InputSignal<"default" | "sm" | "lg" | null | undefined>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarMenuBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScSidebarMenuBase, never, never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScSidebarMenuLink extends ScSidebarMenuBase {
+    protected readonly routerLinkActive: RouterLinkActive;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarMenuLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarMenuLink, "a[sc-sidebar-menu-link]", never, {}, {}, never, ["*"], true, [{ directive: typeof i1$2.RouterLinkActive; inputs: {}; outputs: {}; }]>;
+}
+
+declare class ScSidebarMenuButton extends ScSidebarMenuBase {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSidebarMenuButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSidebarMenuButton, "button[sc-sidebar-menu-button]", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface ScAutocompleteModel {
+    id: string;
+    label: string;
+}
+
+declare class ScAutocompleteItem implements Highlightable {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    readonly _disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    item: _angular_core.InputSignal<ScAutocompleteModel>;
+    selectedItem: _angular_core.InputSignal<ScAutocompleteModel | undefined>;
+    isSelected: _angular_core.Signal<boolean>;
+    private readonly _isActive;
+    disabled: boolean | undefined;
+    getLabel?(): string;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAutocompleteItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAutocompleteItem, "sc-autocomplete-item", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "_disabled": { "alias": "_disabled"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; "selectedItem": { "alias": "selectedItem"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScAutocomplete implements AfterViewInit {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    items: _angular_core.WritableSignal<ScAutocompleteModel[]>;
+    searchControl: FormControl<any>;
+    input: _angular_core.Signal<any>;
+    filteredItems: _angular_core.Signal<ScAutocompleteModel[]>;
+    selectedItem: _angular_core.WritableSignal<ScAutocompleteModel | undefined>;
+    readonly viewItems: _angular_core.Signal<readonly ScAutocompleteItem[]>;
+    private keyManager;
+    ngAfterViewInit(): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScAutocomplete, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScAutocomplete, "sc-autocomplete", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTimeOption implements Highlightable {
+    /** The unique ID of the option. */
+    id: _angular_core.WritableSignal<string>;
+    class: _angular_core.InputSignal<string>;
+    _class: _angular_core.Signal<string>;
+    _active: _angular_core.WritableSignal<boolean>;
+    _selected: _angular_core.WritableSignal<boolean>;
+    readonly _disabledByInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly _disabled: _angular_core.Signal<boolean>;
+    value: _angular_core.InputSignal<string | undefined>;
+    setActiveStyles(): void;
+    setInactiveStyles(): void;
+    disabled: boolean | undefined;
+    getLabel?(): string;
+    private readonly _element;
+    /** Gets the host DOM element. */
+    _getHostElement(): HTMLElement;
+    /** Selects the option. */
+    select(): void;
+    /** Deselects the option. */
+    deselect(): void;
+    onClick(): void;
+    selected: _angular_core.OutputEmitterRef<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTimeOption, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTimeOption, "sc-time-option", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "_disabledByInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Time selection option that can be displayed within a `mat-timepicker`.
+ */
+interface MatTimepickerOption<D = unknown> {
+    /** Date value of the option. */
+    value: D;
+    /** Label to show to the user. */
+    label: string;
+}
+/** Event emitted when a value is selected in the timepicker. */
+interface MatTimepickerSelected<D> {
+    value: D;
+}
+declare class ScTimePicker implements OnDestroy {
+    settings: ScSettings;
+    clock: InputSignal<"am-pm" | "24-hour" | undefined>;
+    _clock: Signal<"am-pm" | "24-hour" | undefined>;
+    class: InputSignal<string>;
+    classes: Signal<string>;
+    private readonly _overlay;
+    private readonly _dir;
+    private readonly _viewContainerRef;
+    private readonly _injector;
+    private readonly _isOpen;
+    private readonly _activeDescendant;
+    private readonly _input;
+    private _overlayRef;
+    private _portal;
+    private readonly _optionsCacheKey;
+    private readonly _localeChanges;
+    private _onOpenRender;
+    protected _panelTemplate: Signal<TemplateRef<unknown>>;
+    protected _timeOptions: readonly MatTimepickerOption<string>[];
+    protected _options: Signal<readonly ScTimeOption[]>;
+    private readonly _keyManager;
+    /**
+     * Interval between each option in the timepicker. The value can either be an amount of
+     * seconds (e.g. 90) or a number with a unit (e.g. 45m). Supported units are `s` for seconds,
+     * `m` for minutes or `h` for hours.
+     */
+    /**
+     * Array of pre-defined options that the user can select from, as an alternative to using the
+     * `interval` input. An error will be thrown if both `options` and `interval` are specified.
+     */
+    readonly options: InputSignal<readonly MatTimepickerOption<string>[] | null>;
+    /** Whether the timepicker is open. */
+    readonly isOpen: Signal<boolean>;
+    /** Emits when the user selects a time. */
+    readonly selected: OutputEmitterRef<MatTimepickerSelected<string>>;
+    /** Emits when the timepicker is opened. */
+    readonly opened: OutputEmitterRef<void>;
+    /** Emits when the timepicker is closed. */
+    readonly closed: OutputEmitterRef<void>;
+    /** ID of the active descendant option. */
+    readonly activeDescendant: Signal<string | null>;
+    /** Unique ID of the timepicker's panel */
+    readonly panelId: string;
+    /** Whether ripples within the timepicker should be disabled. */
+    /** ARIA label for the timepicker panel. */
+    readonly ariaLabel: InputSignal<string | null>;
+    /** ID of the label element for the timepicker panel. */
+    readonly ariaLabelledby: InputSignal<string | null>;
+    /** Whether the timepicker is currently disabled. */
+    readonly disabled: Signal<boolean>;
+    constructor();
+    /** Opens the timepicker. */
+    open(): void;
+    /** Closes the timepicker. */
+    close(): void;
+    /** Registers an input with the timepicker. */
+    ngOnDestroy(): void;
+    /** Selects a specific time value. */
+    protected _selectValue(value: string): void;
+    /** Gets the value of the `aria-labelledby` attribute. */
+    protected _getAriaLabelledby(): string | null;
+    /** Creates an overlay reference for the timepicker panel. */
+    private _getOverlayRef;
+    /** Generates the list of options from which the user can select.. */
+    private _generateOptions;
+    /**
+     * Synchronizes the internal state of the component based on a specific selected date.
+     * @param value Currently selected date.
+     * @param options Options rendered out in the timepicker.
+     * @param fallback Option to set as active if no option is selected.
+     */
+    private _syncSelectedState;
+    /** Handles keyboard events while the overlay is open. */
+    private _handleKeydown;
+    /** Sets up the logic that updates the timepicker when the locale changes. */
+    private _handleLocaleChanges;
+    /**
+     * Sets up the logic that updates the timepicker when the state of the connected input changes.
+     */
+    private _handleInputStateChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTimePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTimePicker, "sc-time-picker", never, { "clock": { "alias": "clock"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, { "selected": "selected"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class ScTimePicker2 implements OnInit {
+    readonly initialTime: _angular_core.InputSignal<string | undefined>;
+    readonly timeSelected: _angular_core.OutputEmitterRef<string>;
+    isOpen: boolean;
+    hours: number[];
+    minutes: number[];
+    periods: string[];
+    selectedHour: number;
+    selectedMinute: number;
+    selectedPeriod: string;
+    ngOnInit(): void;
+    parseInitialTime(time: string): void;
+    toggleDropdown(): void;
+    selectHour(hour: number): void;
+    selectMinute(minute: number): void;
+    selectPeriod(period: string): void;
+    formatTime(hour: number, minute: number, period: string): string;
+    confirmSelection(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTimePicker2, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTimePicker2, "sc-time-picker2", never, { "initialTime": { "alias": "initialTime"; "required": false; "isSignal": true; }; }, { "timeSelected": "timeSelected"; }, never, never, true, never>;
+}
+
+declare class ScSeparator {
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScSeparator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScSeparator, "sc-separator", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScFileUpload {
+    private readonly http;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly acceptedFileTypes: _angular_core.InputSignal<string>;
+    readonly maxFileSize: _angular_core.InputSignal<number>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly uploadUrl: _angular_core.InputSignal<string>;
+    uploadComplete: EventEmitter<any>;
+    files: File[];
+    isDragging: boolean;
+    uploadProgress: number;
+    isUploading: boolean;
+    uploadError: string | null;
+    uploadSuccess: boolean;
+    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: _angular_core.ɵɵFactoryDeclaration<ScFileUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScFileUpload, "sc-file-upload", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "acceptedFileTypes": { "alias": "acceptedFileTypes"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "uploadUrl": { "alias": "uploadUrl"; "required": false; "isSignal": true; }; }, { "uploadComplete": "uploadComplete"; }, never, never, true, never>;
+}
+
+declare class ScPageTitle {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPageTitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPageTitle, "h1[sc-page-title]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPageSubtitle {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPageSubtitle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPageSubtitle, "h2[sc-page-subtitle]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScPageDescription {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScPageDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScPageDescription, "p[sc-page-description]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class Section {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Section, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Section, "sc-section", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScHeading {
+    readonly level: _angular_core.InputSignal<"1" | "2" | "3" | "4" | "5" | "6" | null | undefined>;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly underline: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScHeading, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScHeading, "h1[sc-heading], h2[sc-heading], h3[sc-heading], h4[sc-heading], h5[sc-heading], h6[sc-heading]", never, { "level": { "alias": "level"; "required": false; "isSignal": true; }; "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "underline": { "alias": "underline"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const scArticleClasses: _angular_core.WritableSignal<string>;
+declare class ScArticle {
+    class: _angular_core.InputSignal<string>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScArticle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScArticle, "sc-article", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScBlockquote {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScBlockquote, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScBlockquote, "blockquote[sc-blockquote]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class ScCookieConsent {
+    open: _angular_core.WritableSignal<boolean>;
+    hidden: _angular_core.WritableSignal<boolean>;
+    class: _angular_core.WritableSignal<string>;
+    accept(): void;
+    decline(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCookieConsent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCookieConsent, "sc-cookie-consent", never, {}, {}, never, never, true, never>;
+}
+
+interface ScUserModel {
+    id: number;
+    name: string;
+    avatar: string;
+}
+interface ScCommentModel {
+    id: number;
+    author: string;
+    avatar: string;
+    content: string;
+    timestamp: Date;
+    likes: number;
+    replies: ScCommentModel[];
+}
+
+declare class ScComments {
+    private readonly fb;
+    readonly comments: _angular_core.InputSignal<ScCommentModel[]>;
+    readonly currentUser: _angular_core.InputSignal<ScUserModel>;
+    protected readonly commentForm: FormGroup;
+    constructor();
+    onSubmit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScComments, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScComments, "sc-comments", never, { "comments": { "alias": "comments"; "required": true; "isSignal": true; }; "currentUser": { "alias": "currentUser"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTags {
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly helperText: _angular_core.InputSignal<string>;
+    readonly maxTags: _angular_core.InputSignal<number>;
+    readonly minLength: _angular_core.InputSignal<number>;
+    readonly maxLength: _angular_core.InputSignal<number>;
+    readonly tagsInput: _angular_core.InputSignal<string[]>;
+    protected readonly tags: _angular_core.WritableSignal<string[]>;
+    readonly tagsChange: _angular_core.OutputEmitterRef<string[]>;
+    tagControl: FormControl<string | null>;
+    error: string;
+    onKeydown(event: KeyboardEvent): void;
+    addTag(): void;
+    removeTag(tagToRemove: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTags, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTags, "sc-tags", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "maxTags": { "alias": "maxTags"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "tagsInput": { "alias": "tags"; "required": false; "isSignal": true; }; }, { "tagsChange": "tagsChange"; }, never, never, true, never>;
+}
+
+declare class ScCombobox implements OnInit {
+    private readonly elementRef;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<any[]>;
+    readonly optionTemplate: _angular_core.InputSignal<any>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly labelKey: _angular_core.InputSignal<string>;
+    readonly optionSelected: _angular_core.OutputEmitterRef<any>;
+    readonly search: _angular_core.OutputEmitterRef<string>;
+    searchControl: FormControl<string | null>;
+    isOpen: boolean;
+    activeIndex: number;
+    filteredOptions: any[];
+    listboxId: string;
+    private closeTimeout?;
+    get activeId(): string;
+    constructor();
+    ngOnInit(): void;
+    handleButtonInteraction(event: MouseEvent): void;
+    onButtonKeydown(event: KeyboardEvent): void;
+    handleOptionClick(event: MouseEvent, option: any): void;
+    onOptionKeydown(event: KeyboardEvent, option: any): void;
+    moveActiveIndex(delta: number): void;
+    setActiveIndex(index: number): void;
+    onClickOutside(event: Event): void;
+    toggleDropdown(): void;
+    open(): void;
+    close(): void;
+    onFocus(): void;
+    onBlur(): void;
+    onSearch(query: string): void;
+    filterOptions(): void;
+    selectOption(option: any): void;
+    getOptionLabel(option: any): string;
+    onKeydown(event: KeyboardEvent): void;
+    private scrollActiveOptionIntoView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScCombobox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScCombobox, "sc-combobox", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "labelKey": { "alias": "labelKey"; "required": false; "isSignal": true; }; }, { "optionSelected": "optionSelected"; "search": "search"; }, never, never, true, never>;
+}
+
+declare class ScClockPicker implements OnInit {
+    readonly clockFace: _angular_core.Signal<ElementRef<any>>;
+    readonly initialTime: _angular_core.InputSignal<string | undefined>;
+    readonly timeSelected: _angular_core.OutputEmitterRef<string>;
+    hours: number[];
+    periods: string[];
+    selectedHour: number;
+    selectedMinute: number;
+    selectedPeriod: string;
+    isDragging: boolean;
+    isHourMode: boolean;
+    private readonly moveHandler;
+    private readonly endHandler;
+    constructor();
+    ngOnInit(): void;
+    parseInitialTime(time: string): void;
+    startHourDrag(event: MouseEvent | TouchEvent): void;
+    startMinuteDrag(event: MouseEvent | TouchEvent): void;
+    private startDrag;
+    private handleMove;
+    private stopDrag;
+    getHourDegrees(): number;
+    getMinuteDegrees(): number;
+    selectPeriod(period: string): void;
+    formatTime(hour: number, minute: number, period: string): string;
+    emitTimeChange(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScClockPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScClockPicker, "sc-clock-picker", never, { "initialTime": { "alias": "initialTime"; "required": false; "isSignal": true; }; }, { "timeSelected": "timeSelected"; }, never, never, true, never>;
+}
+
+declare class ScClockPicker2 {
+    protected readonly isHourMode: _angular_core.WritableSignal<boolean>;
+    protected readonly selectedHour: _angular_core.WritableSignal<number>;
+    protected readonly selectedMinute: _angular_core.WritableSignal<number>;
+    protected numToDisplay(number: number): number;
+    protected readonly formattedHour: _angular_core.Signal<string>;
+    protected readonly formattedMinute: _angular_core.Signal<string>;
+    generateClockNumbers: _angular_core.Signal<{
+        number: number;
+        style: {
+            left: string;
+            top: string;
+        };
+    }[]>;
+    handleNumberClick: (num: number) => void;
+    getHandRotation: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScClockPicker2, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScClockPicker2, "sc-clock-picker2", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScImagePlaceholder {
+    private readonly placeholderService;
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly width: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly text: _angular_core.InputSignal<string>;
+    protected readonly placeholderSrc: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScImagePlaceholder, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScImagePlaceholder, "img[sc-image-placeholder]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScDescription {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDescription, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScDescription, "p[sc-description]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScErrorMessage {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScErrorMessage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScErrorMessage, "sc-error-message", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScField {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly id: _angular_core.WritableSignal<string>;
+    readonly scLabel: _angular_core.Signal<ScLabel | undefined>;
+    readonly scInput: _angular_core.Signal<ScInput | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScField, "sc-field", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["scLabel", "scInput"], ["*"], true, never>;
+}
+
+declare class ScFieldset {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScFieldset, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScFieldset, "fieldset[sc-fieldset]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScLegend {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScLegend, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScLegend, "legend[sc-legend]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTouchArea {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTouchArea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTouchArea, "span[sc-touch-area]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScScrollSpy implements OnInit {
+    private readonly el;
+    readonly spySections: _angular_core.InputSignal<string[]>;
+    readonly sectionChange: _angular_core.OutputEmitterRef<string>;
+    private observer;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScScrollSpy, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScScrollSpy, "[scScrollSpy]", never, { "spySections": { "alias": "spySections"; "required": false; "isSignal": true; }; }, { "sectionChange": "sectionChange"; }, never, never, true, never>;
+}
+
+declare class ScColorPicker implements OnInit {
+    readonly initialColorInput: _angular_core.InputSignal<string>;
+    readonly initialColor: _angular_core.WritableSignal<string>;
+    readonly colorChange: _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: _angular_core.ɵɵFactoryDeclaration<ScColorPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScColorPicker, "sc-color-picker", never, { "initialColorInput": { "alias": "initialColor"; "required": false; "isSignal": true; }; }, { "colorChange": "colorChange"; }, never, never, true, never>;
+}
+
+declare class ScToggleSwitch {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScToggleSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScToggleSwitch, "button[sc-toggle-switch]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScRangeSlider {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly type: _angular_core.InputSignal<"range">;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScRangeSlider, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+declare class ScDualRangeSlider {
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    minValue: number;
+    maxValue: number;
+    readonly minValueChange: _angular_core.OutputEmitterRef<number>;
+    readonly maxValueChange: _angular_core.OutputEmitterRef<number>;
+    get minPercentage(): number;
+    get maxPercentage(): number;
+    onMinChange(event: Event): void;
+    onMaxChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScDualRangeSlider, never>;
+    static ɵcmp: _angular_core.ɵɵ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>;
+}
+
+interface ScSection {
+    id: string;
+    title: string;
+    element: HTMLElement;
+}
+declare class ScTableOfContents implements AfterViewInit, OnDestroy {
+    private readonly elementRef;
+    sections: _angular_core.WritableSignal<ScSection[]>;
+    activeSection: _angular_core.WritableSignal<string>;
+    private observer;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private initializeToc;
+    private setupIntersectionObserver;
+    scrollToSection(event: Event, sectionId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTableOfContents, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTableOfContents, "sc-table-of-contents", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScStepper extends CdkStepper implements OnInit {
+    readonly stepCompleteEvent: _angular_core.InputSignal<EventEmitter<void>>;
+    ngOnInit(): void;
+    onClick(index: number): void;
+    complete(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStepper, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScStepper, "sc-stepper", never, { "stepCompleteEvent": { "alias": "stepCompleteEvent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScStep extends CdkStep {
+    label: string;
+    content: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScStep, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScStep, "sc-step", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScRating implements OnInit, OnChanges {
+    readonly maxRating: _angular_core.InputSignal<number>;
+    readonly ratingInput: _angular_core.InputSignal<number>;
+    readonly rating: _angular_core.WritableSignal<number>;
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    readonly showRatingValue: _angular_core.InputSignal<boolean>;
+    readonly allowHalfStars: _angular_core.InputSignal<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: _angular_core.ɵɵFactoryDeclaration<ScRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScRating, "sc-rating", never, { "maxRating": { "alias": "maxRating"; "required": false; "isSignal": true; }; "ratingInput": { "alias": "rating"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "showRatingValue": { "alias": "showRatingValue"; "required": false; "isSignal": true; }; "allowHalfStars": { "alias": "allowHalfStars"; "required": false; "isSignal": true; }; }, { "ratingChange": "ratingChange"; }, never, never, true, never>;
+}
+
+interface NavItem {
+    id: string;
+    text: string;
+    level: number;
+    children: NavItem[];
+}
+declare class ScOnThisPage implements OnInit, OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    private observer;
+    private readonly observedElements;
+    protected readonly navItems: _angular_core.WritableSignal<NavItem[]>;
+    protected readonly activeItem: _angular_core.WritableSignal<string>;
+    private readonly destroy$;
+    private isObserving;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initNavItems;
+    getPaddingClass(level: number): string;
+    scrollToSection(id: string): void;
+    private initIntersectionObserver;
+    private setupScrollListener;
+    private startObserving;
+    private stopObserving;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScOnThisPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScOnThisPage, "sc-on-this-page", never, {}, {}, never, never, true, never>;
+}
+
+declare class ScTab {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.InputSignal<string>;
+    private readonly scTabsService;
+    protected readonly isActive: _angular_core.Signal<boolean>;
+    private readonly host;
+    constructor();
+    protected selectTab(): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTab, "button[sc-tab]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTabs {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    readonly value: _angular_core.InputSignal<string>;
+    private readonly scTabsService;
+    readonly tabs: _angular_core.Signal<readonly ScTab[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTabs, "div[sc-tabs]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, ["tabs"], ["*"], true, never>;
+}
+
+declare class ScTabList {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTabList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTabList, "div[sc-tab-list]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class ScTabPanelContent {
+    readonly templateRef: TemplateRef<any>;
+    readonly tabId: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTabPanelContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ScTabPanelContent, "[scTabPanelContent]", never, { "tabId": { "alias": "scTabPanelContent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ScTabPanels {
+    readonly classInput: _angular_core.InputSignal<string>;
+    protected readonly class: _angular_core.Signal<string>;
+    private readonly scTabsService;
+    protected readonly activeTabId: _angular_core.Signal<string | undefined>;
+    protected readonly tabPanelContents: _angular_core.Signal<readonly ScTabPanelContent[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScTabPanels, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScTabPanels, "div[sc-tab-panels]", never, { "classInput": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["tabPanelContents"], never, true, never>;
+}
+
+export { FlexibleScrollAreaComponent, HorizontalScrollAreaComponent, HoverScrollbarComponent, ScAccordion, ScAccordionContent, ScAccordionHeader, ScAccordionItem, ScAccordionToggle, ScAlert, ScAlertDescription, ScAlertDialogManager, ScAlertTitle, ScArticle, ScAspectRatio, ScAutoResizeInput, ScAutocomplete, ScAvatar, ScAvatarFallback, ScAvatarImage, ScBadge, ScBlockquote, ScBreadcrumb, ScBreadcrumbEllipsis, ScBreadcrumbItem, ScBreadcrumbLink, ScBreadcrumbList, ScBreadcrumbPage, ScBreadcrumbSeparator, ScButton, ScButtonBase, ScCalendar, ScCard, ScCardContent, ScCardDescription, ScCardFooter, ScCardHeader, ScCardTitle, ScCheckbox, ScCheckboxGroup, ScCheckboxItem, ScCircularProgress, ScClockPicker, ScClockPicker2, ScCollapsible, ScCollapsibleContent, ScCollapsibleToggle, ScColorPicker, ScCombobox, ScCommand, ScCommandDialog, ScCommandEmpty, ScCommandError, ScCommandGroup, ScCommandInput, ScCommandItem, ScCommandList, ScCommandLoading, ScCommandSeparator, ScCommandShortcut, ScComments, ScContextMenuTriggerFor, ScCookieConsent, ScDataTable, ScDatePicker, ScDatePickerToggle, ScDateRangePicker, ScDescription, ScDialog, ScDialogClose, ScDialogContent, ScDialogDescription, ScDialogFooter, ScDialogHeader, ScDialogManager, ScDialogTitle, ScDualRangeSlider, ScErrorMessage, ScField, ScFieldset, ScFileUpload, ScFullCalendar, ScHeading, ScHoverCard, ScHoverCardTriggerFor, ScImagePlaceholder, ScInput, ScInputGroup, ScInputNumber, ScInputNumberDecrementer, ScInputNumberGroup, ScInputNumberIncrementer, ScInputOTPGroup, ScInputOTPSeparator, ScInputOTPSlot, ScInputOtp, ScInputPassword, ScLabel, ScLegend, ScLink, ScMenu, ScMenuBar, ScMenuBarItem, ScMenuCheckboxGroup, ScMenuCheckboxItem, ScMenuGroup, ScMenuItem, ScMenuLabel, ScMenuRadioGroup, ScMenuRadioItem, ScMenuSeparator, ScMenuShortcut, ScMenuTriggerFor, ScMobileCalendar, ScMultiSelect, ScNav, ScNavItem, ScNavItemDropdown, ScNavLink, ScNavList, ScOnThisPage, ScOption, ScPageDescription, ScPageSizeSelect, ScPageSubtitle, ScPageTitle, ScPagination, ScPaginationEllipsis, ScPaginationFirst, ScPaginationLast, ScPaginationLink, ScPaginationList, ScPaginationNext, ScPaginationPrevious, ScPaginator, ScPaginatorContainer, ScPlainInput, ScPopoverTriggerFor, ScProgress, ScRadio, ScRadioGroup, ScRadioItem, ScRangeCalendar, ScRangeSlider, ScRating, ScScrollArea, ScScrollSpy, ScScrollToTop, ScScrollToTopButton, ScSelect, ScSeparator, ScSettings, ScSheet, ScSheetClose, ScSheetConfig, ScSheetManager, ScSidebar, ScSidebarContent, ScSidebarGroup, ScSidebarGroupAction, ScSidebarGroupContent, ScSidebarGroupLabel, ScSidebarMenu, ScSidebarMenuButton, ScSidebarMenuItem, ScSidebarMenuLink, ScSidebarProvider, ScSidebarState, ScSidebarToggler, ScSkeleton, ScSlider, ScStep, ScStepper, ScSwitch, ScTab, ScTabList, ScTabPanelContent, ScTabPanels, ScTable, ScTableBody, ScTableCaption, ScTableCell, ScTableContainer, ScTableFooter, ScTableHeader, ScTableHeaderGroup, ScTableOfContents, ScTableRow, ScTabs, ScTags, ScTextarea, ScTheme, ScThemeToggler, ScTimePicker, ScTimePicker2, ScToast, ScToastAction, ScToastClose, ScToastContent, ScToastDescription, ScToastTitle, ScToggle, ScToggleGroup, ScToggleItem, ScToggleSwitch, ScTooltip, ScTouchArea, ScWeekView, ScrollAreaComponent, Section, Toaster, buttonVariants, scArticleClasses, scInputStyles };
+export type { ButtonVariants, MatTimepickerOption, MatTimepickerSelected, ScCheckboxChange, ScCommentModel, ScOptionModel, ScPageEvent, ScSection, ScUserModel, SheetVariants };