@educarehq/solaris-ui 0.1.0 → 0.3.0

package/lib/components/interaction/tooltip/directive/tooltip.directive.d.ts

@@ -0,0 +1,80 @@
+import { TemplateRef, AfterViewInit } from '@angular/core';
+import type { SolarisTooltipPlacement, SolarisTooltipTrigger, SolarisTooltipAppearance, SolarisTooltipSize, SolarisTooltipRadius } from '../model/tooltip.types';
+import * as i0 from "@angular/core";
+export declare class SolarisTooltipDirective implements AfterViewInit {
+    private readonly overlay;
+    private readonly elementRef;
+    private readonly viewContainerRef;
+    private readonly injector;
+    private readonly document;
+    private readonly destroyRef;
+    private readonly translate;
+    private readonly ngZone;
+    protected readonly panelId: string;
+    protected readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    protected readonly isClickTrigger: import("@angular/core").Signal<boolean>;
+    private overlayRef;
+    private outsideClickCleanup;
+    private previousActiveElement;
+    private hoverTimeout;
+    private isHovered;
+    private isFocused;
+    private tooltipComponentRef;
+    private positionChangesSub;
+    private currentPlacement;
+    readonly solarisTooltip: import("@angular/core").InputSignal<string | undefined>;
+    readonly solarisTooltipKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly solarisTooltipFor: import("@angular/core").InputSignal<TemplateRef<unknown> | undefined>;
+    readonly solarisTooltipTitle: import("@angular/core").InputSignal<string | undefined>;
+    readonly solarisTooltipTitleKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly solarisTooltipIcon: import("@angular/core").InputSignal<string | undefined>;
+    readonly solarisTooltipIconDecorative: import("@angular/core").InputSignalWithTransform<boolean, boolean>;
+    readonly solarisTooltipTrigger: import("@angular/core").InputSignal<SolarisTooltipTrigger>;
+    readonly solarisTooltipPlacement: import("@angular/core").InputSignal<SolarisTooltipPlacement>;
+    readonly solarisTooltipOffset: import("@angular/core").InputSignalWithTransform<number, string | number>;
+    readonly solarisTooltipDisabled: import("@angular/core").InputSignalWithTransform<boolean, boolean>;
+    readonly solarisTooltipCloseable: import("@angular/core").InputSignalWithTransform<boolean, boolean>;
+    readonly solarisTooltipCloseLabel: import("@angular/core").InputSignal<string | undefined>;
+    readonly solarisTooltipCloseLabelKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly solarisTooltipShowDelay: import("@angular/core").InputSignalWithTransform<number, string | number>;
+    readonly solarisTooltipHideDelay: import("@angular/core").InputSignalWithTransform<number, string | number>;
+    readonly solarisTooltipAppearance: import("@angular/core").InputSignal<SolarisTooltipAppearance>;
+    readonly solarisTooltipSize: import("@angular/core").InputSignal<SolarisTooltipSize>;
+    readonly solarisTooltipRadius: import("@angular/core").InputSignal<SolarisTooltipRadius>;
+    readonly solarisTooltipMaxWidth: import("@angular/core").InputSignal<string | number>;
+    readonly solarisTooltipArrow: import("@angular/core").InputSignalWithTransform<boolean, boolean>;
+    readonly solarisTooltipOpen: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly solarisTooltipOpened: import("@angular/core").OutputEmitterRef<void>;
+    readonly solarisTooltipClosed: import("@angular/core").OutputEmitterRef<void>;
+    readonly solarisTooltipOpenChange: import("@angular/core").OutputEmitterRef<boolean>;
+    constructor();
+    ngAfterViewInit(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    onClick(): void;
+    onEscape(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    reposition(): void;
+    private getResolvedBody;
+    private getResolvedTitle;
+    private getResolvedCloseLabel;
+    private scheduleOpen;
+    private scheduleClose;
+    private clearHoverTimeout;
+    private createOverlay;
+    private createPositionStrategy;
+    private attachPanel;
+    private detachPanel;
+    private disposeOverlay;
+    private addOutsideClickHandler;
+    private removeOutsideClickHandler;
+    private readonly handleOutsideClick;
+    private rendererListen;
+    private restoreFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SolarisTooltipDirective, "[solaris-tooltip], [solarisTooltip], [solarisTooltipFor]", ["solarisTooltip"], { "solarisTooltip": { "alias": "solarisTooltip"; "required": false; "isSignal": true; }; "solarisTooltipKey": { "alias": "solarisTooltipKey"; "required": false; "isSignal": true; }; "solarisTooltipFor": { "alias": "solarisTooltipFor"; "required": false; "isSignal": true; }; "solarisTooltipTitle": { "alias": "solarisTooltipTitle"; "required": false; "isSignal": true; }; "solarisTooltipTitleKey": { "alias": "solarisTooltipTitleKey"; "required": false; "isSignal": true; }; "solarisTooltipIcon": { "alias": "solarisTooltipIcon"; "required": false; "isSignal": true; }; "solarisTooltipIconDecorative": { "alias": "solarisTooltipIconDecorative"; "required": false; "isSignal": true; }; "solarisTooltipTrigger": { "alias": "solarisTooltipTrigger"; "required": false; "isSignal": true; }; "solarisTooltipPlacement": { "alias": "solarisTooltipPlacement"; "required": false; "isSignal": true; }; "solarisTooltipOffset": { "alias": "solarisTooltipOffset"; "required": false; "isSignal": true; }; "solarisTooltipDisabled": { "alias": "solarisTooltipDisabled"; "required": false; "isSignal": true; }; "solarisTooltipCloseable": { "alias": "solarisTooltipCloseable"; "required": false; "isSignal": true; }; "solarisTooltipCloseLabel": { "alias": "solarisTooltipCloseLabel"; "required": false; "isSignal": true; }; "solarisTooltipCloseLabelKey": { "alias": "solarisTooltipCloseLabelKey"; "required": false; "isSignal": true; }; "solarisTooltipShowDelay": { "alias": "solarisTooltipShowDelay"; "required": false; "isSignal": true; }; "solarisTooltipHideDelay": { "alias": "solarisTooltipHideDelay"; "required": false; "isSignal": true; }; "solarisTooltipAppearance": { "alias": "solarisTooltipAppearance"; "required": false; "isSignal": true; }; "solarisTooltipSize": { "alias": "solarisTooltipSize"; "required": false; "isSignal": true; }; "solarisTooltipRadius": { "alias": "solarisTooltipRadius"; "required": false; "isSignal": true; }; "solarisTooltipMaxWidth": { "alias": "solarisTooltipMaxWidth"; "required": false; "isSignal": true; }; "solarisTooltipArrow": { "alias": "solarisTooltipArrow"; "required": false; "isSignal": true; }; "solarisTooltipOpen": { "alias": "solarisTooltipOpen"; "required": false; "isSignal": true; }; }, { "solarisTooltipOpened": "solarisTooltipOpened"; "solarisTooltipClosed": "solarisTooltipClosed"; "solarisTooltipOpenChange": "solarisTooltipOpenChange"; }, never, never, true, never>;
+}

package/lib/components/interaction/tooltip/index.d.ts

@@ -0,0 +1,3 @@
+export { SolarisTooltipDirective } from './directive/tooltip.directive';
+export { SolarisTooltipPanelComponent } from './component/tooltip-panel.component';
+export type { SolarisTooltipPlacement, SolarisTooltipTrigger, SolarisTooltipAppearance, SolarisTooltipSize, SolarisTooltipRadius, SolarisTooltipConfig, } from './model/tooltip.types';

package/lib/components/interaction/tooltip/model/tooltip-position.d.ts

@@ -0,0 +1,5 @@
+import type { ConnectedPosition, ConnectionPositionPair } from '@angular/cdk/overlay';
+import type { SolarisTooltipPlacement } from './tooltip.types';
+export declare function getTooltipPositions(placement: SolarisTooltipPlacement, offset: number): ConnectedPosition[];
+export declare function getTooltipArrowClass(placement: SolarisTooltipPlacement): string;
+export declare function derivePlacementFromConnectionPair(pair: ConnectionPositionPair): SolarisTooltipPlacement;

package/lib/components/interaction/tooltip/model/tooltip.types.d.ts

@@ -0,0 +1,22 @@
+export type SolarisTooltipPlacement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'right-start' | 'right-end' | 'left-start' | 'left-end';
+export type SolarisTooltipTrigger = 'hover' | 'click' | 'manual';
+export type SolarisTooltipAppearance = 'outline' | 'surface' | 'inverse';
+export type SolarisTooltipSize = 'sm' | 'md' | 'lg';
+export type SolarisTooltipRadius = 'sm' | 'md' | 'lg';
+export interface SolarisTooltipConfig {
+    placement?: SolarisTooltipPlacement;
+    offset?: number;
+    appearance?: SolarisTooltipAppearance;
+    size?: SolarisTooltipSize;
+    radius?: SolarisTooltipRadius;
+    maxWidth?: string | number;
+    arrow?: boolean;
+    trigger?: SolarisTooltipTrigger;
+    closeable?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    closeOnEscape?: boolean;
+    closeOnOutsideClick?: boolean;
+    restoreFocus?: boolean;
+    disabled?: boolean;
+}

package/lib/components/interaction/tooltip/token/tooltip.tokens.d.ts

@@ -0,0 +1,21 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+export interface SolarisTooltipPanelData {
+    title: string | undefined;
+    body: string | undefined;
+    icon: string | undefined;
+    iconDecorative: boolean;
+    contentTemplate: TemplateRef<unknown> | undefined;
+    appearance: string;
+    size: string;
+    radius: string;
+    maxWidth: string | number;
+    arrow: boolean;
+    arrowClass: string;
+    closeable: boolean;
+    closeLabel: string;
+    panelId: string;
+    placement: string;
+    trigger: string;
+    close: () => void;
+}
+export declare const SOLARIS_TOOLTIP_PANEL_DATA: InjectionToken<SolarisTooltipPanelData>;

package/lib/components/navigation/editable-tabs/component/editable-tabs.component.d.ts

@@ -0,0 +1,69 @@
+import { TemplateRef } from '@angular/core';
+import { SolarisDropdownMenuComponent } from '../../../interaction/dropdown-menu';
+import type { SolarisEditableTabData, SolarisEditableTabAction, SolarisEditableTabRenameEvent, SolarisEditableTabRemoveEvent, SolarisEditableTabMoveEvent, SolarisEditableTabDefaultChangeEvent, SolarisEditableTabActionEvent, SolarisEditableTabMoveDirection, SolarisEditableTabsShowActions, SolarisEditableTabsRenameOnBlur } from '../model/editable-tabs.types';
+import * as i0 from "@angular/core";
+export declare class SolarisEditableTabsComponent {
+    private readonly translateService;
+    private readonly ngZone;
+    readonly value: import("@angular/core").ModelSignal<unknown>;
+    readonly defaultValue: import("@angular/core").InputSignal<unknown>;
+    readonly orientation: import("@angular/core").InputSignal<import("@educarehq/solaris-ui").SolarisTabsOrientation>;
+    readonly appearance: import("@angular/core").InputSignal<import("@educarehq/solaris-ui").SolarisTabsAppearance>;
+    readonly size: import("@angular/core").InputSignal<import("@educarehq/solaris-ui").SolarisTabsSize>;
+    readonly density: import("@angular/core").InputSignal<import("@educarehq/solaris-ui").SolarisTabsDensity>;
+    readonly activationMode: import("@angular/core").InputSignal<import("@educarehq/solaris-ui").SolarisTabsActivationMode>;
+    readonly contentTransition: import("@angular/core").InputSignal<import("@educarehq/solaris-ui").SolarisTabsContentTransition>;
+    readonly tabs: import("@angular/core").InputSignal<SolarisEditableTabData<unknown>[]>;
+    readonly editable: import("@angular/core").InputSignal<boolean>;
+    readonly renamable: import("@angular/core").InputSignal<boolean>;
+    readonly removable: import("@angular/core").InputSignal<boolean>;
+    readonly movable: import("@angular/core").InputSignal<boolean>;
+    readonly defaultable: import("@angular/core").InputSignal<boolean>;
+    readonly showActions: import("@angular/core").InputSignal<SolarisEditableTabsShowActions>;
+    readonly renameOnBlur: import("@angular/core").InputSignal<SolarisEditableTabsRenameOnBlur>;
+    readonly minTabs: import("@angular/core").InputSignal<number>;
+    readonly allowEmpty: import("@angular/core").InputSignal<boolean>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    readonly ariaLabelKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly tabContentMap: import("@angular/core").InputSignal<Record<string, TemplateRef<void>> | undefined>;
+    readonly valueChange: import("@angular/core").OutputEmitterRef<unknown>;
+    readonly tabRenameRequested: import("@angular/core").OutputEmitterRef<SolarisEditableTabRenameEvent<unknown>>;
+    readonly tabRename: import("@angular/core").OutputEmitterRef<SolarisEditableTabRenameEvent<unknown>>;
+    readonly tabRemoveRequested: import("@angular/core").OutputEmitterRef<SolarisEditableTabRemoveEvent<unknown>>;
+    readonly tabRemove: import("@angular/core").OutputEmitterRef<SolarisEditableTabRemoveEvent<unknown>>;
+    readonly tabMoveRequested: import("@angular/core").OutputEmitterRef<SolarisEditableTabMoveEvent<unknown>>;
+    readonly tabMove: import("@angular/core").OutputEmitterRef<SolarisEditableTabMoveEvent<unknown>>;
+    readonly defaultTabChange: import("@angular/core").OutputEmitterRef<SolarisEditableTabDefaultChangeEvent<unknown>>;
+    readonly tabAction: import("@angular/core").OutputEmitterRef<SolarisEditableTabActionEvent<unknown>>;
+    readonly menuComponents: import("@angular/core").Signal<readonly SolarisDropdownMenuComponent[]>;
+    readonly tabMenuRefs: import("@angular/core").Signal<readonly SolarisDropdownMenuComponent[]>;
+    protected readonly activeMenuIndex: import("@angular/core").WritableSignal<number | null>;
+    protected readonly renamingTabId: import("@angular/core").WritableSignal<unknown>;
+    protected readonly renameValue: import("@angular/core").WritableSignal<string>;
+    protected readonly defaultTabValue: import("@angular/core").WritableSignal<unknown>;
+    protected readonly resolvedAriaLabel: import("@angular/core").Signal<string | undefined>;
+    constructor();
+    protected onValueChange(newValue: unknown): void;
+    protected hasActions(tab: SolarisEditableTabData): boolean;
+    protected canRename(tab: SolarisEditableTabData): boolean;
+    protected canRemove(tab: SolarisEditableTabData): boolean;
+    protected canMoveLeft(tab: SolarisEditableTabData): boolean;
+    protected canMoveRight(tab: SolarisEditableTabData): boolean;
+    protected canSetDefault(tab: SolarisEditableTabData): boolean;
+    protected startRename(tab: SolarisEditableTabData): void;
+    protected commitRename(tab: SolarisEditableTabData): void;
+    protected cancelRename(): void;
+    protected onRenameKeydown(event: KeyboardEvent, tab: SolarisEditableTabData): void;
+    protected onRenameBlur(tab: SolarisEditableTabData): void;
+    protected confirmRemove(tab: SolarisEditableTabData, index: number): void;
+    protected moveLabel(direction: 'left' | 'right'): string;
+    protected moveIcon(direction: 'left' | 'right'): string;
+    protected moveTab(tab: SolarisEditableTabData, index: number, direction: SolarisEditableTabMoveDirection): void;
+    protected setAsDefault(tab: SolarisEditableTabData): void;
+    protected handleCustomAction(tab: SolarisEditableTabData, action: SolarisEditableTabAction): void;
+    protected isRenaming(tab: SolarisEditableTabData): boolean;
+    protected getContentTemplate(tab: SolarisEditableTabData): TemplateRef<void> | null;
+    protected resolveText(key: string): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisEditableTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisEditableTabsComponent, "solaris-editable-tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "contentTransition": { "alias": "contentTransition"; "required": false; "isSignal": true; }; "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "renamable": { "alias": "renamable"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "movable": { "alias": "movable"; "required": false; "isSignal": true; }; "defaultable": { "alias": "defaultable"; "required": false; "isSignal": true; }; "showActions": { "alias": "showActions"; "required": false; "isSignal": true; }; "renameOnBlur": { "alias": "renameOnBlur"; "required": false; "isSignal": true; }; "minTabs": { "alias": "minTabs"; "required": false; "isSignal": true; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; "tabContentMap": { "alias": "tabContentMap"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "tabRenameRequested": "tabRenameRequested"; "tabRename": "tabRename"; "tabRemoveRequested": "tabRemoveRequested"; "tabRemove": "tabRemove"; "tabMoveRequested": "tabMoveRequested"; "tabMove": "tabMove"; "defaultTabChange": "defaultTabChange"; "tabAction": "tabAction"; }, never, never, true, never>;
+}

package/lib/components/navigation/editable-tabs/editable-tab/editable-tab.component.d.ts

@@ -0,0 +1,20 @@
+import { TemplateRef } from '@angular/core';
+import type { SolarisEditableTabAction } from '../model/editable-tabs.types';
+import * as i0 from "@angular/core";
+export declare class SolarisEditableTabComponent {
+    readonly value: import("@angular/core").InputSignal<unknown>;
+    readonly locked: import("@angular/core").InputSignal<boolean>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly icon: import("@angular/core").InputSignal<string | undefined>;
+    readonly label: import("@angular/core").InputSignal<string | undefined>;
+    readonly labelKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly movable: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly removable: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly renamable: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly defaultable: import("@angular/core").InputSignal<boolean | undefined>;
+    readonly badge: import("@angular/core").InputSignal<string | number | undefined>;
+    readonly customActions: import("@angular/core").InputSignal<SolarisEditableTabAction[] | undefined>;
+    readonly content: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisEditableTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisEditableTabComponent, "solaris-editable-tab", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "locked": { "alias": "locked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelKey": { "alias": "labelKey"; "required": false; "isSignal": true; }; "movable": { "alias": "movable"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "renamable": { "alias": "renamable"; "required": false; "isSignal": true; }; "defaultable": { "alias": "defaultable"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "customActions": { "alias": "customActions"; "required": false; "isSignal": true; }; }, {}, ["content"], never, true, never>;
+}

package/lib/components/navigation/editable-tabs/model/editable-tabs.types.d.ts

@@ -0,0 +1,60 @@
+import type { TemplateRef } from '@angular/core';
+import type { SolarisTabsOrientation, SolarisTabsAppearance, SolarisTabsSize, SolarisTabsDensity, SolarisTabsActivationMode, SolarisTabsContentTransition } from '../../tabs';
+export type SolarisEditableTabsOrientation = SolarisTabsOrientation;
+export type SolarisEditableTabsAppearance = SolarisTabsAppearance;
+export type SolarisEditableTabsSize = SolarisTabsSize;
+export type SolarisEditableTabsDensity = SolarisTabsDensity;
+export type SolarisEditableTabsActivationMode = SolarisTabsActivationMode;
+export type SolarisEditableTabsContentTransition = SolarisTabsContentTransition;
+export type SolarisEditableTabsShowActions = 'hover' | 'always' | 'focus-hover';
+export type SolarisEditableTabsRenameOnBlur = 'confirm' | 'cancel';
+export type SolarisEditableTabMoveDirection = 'left' | 'right' | 'up' | 'down';
+export interface SolarisEditableTabData<TValue = unknown> {
+    value: TValue;
+    label?: string;
+    labelKey?: string;
+    icon?: string;
+    badge?: string | number;
+    disabled?: boolean;
+    locked?: boolean;
+    renamable?: boolean;
+    removable?: boolean;
+    movable?: boolean;
+    defaultable?: boolean;
+    customActions?: SolarisEditableTabAction[];
+    content?: TemplateRef<void>;
+}
+export interface SolarisEditableTabAction {
+    id: string;
+    label?: string;
+    labelKey?: string;
+    icon?: string;
+    color?: 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+    disabled?: boolean;
+}
+export interface SolarisEditableTabRenameEvent<TValue = unknown> {
+    value: TValue;
+    previousLabel: string;
+    nextLabel: string;
+    source: 'inline' | 'api';
+}
+export interface SolarisEditableTabRemoveEvent<TValue = unknown> {
+    value: TValue;
+    index: number;
+    wasActive: boolean;
+}
+export interface SolarisEditableTabMoveEvent<TValue = unknown> {
+    value: TValue;
+    previousIndex: number;
+    nextIndex: number;
+    direction: SolarisEditableTabMoveDirection;
+}
+export interface SolarisEditableTabDefaultChangeEvent<TValue = unknown> {
+    value: TValue;
+    previousDefaultValue?: TValue;
+}
+export interface SolarisEditableTabActionEvent<TValue = unknown> {
+    tabValue: TValue;
+    actionId: string;
+    action: SolarisEditableTabAction;
+}

package/lib/components/navigation/segmented-control/component/segmented-control.component.d.ts

@@ -0,0 +1,64 @@
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { type ControlValueAccessor } from '@angular/forms';
+import { SolarisSegmentedItemComponent } from '../item/segmented-item.component';
+import { type SolarisSegmentedControlInterface } from '../token/segmented-control.tokens';
+import type { SolarisSegmentedControlOrientation, SolarisSegmentedControlAppearance, SolarisSegmentedControlSize, SolarisSegmentedControlDensity, SolarisSegmentedControlRadius, SolarisSegmentedControlChangeEvent } from '../model/segmented-control.types';
+import * as i0 from "@angular/core";
+export declare class SolarisSegmentedControlComponent implements SolarisSegmentedControlInterface, ControlValueAccessor, AfterViewInit, OnDestroy {
+    private readonly translateService;
+    private readonly elementRef;
+    private readonly injector;
+    private readonly ngZone;
+    readonly items: import("@angular/core").Signal<readonly SolarisSegmentedItemComponent[]>;
+    readonly invalid: import("@angular/core").InputSignal<boolean>;
+    readonly indicator: import("@angular/core").InputSignal<boolean>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly readonly: import("@angular/core").InputSignal<boolean>;
+    readonly required: import("@angular/core").InputSignal<boolean>;
+    readonly fullWidth: import("@angular/core").InputSignal<boolean>;
+    readonly equalWidth: import("@angular/core").InputSignal<boolean>;
+    readonly value: import("@angular/core").ModelSignal<unknown>;
+    readonly defaultValue: import("@angular/core").InputSignal<unknown>;
+    readonly compareFn: import("@angular/core").Signal<(a: unknown, b: unknown) => boolean>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    readonly ariaLabelKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly ariaLabelledby: import("@angular/core").InputSignal<string | undefined>;
+    readonly size: import("@angular/core").InputSignal<SolarisSegmentedControlSize>;
+    readonly radius: import("@angular/core").InputSignal<SolarisSegmentedControlRadius>;
+    readonly compareWith: import("@angular/core").InputSignal<(a: unknown, b: unknown) => boolean>;
+    readonly density: import("@angular/core").InputSignal<SolarisSegmentedControlDensity>;
+    readonly appearance: import("@angular/core").InputSignal<SolarisSegmentedControlAppearance>;
+    readonly orientation: import("@angular/core").InputSignal<SolarisSegmentedControlOrientation>;
+    readonly valueChange: import("@angular/core").OutputEmitterRef<unknown>;
+    readonly segmentedChange: import("@angular/core").OutputEmitterRef<SolarisSegmentedControlChangeEvent>;
+    protected readonly instanceId: string;
+    protected readonly touched: import("@angular/core").WritableSignal<boolean>;
+    protected readonly indicatorWidth: import("@angular/core").WritableSignal<string>;
+    protected readonly indicatorHeight: import("@angular/core").WritableSignal<string>;
+    protected readonly indicatorReady: import("@angular/core").WritableSignal<boolean>;
+    protected readonly internalDisabled: import("@angular/core").WritableSignal<boolean>;
+    protected readonly indicatorTransformX: import("@angular/core").WritableSignal<string>;
+    protected readonly indicatorTransformY: import("@angular/core").WritableSignal<string>;
+    private onChange;
+    private onTouched;
+    private resizeObserver;
+    private contentObserver;
+    protected readonly isEffectivelyDisabled: import("@angular/core").Signal<boolean>;
+    protected readonly hasValue: import("@angular/core").Signal<boolean>;
+    protected readonly resolvedAriaLabel: import("@angular/core").Signal<string | undefined>;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    selectItem(item: SolarisSegmentedItemComponent): void;
+    focusItem(item: SolarisSegmentedItemComponent): void;
+    writeValue(safe: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private markAsTouched;
+    private measureIndicator;
+    private setupIndicatorMeasurement;
+    private disconnectObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisSegmentedControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisSegmentedControlComponent, "solaris-segmented-control", never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "indicator": { "alias": "indicator"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "equalWidth": { "alias": "equalWidth"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "segmentedChange": "segmentedChange"; }, ["items"], ["solaris-segmented-item"], true, never>;
+}

package/lib/components/navigation/segmented-control/item/segmented-item.component.d.ts

@@ -0,0 +1,35 @@
+import { AfterContentInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SolarisSegmentedItemComponent implements AfterContentInit {
+    private readonly translateService;
+    private readonly control;
+    private readonly elementRef;
+    protected readonly hasContent: import("@angular/core").WritableSignal<boolean>;
+    readonly value: import("@angular/core").InputSignal<unknown>;
+    readonly label: import("@angular/core").InputSignal<string | undefined>;
+    readonly labelKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly icon: import("@angular/core").InputSignal<string | undefined>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    readonly ariaLabelKey: import("@angular/core").InputSignal<string | undefined>;
+    protected readonly instanceId: string;
+    protected readonly itemId: import("@angular/core").Signal<string>;
+    readonly isSelected: import("@angular/core").Signal<boolean>;
+    readonly isComputedDisabled: import("@angular/core").Signal<boolean>;
+    readonly isComputedReadonly: import("@angular/core").Signal<boolean>;
+    readonly isTabstop: import("@angular/core").Signal<boolean>;
+    protected readonly isIconOnly: import("@angular/core").Signal<boolean>;
+    ngAfterContentInit(): void;
+    private updateHasContent;
+    readonly resolvedLabel: import("@angular/core").Signal<string | undefined>;
+    protected readonly resolvedAriaLabel: import("@angular/core").Signal<string | undefined>;
+    protected readonly index: import("@angular/core").Signal<number>;
+    protected onClick(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private getNextIndex;
+    private findNextEnabled;
+    private findFirstEnabled;
+    private findLastEnabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisSegmentedItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisSegmentedItemComponent, "solaris-segmented-item", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelKey": { "alias": "labelKey"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/navigation/segmented-control/model/segmented-control.types.d.ts

@@ -0,0 +1,12 @@
+export type SolarisSegmentedControlOrientation = 'horizontal' | 'vertical';
+export type SolarisSegmentedControlAppearance = 'surface' | 'outline';
+export type SolarisSegmentedControlSize = 'sm' | 'md' | 'lg';
+export type SolarisSegmentedControlDensity = 'compact' | 'comfortable';
+export type SolarisSegmentedControlRadius = 'sm' | 'md' | 'lg' | 'full';
+export interface SolarisSegmentedControlValueChangeEvent {
+    value: unknown;
+}
+export interface SolarisSegmentedControlChangeEvent {
+    value: unknown;
+    previousValue: unknown;
+}

package/lib/components/navigation/segmented-control/token/segmented-control.tokens.d.ts

@@ -0,0 +1,22 @@
+import { InjectionToken, type Signal } from '@angular/core';
+import type { SolarisSegmentedControlOrientation, SolarisSegmentedControlAppearance, SolarisSegmentedControlSize, SolarisSegmentedControlDensity, SolarisSegmentedControlRadius } from '../model/segmented-control.types';
+import type { SolarisSegmentedItemComponent } from '../item/segmented-item.component';
+export interface SolarisSegmentedControlInterface {
+    value: Signal<unknown>;
+    items: Signal<ReadonlyArray<SolarisSegmentedItemComponent>>;
+    orientation: Signal<SolarisSegmentedControlOrientation>;
+    appearance: Signal<SolarisSegmentedControlAppearance>;
+    size: Signal<SolarisSegmentedControlSize>;
+    density: Signal<SolarisSegmentedControlDensity>;
+    radius: Signal<SolarisSegmentedControlRadius>;
+    disabled: Signal<boolean>;
+    readonly: Signal<boolean>;
+    invalid: Signal<boolean>;
+    fullWidth: Signal<boolean>;
+    equalWidth: Signal<boolean>;
+    indicator: Signal<boolean>;
+    compareFn: Signal<(a: unknown, b: unknown) => boolean>;
+    selectItem: (item: SolarisSegmentedItemComponent) => void;
+    focusItem: (item: SolarisSegmentedItemComponent) => void;
+}
+export declare const SOLARIS_SEGMENTED_CONTROL: InjectionToken<SolarisSegmentedControlInterface>;

package/lib/components/navigation/stepper/actions/stepper-actions.component.d.ts

@@ -0,0 +1,7 @@
+import type { SolarisStepperActionsAlign } from '../model/stepper.types';
+import * as i0 from "@angular/core";
+export declare class SolarisStepperActionsComponent {
+    readonly align: import("@angular/core").InputSignal<SolarisStepperActionsAlign>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisStepperActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisStepperActionsComponent, "solaris-stepper-actions", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/lib/components/navigation/stepper/component/stepper.component.d.ts

@@ -0,0 +1,36 @@
+import { SolarisStepperActionsComponent } from '../actions/stepper-actions.component';
+import type { SolarisStepperControl } from '../token/stepper.tokens';
+import { SolarisStepComponent } from '../step/step.component';
+import type { SolarisStepperOrientation, SolarisStepperAppearance, SolarisStepperSize, SolarisStepperDensity, SolarisStepperContentTransition, SolarisStepperChangeEvent } from '../model/stepper.types';
+import * as i0 from "@angular/core";
+export declare class SolarisStepperComponent implements SolarisStepperControl {
+    private readonly translateService;
+    readonly steps: import("@angular/core").Signal<readonly SolarisStepComponent[]>;
+    readonly actions: import("@angular/core").Signal<SolarisStepperActionsComponent | undefined>;
+    readonly activeIndex: import("@angular/core").ModelSignal<number>;
+    readonly orientation: import("@angular/core").InputSignal<SolarisStepperOrientation>;
+    readonly appearance: import("@angular/core").InputSignal<SolarisStepperAppearance>;
+    readonly linear: import("@angular/core").InputSignal<boolean>;
+    readonly size: import("@angular/core").InputSignal<SolarisStepperSize>;
+    readonly density: import("@angular/core").InputSignal<SolarisStepperDensity>;
+    readonly showConnectors: import("@angular/core").InputSignal<boolean>;
+    readonly showStepStatus: import("@angular/core").InputSignal<boolean>;
+    readonly showStepNumbers: import("@angular/core").InputSignal<boolean>;
+    readonly contentTransition: import("@angular/core").InputSignal<SolarisStepperContentTransition>;
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    readonly ariaLabelKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly activeIndexChange: import("@angular/core").OutputEmitterRef<number>;
+    readonly stepChange: import("@angular/core").OutputEmitterRef<SolarisStepperChangeEvent>;
+    readonly stepClick: import("@angular/core").OutputEmitterRef<{
+        index: number;
+        label: string | undefined;
+    }>;
+    protected readonly stepTransitionDirection: import("@angular/core").WritableSignal<"next" | "previous">;
+    readonly previousIndex: import("@angular/core").WritableSignal<number>;
+    readonly resolvedAriaLabel: import("@angular/core").Signal<string | undefined>;
+    constructor();
+    goToStep(index: number): void;
+    isStepClickable(step: SolarisStepComponent): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisStepperComponent, "solaris-stepper", never, { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "showConnectors": { "alias": "showConnectors"; "required": false; "isSignal": true; }; "showStepStatus": { "alias": "showStepStatus"; "required": false; "isSignal": true; }; "showStepNumbers": { "alias": "showStepNumbers"; "required": false; "isSignal": true; }; "contentTransition": { "alias": "contentTransition"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelKey": { "alias": "ariaLabelKey"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; "activeIndexChange": "activeIndexChange"; "stepChange": "stepChange"; "stepClick": "stepClick"; }, ["steps", "actions"], ["solaris-step", "solaris-stepper-actions"], true, never>;
+}

package/lib/components/navigation/stepper/content/stepper-content.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SolarisStepperContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisStepperContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisStepperContentComponent, "solaris-stepper-content", never, {}, {}, never, ["*"], true, never>;
+}

package/lib/components/navigation/stepper/model/stepper.types.d.ts

@@ -0,0 +1,15 @@
+export type SolarisStepperOrientation = 'horizontal' | 'vertical';
+export type SolarisStepperAppearance = 'default' | 'card' | 'dashed';
+export type SolarisStepperSize = 'sm' | 'md' | 'lg';
+export type SolarisStepperDensity = 'compact' | 'comfortable';
+export type SolarisStepperStatus = 'pending' | 'active' | 'completed' | 'error' | 'disabled';
+export type SolarisStepperContentTransition = 'none' | 'fade' | 'slide';
+export type SolarisStepperActionsAlign = 'start' | 'center' | 'end' | 'space-between';
+export interface SolarisStepperChangeEvent {
+    activeIndex: number;
+    previousIndex: number;
+}
+export interface SolarisStepClickEvent {
+    index: number;
+    label: string | undefined;
+}

package/lib/components/navigation/stepper/step/step.component.d.ts

@@ -0,0 +1,27 @@
+import type { SolarisStepperStatus } from '../model/stepper.types';
+import * as i0 from "@angular/core";
+export declare class SolarisStepComponent {
+    private readonly translateService;
+    readonly stepper: import("@educarehq/solaris-ui").SolarisStepperControl | null;
+    readonly error: import("@angular/core").InputSignal<boolean>;
+    readonly optional: import("@angular/core").InputSignal<boolean>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly completed: import("@angular/core").InputSignal<boolean>;
+    readonly icon: import("@angular/core").InputSignal<string | undefined>;
+    readonly label: import("@angular/core").InputSignal<string | undefined>;
+    readonly labelKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly status: import("@angular/core").InputSignal<SolarisStepperStatus>;
+    readonly description: import("@angular/core").InputSignal<string | undefined>;
+    readonly descriptionKey: import("@angular/core").InputSignal<string | undefined>;
+    readonly index: import("@angular/core").Signal<number>;
+    readonly isActive: import("@angular/core").Signal<boolean>;
+    readonly computedStatus: import("@angular/core").Signal<SolarisStepperStatus>;
+    readonly isInteractive: import("@angular/core").Signal<boolean>;
+    readonly showContent: import("@angular/core").Signal<boolean>;
+    readonly resolvedLabel: import("@angular/core").Signal<string | undefined>;
+    readonly resolvedDescription: import("@angular/core").Signal<string | undefined>;
+    readonly showCheckIcon: import("@angular/core").Signal<boolean>;
+    readonly showErrorIcon: import("@angular/core").Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SolarisStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SolarisStepComponent, "solaris-step", never, { "error": { "alias": "error"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "completed": { "alias": "completed"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelKey": { "alias": "labelKey"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "descriptionKey": { "alias": "descriptionKey"; "required": false; "isSignal": true; }; }, {}, never, ["solaris-stepper-content"], true, never>;
+}

package/lib/components/navigation/stepper/token/stepper.tokens.d.ts

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+import type { SolarisStepperOrientation, SolarisStepperAppearance, SolarisStepperSize, SolarisStepperDensity } from '../model/stepper.types';
+export interface SolarisStepperControl {
+    activeIndex: () => number;
+    steps: () => ReadonlyArray<unknown>;
+    orientation: () => SolarisStepperOrientation;
+    appearance: () => SolarisStepperAppearance;
+    linear: () => boolean;
+    size: () => SolarisStepperSize;
+    density: () => SolarisStepperDensity;
+    goToStep: (index: number) => void;
+}
+export declare const SOLARIS_STEPPER: InjectionToken<SolarisStepperControl>;