@educarehq/solaris-components 0.2.4 → 0.2.5

package/types/educarehq-solaris-components.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { ElementRef, TemplateRef, AfterContentInit, OnDestroy, EventEmitter, QueryList, OnChanges, SimpleChanges, AfterViewInit, WritableSignal, InjectionToken } from '@angular/core';
+import { ElementRef, TemplateRef, AfterContentInit, OnDestroy, EventEmitter, QueryList, OnChanges, SimpleChanges, OnInit, AfterViewInit, WritableSignal, InjectionToken } from '@angular/core';
 import { ControlValueAccessor, Validator, ValidationErrors, AbstractControl, NgControl } from '@angular/forms';
 import * as _educarehq_solaris_components from '@educarehq/solaris-components';
 import { SolarisTranslationParams } from '@educarehq/solaris-services';
@@ -124,6 +124,76 @@ declare class SolarisBreadcrumb {
     static ɵcmp: i0.ɵɵComponentDeclaration<SolarisBreadcrumb, "solaris-breadcrumb", never, { "minItems": { "alias": "min-items"; "required": false; }; "maxItems": { "alias": "max-items"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "items": { "alias": "items"; "required": true; }; }, { "itemSelect": "itemSelect"; }, never, never, true, never>;
 }
 
+declare class SolarisPopoverTriggerDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisPopoverTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisPopoverTriggerDirective, "[solaris-popover-trigger]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SolarisPopoverPanelDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisPopoverPanelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisPopoverPanelDirective, "ng-template[solaris-popover-panel]", never, {}, {}, never, never, true, never>;
+}
+
+type SolarisPopoverPlacement = 'bottom-start' | 'bottom' | 'bottom-end' | 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'left-start' | 'left' | 'left-end';
+interface SolarisPopoverPositionConfiguration {
+    placement: SolarisPopoverPlacement;
+    offset: number;
+    viewportPadding: number;
+    autoFlip: boolean;
+    autoShift: boolean;
+    matchWidth: boolean;
+}
+interface SolarisPopoverPositionResult {
+    x: number;
+    y: number;
+    appliedPlacement: SolarisPopoverPlacement;
+}
+declare function computePopoverPosition(anchorRect: DOMRect, panelRect: DOMRect, configuration: SolarisPopoverPositionConfiguration): SolarisPopoverPositionResult;
+
+declare class SolarisPopover {
+    private readonly appRef;
+    private readonly destroyRef;
+    offset: number;
+    panelClass: string;
+    autoFlip: boolean;
+    autoShift: boolean;
+    matchWidth: boolean;
+    viewportPadding: number;
+    closeOnEscape: boolean;
+    closeOnOutsideClick: boolean;
+    anchorElement?: HTMLElement | null;
+    matchWidthElement?: HTMLElement | null;
+    placement: SolarisPopoverPlacement;
+    openChange: EventEmitter<boolean>;
+    private readonly _internalOpen;
+    private readonly _openInput;
+    readonly isOpen: i0.Signal<boolean>;
+    set open(v: boolean | null);
+    get open(): boolean | null;
+    panelDir?: SolarisPopoverPanelDirective;
+    triggerDir?: SolarisPopoverTriggerDirective;
+    private raf;
+    private static seq;
+    private _setting;
+    private panelHost?;
+    private panelView?;
+    private readonly _id;
+    get dataOpen(): "true" | null;
+    constructor();
+    toggle(): void;
+    setOpen(next: boolean): void;
+    private ensureMounted;
+    private show;
+    private hide;
+    private unmountHard;
+    private scheduleReposition;
+    private reposition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisPopover, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisPopover, "solaris-popover", never, { "offset": { "alias": "offset"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "autoFlip": { "alias": "autoFlip"; "required": false; }; "autoShift": { "alias": "autoShift"; "required": false; }; "matchWidth": { "alias": "matchWidth"; "required": false; }; "viewportPadding": { "alias": "viewportPadding"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "anchorElement": { "alias": "anchorElement"; "required": false; }; "matchWidthElement": { "alias": "matchWidthElement"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, ["panelDir", "triggerDir"], ["*"], true, never>;
+}
+
 type TabsSize = 'sm' | 'md';
 type TabsVariant = 'underline' | 'pill';
 
@@ -190,41 +260,68 @@ declare class SolarisLoadingOverlay implements OnChanges {
     static ngAcceptInputType_lockScroll: any;
 }
 
-type SolarisLoadingColor = 'primary' | 'success' | 'warning' | 'error' | 'surface';
-type SolarisLoadingType = 'spinner' | 'spinner-dashed' | 'progress' | 'bar';
+type SolarisLoadingTrail = 'forward' | 'reverse';
+type SolarisLoadingSpeed = 'slow' | 'md' | 'fast';
+type SolarisLoadingDashDensity = 'low' | 'md' | 'high';
 type SolarisLoadingSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type SolarisLoadingEasing = 'linear' | 'smooth' | 'snappy';
+type LoadingType = 'spinner' | 'spinner-dashed' | 'progress' | 'bar';
+type SolarisLoadingColor = SolarisLoadingPresetColor | (string & {});
+type SolarisLoadingPresetColor = 'primary' | 'success' | 'warning' | 'error' | 'surface';
 
 declare class SolarisLoading {
     readonly marker = "";
     label?: string;
     value: number | null;
+    type: LoadingType;
     size: SolarisLoadingSize;
-    type: SolarisLoadingType;
+    speed: SolarisLoadingSpeed;
     color: SolarisLoadingColor;
+    easing: SolarisLoadingEasing;
+    trail: 'forward' | 'reverse';
+    dashDensity: SolarisLoadingDashDensity;
     indeterminate: boolean;
-    get ariaValueNow(): number | null;
     get percent(): number;
-    get role(): 'status' | 'progressbar';
     get ariaLabel(): string;
+    get dashedSpokes(): Spoke[];
+    get inlineColor(): string | null;
+    get ariaValueNow(): number | null;
+    get role(): 'status' | 'progressbar';
+    get dataColor(): SolarisLoadingPresetColor | null;
+    private get dashedCount();
     static ɵfac: i0.ɵɵFactoryDeclaration<SolarisLoading, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisLoading, "solaris-loading", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "color": { "alias": "color"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisLoading, "solaris-loading", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "color": { "alias": "color"; "required": false; }; "easing": { "alias": "easing"; "required": false; }; "trail": { "alias": "trail"; "required": false; }; "dashDensity": { "alias": "dashDensity"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; }, {}, never, never, true, never>;
     static ngAcceptInputType_indeterminate: any;
 }
+type Spoke = {
+    angle: number;
+    opacity: number;
+};
+
+type SolarisSizePreset = 'sm' | 'md' | 'lg';
+type SolarisRadiusPreset = 'none' | 'sm' | 'md' | 'lg' | 'full';
+type SolarisColorPreset = 'primary' | 'surface' | 'success' | 'warning' | 'error' | 'info' | 'gradient';
 
-type BadgeSize = 'sm' | 'md';
 type BadgeVariant = 'solid' | 'subtle' | 'outline';
-type BadgeColor = 'primary' | 'success' | 'warning' | 'error' | 'info' | 'surface';
+type BadgeColorInput = SolarisColorPreset | string & {
+    readonly __solarisCustom?: unique symbol;
+};
 
 declare class SolarisBadge {
-    hostClass: string;
     pill: boolean;
-    size: BadgeSize;
+    customTextColor?: string;
     interactive: boolean;
-    color: BadgeColor;
+    size: SolarisSizePreset;
     variant: BadgeVariant;
+    color: BadgeColorInput;
     ariaHidden: 'true' | 'false' | null;
+    hostClass: string;
+    private readonly presetColors;
+    get colorClass(): string;
+    get isCustomColor(): boolean;
+    get customColorValue(): string | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<SolarisBadge, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisBadge, "solaris-badge", never, { "pill": { "alias": "pill"; "required": false; }; "size": { "alias": "size"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "color": { "alias": "color"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "ariaHidden": { "alias": "aria-hidden"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisBadge, "solaris-badge", never, { "pill": { "alias": "pill"; "required": false; }; "customTextColor": { "alias": "customTextColor"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "ariaHidden": { "alias": "aria-hidden"; "required": false; }; }, {}, never, ["*"], true, never>;
 }
 
 interface SolarisSliderItem {
@@ -310,6 +407,304 @@ declare class SolarisDivider {
     static ɵcmp: i0.ɵɵComponentDeclaration<SolarisDivider, "solaris-divider", never, { "label": { "alias": "label"; "required": false; }; "inset": { "alias": "inset"; "required": false; }; "spacing": { "alias": "spacing"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "strength": { "alias": "strength"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "labelAlign": { "alias": "label-align"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+declare class SolarisDrawerHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisDrawerHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisDrawerHeaderDirective, "[solaris-drawer-header]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SolarisDrawerFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisDrawerFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisDrawerFooterDirective, "[solaris-drawer-footer]", never, {}, {}, never, never, true, never>;
+}
+
+type SolarisDrawerSide = 'right' | 'left' | 'bottom';
+
+declare class SolarisDrawer {
+    private readonly doc;
+    title: string;
+    titleKey: string;
+    panelClass: string;
+    backdrop: boolean;
+    showClose: boolean;
+    trapFocus: boolean;
+    backdropClass: string;
+    showHeader: boolean;
+    lockScroll: boolean;
+    restoreFocus: boolean;
+    closeOnEscape: boolean;
+    width: string;
+    side: SolarisDrawerSide;
+    height: string;
+    closeOnOutsideClick: boolean;
+    private readonly _openInput;
+    private readonly _internalOpen;
+    set open(v: boolean | null);
+    get open(): boolean | null;
+    readonly isOpen: i0.Signal<boolean>;
+    openChange: EventEmitter<boolean>;
+    headerSlot?: SolarisDrawerHeaderDirective;
+    footerSlot?: SolarisDrawerFooterDirective;
+    panelEl?: ElementRef<HTMLElement>;
+    private static seq;
+    readonly _id: string;
+    private static scrollLockCount;
+    private static prevBodyOverflow;
+    readonly titleId: string;
+    private prevFocused;
+    private static prevBodyPaddingRight;
+    get dataSide(): SolarisDrawerSide;
+    get dataOpen(): "true" | null;
+    get hasCustomHeader(): boolean;
+    get hasCustomFooter(): boolean;
+    constructor();
+    toggle(): void;
+    setOpen(next: boolean): void;
+    onBackdropClick(): void;
+    onPanelKeydown(ev: KeyboardEvent): void;
+    private onOpen;
+    private onClose;
+    private focusFirst;
+    private getFocusable;
+    private lockBodyScroll;
+    private unlockBodyScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisDrawer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisDrawer, "solaris-drawer", never, { "title": { "alias": "title"; "required": false; }; "titleKey": { "alias": "titleKey"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "backdrop": { "alias": "backdrop"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "trapFocus": { "alias": "trapFocus"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "lockScroll": { "alias": "lockScroll"; "required": false; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; "width": { "alias": "width"; "required": false; }; "side": { "alias": "side"; "required": false; }; "height": { "alias": "height"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, ["headerSlot", "footerSlot"], ["[solaris-drawer-header]", "*", "[solaris-drawer-footer]"], true, never>;
+}
+
+declare class SolarisFilterPanelFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisFilterPanelFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisFilterPanelFooterDirective, "[solaris-filter-panel-footer]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SolarisTableFilters {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisTableFilters, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisTableFilters, "solaris-table-filters", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class SolarisFilterField {
+    label: string;
+    labelKey: string;
+    active: boolean;
+    resetLabel: string;
+    resetLabelKey: string;
+    reset: EventEmitter<void>;
+    get showReset(): boolean;
+    onResetClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisFilterField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisFilterField, "solaris-filter-field", never, { "label": { "alias": "label"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "active": { "alias": "active"; "required": false; }; "resetLabel": { "alias": "resetLabel"; "required": false; }; "resetLabelKey": { "alias": "resetLabelKey"; "required": false; }; }, { "reset": "reset"; }, never, ["*"], true, never>;
+}
+
+declare class SolarisFilterPanelChipsDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisFilterPanelChipsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisFilterPanelChipsDirective, "[solaris-filter-panel-chips]", never, {}, {}, never, never, true, never>;
+}
+
+type SolarisFilterPanelRadius = 'sm' | 'md' | 'full';
+
+declare class SolarisFilterPanel {
+    count: number;
+    labelKey: string;
+    titleKey: string;
+    disabled: boolean;
+    drawerSide: 'right' | 'left';
+    radius: SolarisFilterPanelRadius;
+    drawerWidth: string;
+    label: string;
+    title: string;
+    private readonly _internalOpen;
+    private readonly _openInput;
+    private readonly _chipsSlot;
+    set open(v: boolean | null);
+    get open(): boolean | null;
+    readonly isOpen: i0.Signal<boolean>;
+    apply: EventEmitter<void>;
+    clearAll: EventEmitter<void>;
+    openChange: EventEmitter<boolean>;
+    footerSlot?: SolarisFilterPanelFooterDirective;
+    set chipsSlot(v: SolarisFilterPanelChipsDirective | undefined);
+    readonly hasChips: i0.Signal<boolean>;
+    get hasCustomFooter(): boolean;
+    setOpen(next: boolean): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisFilterPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisFilterPanel, "solaris-filter-panel", never, { "count": { "alias": "count"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "titleKey": { "alias": "titleKey"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "drawerSide": { "alias": "drawerSide"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "drawerWidth": { "alias": "drawerWidth"; "required": false; }; "label": { "alias": "label"; "required": false; }; "title": { "alias": "title"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "apply": "apply"; "clearAll": "clearAll"; "openChange": "openChange"; }, ["footerSlot", "chipsSlot"], ["[solarisFilterPanelChips]", "*", "[solarisFilterPanelFooter]"], true, never>;
+}
+
+declare class SolarisFilterChip {
+    label: string;
+    value: string;
+    labelKey: string;
+    valueKey: string;
+    disabled: boolean;
+    removable: boolean;
+    radius: SolarisRadiusPreset;
+    remove: EventEmitter<void>;
+    chipClick: EventEmitter<void>;
+    onRemoveClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisFilterChip, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisFilterChip, "solaris-filter-chip", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "valueKey": { "alias": "valueKey"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, { "remove": "remove"; "chipClick": "chipClick"; }, never, never, true, never>;
+}
+
+declare class SolarisTableSkeleton {
+    rows: number;
+    columns: number;
+    selectable: boolean;
+    gridTemplateColumns: string;
+    rowsArray(): number[];
+    colsArray(): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisTableSkeleton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisTableSkeleton, "solaris-table-skeleton", never, { "rows": { "alias": "rows"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "gridTemplateColumns": { "alias": "gridTemplateColumns"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SolarisFilterBar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisFilterBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisFilterBar, "solaris-filter-bar", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class SolarisColumnCellDef {
+    readonly template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisColumnCellDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisColumnCellDef, "ng-template[solaris-column-cell]", never, {}, {}, never, never, true, never>;
+}
+declare class SolarisColumnHeaderDef {
+    readonly template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisColumnHeaderDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisColumnHeaderDef, "ng-template[solaris-column-header]", never, {}, {}, never, never, true, never>;
+}
+
+type SolarisTableVariant = 'grid' | 'zebra';
+type SolarisAlign = 'start' | 'center' | 'end';
+type SolarisSortDirection = 'asc' | 'desc';
+type SolarisRowKey = string | number;
+interface SolarisSort {
+    key: string;
+    order: number;
+    direction: SolarisSortDirection;
+}
+interface SolarisPageChange {
+    pageSize: number;
+    pageIndex: number;
+}
+interface SolarisTableI18n {
+    ofLabelKey: string;
+    goToLabelKey: string;
+    selectedLabelKey: string;
+    rowsPerPageLabelKey: string;
+}
+
+declare class SolarisTableColumn {
+    private readonly ids;
+    readonly id: string;
+    field?: string;
+    width?: string;
+    header?: string;
+    sortKey?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    headerKey?: string;
+    headerIconClass?: string;
+    align: SolarisAlign;
+    grow: boolean;
+    resizable: boolean;
+    sortable: boolean;
+    cellDef?: SolarisColumnCellDef;
+    headerDef?: SolarisColumnHeaderDef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisTableColumn, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisTableColumn, "solaris-column", never, { "field": { "alias": "field"; "required": false; }; "width": { "alias": "width"; "required": false; }; "header": { "alias": "header"; "required": false; }; "sortKey": { "alias": "sortKey"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "headerKey": { "alias": "headerKey"; "required": false; }; "headerIconClass": { "alias": "headerIconClass"; "required": false; }; "align": { "alias": "align"; "required": false; }; "grow": { "alias": "grow"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; }, {}, ["cellDef", "headerDef"], never, true, never>;
+    static ngAcceptInputType_grow: unknown;
+    static ngAcceptInputType_resizable: unknown;
+    static ngAcceptInputType_sortable: unknown;
+}
+
+declare class SolarisTable implements AfterContentInit, OnChanges {
+    private readonly destroyRef;
+    length: number;
+    pageIndex: number;
+    pageSize: number;
+    rowsCount: number;
+    loading: boolean;
+    sort: SolarisSort[];
+    selectable: boolean;
+    tableDescription: string;
+    selection: SolarisRowKey[];
+    variant: SolarisTableVariant;
+    emptyIconClass: string;
+    pageSizeOptions: number[];
+    emptyTextKey: string;
+    sortChange: EventEmitter<SolarisSort[]>;
+    pageChange: EventEmitter<SolarisPageChange>;
+    selectionChange: EventEmitter<SolarisRowKey[]>;
+    private readonly columnQuery;
+    private readonly tableRoot;
+    readonly needsScroll: i0.WritableSignal<boolean>;
+    readonly measuredReady: i0.WritableSignal<boolean>;
+    readonly sortState: i0.WritableSignal<SolarisSort[]>;
+    private readonly measuredPx;
+    readonly columns: i0.WritableSignal<SolarisTableColumn[]>;
+    private readonly selectionSig;
+    private readonly rowKeys;
+    private readonly manualPx;
+    private readonly selectionSetSig;
+    readonly selectAllChecked: i0.Signal<boolean>;
+    readonly selectAllIndeterminate: i0.Signal<boolean>;
+    readonly selectedCount: i0.Signal<number>;
+    readonly gridTemplateColumns: i0.Signal<string>;
+    private rafId;
+    private resizeObserver?;
+    get rangeStart(): number;
+    get rangeEnd(): number;
+    get totalPages(): number;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private syncColumns;
+    private scheduleMeasure;
+    private measureColumns;
+    private measureHeaderCellWidth;
+    private measureBodyCellsWidth;
+    private measureBodyCellWidth;
+    private toPx;
+    private updateScrollFlag;
+    private clamp;
+    clearManualWidth(i: number): void;
+    onResizeStart(ev: PointerEvent, i: number): void;
+    private getHeaderCell;
+    private pxMinWidth;
+    private pxFixedWidth;
+    private reservedWidthExcept;
+    readField(row: any, path?: string): any;
+    private computeResizeMax;
+    registerRowKey(key: SolarisRowKey): void;
+    unregisterRowKey(key: SolarisRowKey): void;
+    onToggleSelectAll(checked: boolean): void;
+    toggleRow(key: SolarisRowKey, checked: boolean): void;
+    isSelected(key: SolarisRowKey): boolean;
+    getSortFor(col: SolarisTableColumn): SolarisSort | undefined;
+    onHeaderSortClick(ev: MouseEvent, col: SolarisTableColumn): void;
+    ariaSort(col: SolarisTableColumn): 'none' | 'ascending' | 'descending';
+    firstPage(): void;
+    prevPage(): void;
+    nextPage(): void;
+    lastPage(): void;
+    changePageSize(size: number): void;
+    private buildGridTemplateColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisTable, "solaris-table", never, { "length": { "alias": "length"; "required": false; }; "pageIndex": { "alias": "pageIndex"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "rowsCount": { "alias": "rowsCount"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "tableDescription": { "alias": "tableDescription"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "emptyIconClass": { "alias": "emptyIconClass"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "emptyTextKey": { "alias": "emptyTextKey"; "required": false; }; }, { "sortChange": "sortChange"; "pageChange": "pageChange"; "selectionChange": "selectionChange"; }, ["columnQuery"], ["solaris-table-filters", "solaris-row"], true, never>;
+}
+
+declare class SolarisRowComponent implements OnInit {
+    readonly table: SolarisTable;
+    private readonly destroyRef;
+    rowKey: SolarisRowKey;
+    value: any;
+    constructor(table: SolarisTable);
+    ngOnInit(): void;
+    get isSelected(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisRowComponent, [{ optional: true; host: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisRowComponent, "solaris-row", never, { "rowKey": { "alias": "rowKey"; "required": false; }; "value": { "alias": "value"; "required": true; }; }, {}, never, never, true, never>;
+}
+
 declare class SolarisHeaderDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<SolarisHeaderDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisHeaderDirective, "[solaris-header]", never, {}, {}, never, never, true, never>;
@@ -372,52 +767,119 @@ declare class SolarisPageHeader {
     static ɵcmp: i0.ɵɵComponentDeclaration<SolarisPageHeader, "solaris-page-header", never, { "layout": { "alias": "layout"; "required": false; }; "density": { "alias": "density"; "required": false; }; }, {}, ["titleSlot", "actionsSlot", "breadcrumbSlot", "descriptionSlot"], ["[solaris-page-header-breadcrumb]", "[solaris-page-header-title]", "[solaris-page-header-title-meta]", "[solaris-page-header-title-meta]", "[solaris-page-header-description]", "[solaris-page-header-actions]"], true, never>;
 }
 
-declare class SolarisButtonGroupDirective {
-    readonly attr = "";
-    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisButtonGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisButtonGroupDirective, "[solaris-button-group]", never, {}, {}, never, never, true, never>;
+type CheckboxAppearance = 'solid' | 'outline';
+type CheckboxVariant = 'square' | 'round' | 'icon';
+type CheckboxColorInput = SolarisColorPreset | SolarisCheckCustomString;
+type SolarisCheckCustomString = string & {
+    readonly __solarisCustom?: unique symbol;
+};
+
+declare class SolarisCheckbox implements ControlValueAccessor {
+    readonly indeterminate: i0.InputSignal<boolean>;
+    readonly ariaLabel: i0.InputSignal<string | null>;
+    readonly size: i0.InputSignal<SolarisSizePreset>;
+    readonly variant: i0.InputSignal<CheckboxVariant>;
+    readonly color: i0.InputSignal<CheckboxColorInput>;
+    readonly inputId: i0.InputSignal<string | null>;
+    readonly appearance: i0.InputSignal<CheckboxAppearance>;
+    readonly checkColor: i0.InputSignal<CheckboxColorInput | null>;
+    readonly checked: i0.WritableSignal<boolean>;
+    readonly disabled: i0.WritableSignal<boolean>;
+    readonly checkedChange: i0.OutputEmitterRef<boolean>;
+    readonly indeterminateChange: i0.OutputEmitterRef<boolean>;
+    private readonly native?;
+    readonly customAccent: i0.Signal<string | null>;
+    readonly colorKey: i0.Signal<SolarisColorPreset | "custom">;
+    private readonly autoId;
+    readonly id: i0.Signal<string>;
+    readonly ink: i0.Signal<string | null>;
+    private onChange;
+    private onTouched;
+    constructor();
+    onNativeChange(next: boolean): void;
+    onBlur(): void;
+    writeValue(value: boolean | null): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisCheckbox, "solaris-checkbox", never, { "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "inputId": { "alias": "id"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "checkColor": { "alias": "checkColor"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; }, never, ["*"], true, never>;
 }
 
-type SolarisButtonSize = 'sm' | 'md' | 'lg';
 type SolarisButtonVariant = 'solid' | 'outline' | 'ghost' | 'soft';
-type SolarisButtonColor = 'primary' | 'surface' | 'success' | 'warning' | 'error' | 'info' | 'gradient';
+type SolarisRadiusInput = SolarisRadiusPreset | SolarisCustomString;
+type SolarisButtonColorInput = SolarisColorPreset | SolarisCustomString;
+type SolarisCustomString = string & {
+    readonly __solarisCustom?: unique symbol;
+};
 
-declare class SolarisButtonDirective {
-    private readonly el;
-    private readonly isAnchor;
+declare class ButtonGroupDirective {
+    private _radius;
+    set radius(v: SolarisRadiusInput | null | undefined);
+    readonly attr = "";
+    get groupRadius(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonGroupDirective, "[solaris-button-group]", never, { "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ButtonDirective {
+    private readonly elementRef;
     private readonly _loading;
     private readonly _disabled;
     private readonly _iconOnly;
     private readonly _fullWidth;
+    private readonly _badgeOverlay;
+    private readonly _textColor;
+    private readonly _customColor;
     private readonly _size;
-    private readonly _color;
     private readonly _variant;
-    set size(v: SolarisButtonSize);
-    set color(v: SolarisButtonColor);
-    set fullWidth(v: boolean);
+    private readonly _radius;
+    private readonly _color;
+    private readonly isAnchor;
+    set size(v: SolarisSizePreset);
     set variant(v: SolarisButtonVariant);
+    set color(v: SolarisButtonColorInput);
+    set textColor(v: string | null | undefined);
+    set radius(v: SolarisRadiusInput | null | undefined);
     set loading(v: boolean);
-    set disabled(v: boolean);
     set iconOnly(v: boolean);
+    set disabled(v: boolean);
+    set fullWidth(v: boolean);
+    set badgeOverlay(v: boolean);
+    readonly attr = "";
     get tabIndex(): -1 | null;
+    get ariaBusy(): "true" | null;
+    get dataSize(): SolarisSizePreset;
+    get dataColor(): SolarisColorPreset | "custom";
     get nativeDisabled(): "" | null;
-    readonly attr = "";
-    get ariaDisabled(): "true" | null;
-    get dataSize(): SolarisButtonSize;
-    get dataColor(): SolarisButtonColor;
     get dataVariant(): SolarisButtonVariant;
-    get ariaBusy(): "true" | null;
+    get ariaDisabled(): "true" | null;
     get dataIconOnly(): "true" | null;
     get dataFullWidth(): "true" | null;
+    get customColorValue(): string | null;
+    get dataCustomInk(): "true" | null;
+    get customInkValue(): string | null;
+    get dataBadgeOverlay(): "true" | null;
+    get buttonRadius(): string | null;
     onClick(ev: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisButtonDirective, "button[solaris-button], a[solaris-button]", never, { "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_fullWidth: unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonDirective, "button[solaris-button], a[solaris-button]", never, { "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "color": { "alias": "color"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "badgeOverlay": { "alias": "badgeOverlay"; "required": false; }; }, {}, never, never, true, never>;
     static ngAcceptInputType_loading: unknown;
-    static ngAcceptInputType_disabled: unknown;
     static ngAcceptInputType_iconOnly: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_fullWidth: unknown;
+    static ngAcceptInputType_badgeOverlay: unknown;
+}
+
+declare class SolarisIdGenerator {
+    private readonly counters;
+    next(prefix?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisIdGenerator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SolarisIdGenerator>;
 }
 
+declare function uniqueId(prefix: string): string;
+
 type Iso2 = Lowercase<string>;
 type PhoneFormat = 'e164';
 
@@ -503,7 +965,7 @@ declare class SolarisPasswordDirective implements Validator {
     validate(control: AbstractControl): ValidationErrors | null;
     registerOnValidatorChange(fn: () => void): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SolarisPasswordDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisPasswordDirective, "input[solaris-password],input[solarisPassword]", never, { "minLength": { "alias": "minLength"; "required": false; }; "requireUpper": { "alias": "requireUpper"; "required": false; }; "requireLower": { "alias": "requireLower"; "required": false; }; "requireNumber": { "alias": "requireNumber"; "required": false; }; "requireSpecial": { "alias": "requireSpecial"; "required": false; }; "requireUpperKebab": { "alias": "requireUpperKebab"; "required": false; }; "requireLowerKebab": { "alias": "requireLowerKebab"; "required": false; }; "requireNumberKebab": { "alias": "requireNumberKebab"; "required": false; }; "minLengthKebab": { "alias": "minLengthKebab"; "required": false; }; "requireSpecialKebab": { "alias": "requireSpecialKebab"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisPasswordDirective, "input[solaris-password]", never, { "minLength": { "alias": "minLength"; "required": false; }; "requireUpper": { "alias": "requireUpper"; "required": false; }; "requireLower": { "alias": "requireLower"; "required": false; }; "requireNumber": { "alias": "requireNumber"; "required": false; }; "requireSpecial": { "alias": "requireSpecial"; "required": false; }; "requireUpperKebab": { "alias": "requireUpperKebab"; "required": false; }; "requireLowerKebab": { "alias": "requireLowerKebab"; "required": false; }; "requireNumberKebab": { "alias": "requireNumberKebab"; "required": false; }; "minLengthKebab": { "alias": "minLengthKebab"; "required": false; }; "requireSpecialKebab": { "alias": "requireSpecialKebab"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 declare class SolarisEmailDirective implements Validator {
@@ -555,17 +1017,6 @@ declare class SolarisControlBridgeDirective {
     static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisControlBridgeDirective, "input[solaris-password],input[solaris-email],input[solaris-input],textarea[solaris-input]", never, {}, {}, never, never, true, never>;
 }
 
-declare class SolarisPrefixDirective {
-    readonly attr = "";
-    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisPrefixDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisPrefixDirective, "[solaris-prefix]", never, {}, {}, never, never, true, never>;
-}
-
-declare class SolarisSuffixDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisSuffixDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisSuffixDirective, "[solaris-suffix]", never, {}, {}, never, never, true, never>;
-}
-
 declare class SolarisFormFieldController {
     features: readonly _educarehq_solaris_components.SolarisFormFieldFeature[];
     private readonly ngForm;
@@ -597,6 +1048,17 @@ interface SolarisFormFieldFeature {
 }
 declare const SOLARIS_FORM_FIELD_FEATURES: InjectionToken<readonly SolarisFormFieldFeature[]>;
 
+declare class SolarisPrefixDirective {
+    readonly attr = "";
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisPrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisPrefixDirective, "[solaris-prefix]", never, {}, {}, never, never, true, never>;
+}
+
+declare class SolarisSuffixDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisSuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisSuffixDirective, "[solaris-suffix]", never, {}, {}, never, never, true, never>;
+}
+
 declare class FieldErrorComponent {
     text?: string;
     textKey?: string;
@@ -605,6 +1067,10 @@ declare class FieldErrorComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<FieldErrorComponent, "solaris-field-error", never, { "text": { "alias": "text"; "required": false; }; "textKey": { "alias": "textKey"; "required": false; }; "textParams": { "alias": "textParams"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+type SolarisFormFieldAppearance = 'filled' | 'outline';
+type SolarisFormFieldRadius = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'full';
+type SolarisFormFieldShowErrors = 'dirtyOrTouched' | 'always' | 'submitted';
+
 declare class FormField {
     protected readonly field: SolarisFormFieldController;
     prefix?: SolarisPrefixDirective;
@@ -614,7 +1080,9 @@ declare class FormField {
     hintKey?: string;
     labelKey?: string;
     invalid: boolean | null;
-    showErrors: 'dirtyOrTouched' | 'always' | 'submitted';
+    radius: SolarisFormFieldRadius;
+    appearance: SolarisFormFieldAppearance;
+    showErrors: SolarisFormFieldShowErrors;
     private readonly _tick;
     constructor();
     get hasPrefix(): boolean;
@@ -628,8 +1096,186 @@ declare class FormField {
     } | undefined>;
     readonly errorKey: i0.Signal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormField, "solaris-form-field", never, { "hint": { "alias": "hint"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hintKey": { "alias": "hintKey"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "showErrors": { "alias": "showErrors"; "required": false; }; }, {}, ["prefix", "suffix"], ["[solaris-prefix]", "*", "[solaris-suffix]", "[form-field-message]"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormField, "solaris-form-field", never, { "hint": { "alias": "hint"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hintKey": { "alias": "hintKey"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "showErrors": { "alias": "showErrors"; "required": false; }; }, {}, ["prefix", "suffix"], ["[solaris-prefix]", "*", "[solaris-suffix]", "[form-field-message]"], true, never>;
+}
+
+type SolarisSelectNode<T = any> = SolarisSelectItem<T> | SolarisSelectDivider | SolarisSelectGroup<T>;
+type SelectionDisplay = 'auto' | 'list' | 'count';
+interface SolarisSelectItem<T = any> {
+    kind: 'item';
+    value: T;
+    label?: string;
+    labelKey?: string;
+    description?: string;
+    descriptionKey?: string;
+    icon?: string;
+    imageUrl?: string;
+    endText?: string;
+    endTextKey?: string;
+    disabled?: boolean;
+    children?: SolarisSelectNode<T>[];
+    childrenTitle?: string;
+    childrenTitleKey?: string;
+    searchText?: string;
+}
+interface SolarisSelectDivider {
+    kind: 'divider';
+}
+interface SolarisSelectGroup<T = any> {
+    kind: 'group';
+    label?: string;
+    labelKey?: string;
+    items: SolarisSelectNode<T>[];
+}
+type SolarisSelectRow = {
+    kind: 'divider';
+    key: string;
+} | {
+    kind: 'group';
+    key: string;
+    label?: string;
+    labelKey?: string;
+} | {
+    kind: 'item';
+    key: string;
+    id: string;
+    optionIndex: number;
+    item: SolarisSelectItem;
+    disabled: boolean;
+    selected: boolean;
+    hasChildren: boolean;
+    selectable: boolean;
+};
+interface StackLevel {
+    title?: string;
+    titleKey?: string;
+    nodes: SolarisSelectNode[];
+}
+
+declare class SolarisSelect implements OnInit, ControlValueAccessor, AfterViewInit {
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly field;
+    tokenEl?: ElementRef<HTMLElement>;
+    measureSlot?: ElementRef<HTMLElement>;
+    triggerWrap?: ElementRef<HTMLElement>;
+    triggerInput?: ElementRef<HTMLInputElement>;
+    get dataOpen(): "true" | null;
+    get dataCompact(): "true" | null;
+    private readonly _rootNodes;
+    set items(v: SolarisSelectNode[] | null | undefined);
+    private sameCvaValue;
+    private _multiple;
+    set multiple(v: boolean);
+    get multiple(): boolean;
+    valueKey?: string;
+    backKey: string;
+    placeholder: string;
+    placeholderKey: string;
+    searchable: boolean;
+    selectedCountKey: string;
+    selectedFirst: boolean;
+    searchPlaceholder: string;
+    selectedCountText: string;
+    panelMaxHeight: string;
+    searchPlaceholderKey: string;
+    selectionSeparator: string;
+    compareWith?: (a: any, b: any) => boolean;
+    backText: string;
+    selectionDisplay: SelectionDisplay;
+    private readonly _disabled;
+    set disabled(v: boolean);
+    get disabled(): boolean;
+    readonly open: i0.WritableSignal<boolean>;
+    readonly searchTerm: i0.WritableSignal<string>;
+    readonly activeIndex: i0.WritableSignal<number>;
+    readonly showCount: i0.WritableSignal<boolean>;
+    readonly showToken: i0.Signal<boolean>;
+    readonly selectedText: i0.Signal<string>;
+    readonly triggerValue: i0.Signal<string>;
+    readonly activeOptionId: i0.Signal<string>;
+    readonly inputPlaceholder: i0.Signal<string>;
+    private readonly _value;
+    readonly selectedItems: i0.Signal<SolarisSelectItem<any>[]>;
+    private readonly _stack;
+    readonly viewModel: i0.Signal<{
+        rows: SolarisSelectRow[];
+        itemRows: {
+            kind: "item";
+            key: string;
+            id: string;
+            optionIndex: number;
+            item: SolarisSelectItem;
+            disabled: boolean;
+            selected: boolean;
+            hasChildren: boolean;
+            selectable: boolean;
+        }[];
+    }>;
+    readonly rows: i0.Signal<SolarisSelectRow[]>;
+    readonly canGoBack: i0.Signal<boolean>;
+    readonly selectedCount: i0.Signal<number>;
+    readonly isSearchMode: i0.Signal<boolean>;
+    readonly itemRows: i0.Signal<{
+        kind: "item";
+        key: string;
+        id: string;
+        optionIndex: number;
+        item: SolarisSelectItem;
+        disabled: boolean;
+        selected: boolean;
+        hasChildren: boolean;
+        selectable: boolean;
+    }[]>;
+    readonly compactInput: i0.Signal<boolean>;
+    readonly currentLevel: i0.Signal<StackLevel>;
+    private static seq;
+    private _measureNonce;
+    private resizeObs?;
+    matchWidthEl: HTMLElement | null;
+    private propagateTouched;
+    private propagateChange;
+    private resolvedNgControl;
+    readonly _id: string;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    private eq;
+    private resolveNgControlOnce;
+    private itemLabel;
+    private collectAllItems;
+    private resetStack;
+    goBack(): void;
+    private enterChildren;
+    private filterNodes;
+    private cleanupDividers;
+    private applySelectedFirst;
+    private buildRows;
+    isSelected(value: any): boolean;
+    private setValue;
+    toggleItem(value: any): void;
+    selectSingle(value: any): void;
+    onOptionClick(item: SolarisSelectItem): void;
+    openFromTrigger(): void;
+    toggleOpen(): void;
+    onTriggerInput(v: string): void;
+    onTriggerKeydown(ev: KeyboardEvent): void;
+    onPanelKeydown(ev: KeyboardEvent): void;
+    private scheduleAutoMeasure;
+    private measureAuto;
+    private px;
+    private scheduleFocusTrigger;
+    private isSelectableValue;
+    private sanitizeValue;
+    selectedCountLabel(): string;
+    trackRow: (_: number, r: SolarisSelectRow) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisSelect, "solaris-select", never, { "items": { "alias": "items"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "valueKey": { "alias": "valueKey"; "required": false; }; "backKey": { "alias": "backKey"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderKey": { "alias": "placeholderKey"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "selectedCountKey": { "alias": "selectedCountKey"; "required": false; }; "selectedFirst": { "alias": "selectedFirst"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "selectedCountText": { "alias": "selectedCountText"; "required": false; }; "panelMaxHeight": { "alias": "panelMaxHeight"; "required": false; }; "searchPlaceholderKey": { "alias": "searchPlaceholderKey"; "required": false; }; "selectionSeparator": { "alias": "selectionSeparator"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "backText": { "alias": "backText"; "required": false; }; "selectionDisplay": { "alias": "selectionDisplay"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-export { FieldErrorComponent, FormField, InputTextDirective, PasswordToggle, SOLARIS_FORM_FIELD_CONTROLLER, SOLARIS_FORM_FIELD_FEATURES, SOLARIS_INPUT, SolarisBadge, SolarisBodyDirective, SolarisBreadcrumb, SolarisButtonDirective, SolarisButtonGroupDirective, SolarisControlBridgeDirective, SolarisDivider, SolarisDropdownContent, SolarisDropdownContentPanelDirective, SolarisDropdownContentRegistry, SolarisDropdownContentTriggerDirective, SolarisEmailDirective, SolarisFooterDirective, SolarisFormFieldController, SolarisHeaderDirective, SolarisImageSliderComponent, SolarisLoading, SolarisLoadingOverlay, SolarisPage, SolarisPageHeader, SolarisPageHeaderBreadcrumbDirective, SolarisPageHeaderDescriptionDirective, SolarisPageHeaderTitle, SolarisPageHeaderTitleDirective, SolarisPasswordDirective, SolarisPhoneInput, SolarisPrefixDirective, SolarisSectionComponent, SolarisSuffixDirective, SolarisTab, SolarisTabs };
-export type { BadgeColor, BadgeSize, BadgeVariant, DividerLabelAlign, DividerOrientation, DividerSpacing, DividerStrength, DividerVariant, Iso2, PhoneFormat, SolarisBreadcrumbItem, SolarisBreadcrumbTarget, SolarisButtonColor, SolarisButtonSize, SolarisButtonVariant, SolarisDropdownContentInterface, SolarisDropdownWidthMode, SolarisFormFieldControllerLike, SolarisFormFieldFeature, SolarisInputApi, SolarisLoadingColor, SolarisLoadingSize, SolarisLoadingType, SolarisSliderItem, SolarisSliderOverlayContext, TabsSize, TabsVariant };
+export { ButtonDirective, ButtonGroupDirective, FieldErrorComponent, FormField, InputTextDirective, PasswordToggle, SOLARIS_FORM_FIELD_CONTROLLER, SOLARIS_FORM_FIELD_FEATURES, SOLARIS_INPUT, SolarisBadge, SolarisBodyDirective, SolarisBreadcrumb, SolarisCheckbox, SolarisColumnCellDef, SolarisColumnHeaderDef, SolarisControlBridgeDirective, SolarisDivider, SolarisDrawer, SolarisDrawerFooterDirective, SolarisDrawerHeaderDirective, SolarisDropdownContent, SolarisDropdownContentPanelDirective, SolarisDropdownContentRegistry, SolarisDropdownContentTriggerDirective, SolarisEmailDirective, SolarisFilterBar, SolarisFilterChip, SolarisFilterField, SolarisFilterPanel, SolarisFilterPanelFooterDirective, SolarisFooterDirective, SolarisFormFieldController, SolarisHeaderDirective, SolarisIdGenerator, SolarisImageSliderComponent, SolarisLoading, SolarisLoadingOverlay, SolarisPage, SolarisPageHeader, SolarisPageHeaderBreadcrumbDirective, SolarisPageHeaderDescriptionDirective, SolarisPageHeaderTitle, SolarisPageHeaderTitleDirective, SolarisPasswordDirective, SolarisPhoneInput, SolarisPopover, SolarisPopoverPanelDirective, SolarisPopoverTriggerDirective, SolarisPrefixDirective, SolarisRowComponent, SolarisSectionComponent, SolarisSelect, SolarisSuffixDirective, SolarisTab, SolarisTable, SolarisTableColumn, SolarisTableFilters, SolarisTableSkeleton, SolarisTabs, computePopoverPosition, uniqueId };
+export type { BadgeColorInput, BadgeVariant, CheckboxAppearance, CheckboxColorInput, CheckboxVariant, DividerLabelAlign, DividerOrientation, DividerSpacing, DividerStrength, DividerVariant, Iso2, LoadingType, PhoneFormat, SelectionDisplay, SolarisAlign, SolarisBreadcrumbItem, SolarisBreadcrumbTarget, SolarisButtonColorInput, SolarisButtonVariant, SolarisCheckCustomString, SolarisColorPreset, SolarisCustomString, SolarisDrawerSide, SolarisDropdownContentInterface, SolarisDropdownWidthMode, SolarisFilterPanelRadius, SolarisFormFieldAppearance, SolarisFormFieldControllerLike, SolarisFormFieldFeature, SolarisFormFieldRadius, SolarisFormFieldShowErrors, SolarisInputApi, SolarisLoadingColor, SolarisLoadingDashDensity, SolarisLoadingEasing, SolarisLoadingPresetColor, SolarisLoadingSize, SolarisLoadingSpeed, SolarisLoadingTrail, SolarisPageChange, SolarisPopoverPlacement, SolarisPopoverPositionConfiguration, SolarisPopoverPositionResult, SolarisRadiusInput, SolarisRadiusPreset, SolarisRowKey, SolarisSelectDivider, SolarisSelectGroup, SolarisSelectItem, SolarisSelectNode, SolarisSelectRow, SolarisSizePreset, SolarisSliderItem, SolarisSliderOverlayContext, SolarisSort, SolarisSortDirection, SolarisTableI18n, SolarisTableVariant, StackLevel, TabsSize, TabsVariant };