@cocoar/ui-components 0.1.0-beta.100

package/types/cocoar-ui-components.d.ts

@@ -0,0 +1,1879 @@
+import * as _angular_core from '@angular/core';
+import { Type, Provider, ElementRef, InjectionToken, AfterViewInit, OnDestroy, DestroyRef, TemplateRef, AfterContentInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { SafeHtml } from '@angular/platform-browser';
+import { OverlayScrollbars } from 'overlayscrollbars';
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { Temporal } from '@js-temporal/polyfill';
+
+declare function coarProvideValueAccessor(type: () => Type<ControlValueAccessor>): Provider;
+declare abstract class CoarControlValueAccessor<T> implements ControlValueAccessor {
+    protected readonly cvaDisabled: _angular_core.WritableSignal<boolean>;
+    protected cvaOnChange: (value: T) => void;
+    protected cvaOnTouched: () => void;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    abstract writeValue(value: T | null): void;
+}
+
+type CoarTextInputSize = 'xs' | 'sm' | 'md' | 'lg';
+declare class CoarTextInputComponent extends CoarControlValueAccessor<string> {
+    /** Label text displayed above the input */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when input is empty */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Current input value (two-way bindable with [(value)]) */
+    value: _angular_core.ModelSignal<string>;
+    /** Input size - matches button/checkbox sizes for consistent layouts */
+    size: _angular_core.InputSignal<CoarTextInputSize>;
+    /** Number of visible text rows (1 = single-line input, 2+ = textarea) */
+    rows: _angular_core.InputSignal<number>;
+    /** Disables the input (greyed out, not focusable) */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Makes the input read-only (focusable but not editable) */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marks the input as required, shows asterisk on label */
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error message to display below the input */
+    error: _angular_core.InputSignal<string>;
+    /** Hint text displayed below the input */
+    hint: _angular_core.InputSignal<string>;
+    /** Show clear button when input has value and is focused/hovered */
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Text or symbol displayed before the input value */
+    prefix: _angular_core.InputSignal<string>;
+    /** Text or symbol displayed after the input value */
+    suffix: _angular_core.InputSignal<string>;
+    /** HTML id attribute for the input element */
+    id: _angular_core.InputSignal<string>;
+    /** HTML name attribute for form submission */
+    name: _angular_core.InputSignal<string>;
+    /** HTML autocomplete attribute */
+    autocomplete: _angular_core.InputSignal<string>;
+    /** Maximum character length */
+    maxlength: _angular_core.InputSignal<number | undefined>;
+    /** Emits when input value changes */
+    valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Emits when input loses focus */
+    blurred: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Emits when input gains focus */
+    focused: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Emits when clear button is clicked */
+    clear: _angular_core.OutputEmitterRef<void>;
+    protected isFocused: _angular_core.WritableSignal<boolean>;
+    protected inputRef: _angular_core.Signal<ElementRef<HTMLInputElement | HTMLTextAreaElement> | undefined>;
+    protected isMultiline: _angular_core.Signal<boolean>;
+    protected isDisabled: _angular_core.Signal<boolean>;
+    protected showClearButton: _angular_core.Signal<boolean>;
+    protected hasError: _angular_core.Signal<boolean>;
+    protected displayMessage: _angular_core.Signal<string>;
+    private readonly autoId;
+    protected inputId: _angular_core.Signal<string>;
+    protected messageId: _angular_core.Signal<string>;
+    writeValue(value: string | null): void;
+    protected onInput(event: Event): void;
+    protected onFocus(event: FocusEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    protected onClear(): void;
+    protected onLabelClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarTextInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarTextInputComponent, "coar-text-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "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; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "blurred": "blurred"; "focused": "focused"; "clear": "clear"; }, never, ["[prefix]", "[suffix]", "[suffixAction]"], true, never>;
+}
+
+type CoarIconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto';
+/**
+ * COAR Icon Component
+ *
+ * Icon component supporting DI-provided icon registries.
+ *
+ * Usage:
+ * ```html
+ * <coar-icon name="settings" size="md"></coar-icon>
+ * ```
+ *
+ * Size tokens:
+ * - xs = 12px
+ * - sm = 16px
+ * - md = 20px (default)
+ * - lg = 24px
+ * - xl = 32px
+ * - auto = fills parent container (use padding on parent to control)
+ */
+declare class CoarIconComponent {
+    private readonly iconService;
+    private readonly sanitizer;
+    private iconLoadVersion;
+    /**
+     * Icon identifier.
+     * Examples: "settings", "user"
+     */
+    name: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Optional icon source key.
+     *
+     * - If omitted, the default source is used.
+     * - If multiple sources are registered, this can be used to target a specific one.
+     */
+    source: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Icon size. Defaults to 'md' (20px).
+     * Can be a preset token (xs, sm, md, lg, xl, auto) or a custom CSS value (e.g., '42px', '3rem').
+     */
+    size: _angular_core.InputSignal<string>;
+    /**
+     * Rotation angle in degrees (0, 90, 180, 270, or any number).
+     */
+    rotate: _angular_core.InputSignal<number>;
+    /**
+     * Rotation transition animation.
+     * - Empty/undefined: No animation
+     * - Number: Duration in milliseconds (e.g., 300)
+     * - String: Full CSS transition value (e.g., '0.3s ease-in-out', '500ms cubic-bezier(0.4, 0, 0.2, 1)')
+     */
+    rotateTransition: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Enable continuous spinning animation.
+     */
+    spin: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Icon color. Can be any valid CSS color value.
+     * Examples: 'red', '#ff0000', 'rgb(255, 0, 0)', 'var(--coar-text-semantic-error-bold)'
+     * Use 'inherit' to inherit the parent element's color.
+     */
+    color: _angular_core.InputSignal<string>;
+    /**
+     * Optional text label to display next to the icon.
+     */
+    label: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Signal holding the sanitized SVG HTML ready for rendering.
+     */
+    protected sanitizedSvg: _angular_core.WritableSignal<SafeHtml | null>;
+    /**
+     * Signal indicating whether an icon is currently being loaded.
+     */
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    /**
+     * Check if the size is a preset token (xs, sm, md, lg, xl, auto).
+     */
+    protected isPresetSize(size: string): boolean;
+    /**
+     * Compute the CSS transition value for rotation.
+     */
+    protected getRotateTransitionValue(): string | null;
+    constructor();
+    /**
+     * Resolve an icon name to an SVG string.
+     *
+     * This is kept as a single observable chain so callers can cancel it.
+     */
+    private resolveIcon$;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarIconComponent, "coar-icon", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "source": { "alias": "source"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "rotate": { "alias": "rotate"; "required": false; "isSignal": true; }; "rotateTransition": { "alias": "rotateTransition"; "required": false; "isSignal": true; }; "spin": { "alias": "spin"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Configuration for number formatting */
+interface NumberFormatConfig {
+    readonly decimal: string;
+    readonly thousand: string;
+}
+/** Configuration for date formatting */
+interface DateFormatConfig {
+    /** Date format pattern: 'dd.mm.yyyy', 'dd/mm/yyyy', 'mm/dd/yyyy', 'yyyy-mm-dd' */
+    readonly pattern: 'dd.mm.yyyy' | 'dd/mm/yyyy' | 'mm/dd/yyyy' | 'yyyy-mm-dd';
+    /** First day of week: 1 = Monday, 7 = Sunday */
+    readonly firstDayOfWeek: 1 | 7;
+}
+/** Complete locale configuration */
+interface LocaleConfig {
+    readonly number: NumberFormatConfig;
+    readonly date: DateFormatConfig;
+}
+/**
+ * Service contract for locale-aware formatting.
+ * Provides formatting rules (not translations) for numbers, dates, etc.
+ *
+ * This handles "how to display" (1.000,50 vs 1,000.50),
+ * not "what text to show" (that's translation/i18n).
+ */
+interface ICoarLocaleService {
+    /**
+     * Get number format configuration for a specific locale.
+     * @param locale - Optional locale identifier (e.g., 'de-AT', 'en-US'). If not provided, uses default locale.
+     * @returns Number format configuration with decimal and thousand separators
+     */
+    getNumberFormat(locale?: string): NumberFormatConfig;
+    /**
+     * Get date format configuration for a specific locale.
+     * @param locale - Optional locale identifier (e.g., 'de-AT', 'en-US'). If not provided, uses default locale.
+     * @returns Date format configuration with pattern and first day of week
+     */
+    getDateFormat(locale?: string): DateFormatConfig;
+    /**
+     * Get the current default locale identifier.
+     * @returns Current default locale (e.g., 'de-AT', 'en-US')
+     */
+    getDefaultLocale(): string;
+    /**
+     * Set the default locale used when no locale is explicitly specified.
+     * @param locale - Locale identifier (e.g., 'de-AT', 'en-US')
+     */
+    setDefaultLocale(locale: string): void;
+    /**
+     * Register a custom locale configuration.
+     * Useful for specialized formats (e.g., financial reports with space as thousand separator).
+     * @param id - Custom locale identifier (e.g., 'custom-finance')
+     * @param config - Partial locale configuration (only specify what you want to override)
+     */
+    registerLocale(id: string, config: Partial<LocaleConfig>): void;
+}
+/**
+ * Injection token for the locale service.
+ * Use this to inject the locale service in components.
+ *
+ * @example
+ * ```typescript
+ * private localeService = inject(COAR_LOCALE_SERVICE, { optional: true });
+ * ```
+ */
+declare const COAR_LOCALE_SERVICE: InjectionToken<ICoarLocaleService>;
+/**
+ * Default implementation of locale service.
+ * Uses browser's Intl.NumberFormat API for standard locales,
+ * with support for custom locale registration.
+ */
+declare class CoarLocaleService implements ICoarLocaleService {
+    private defaultLocale;
+    private customLocales;
+    getDefaultLocale(): string;
+    setDefaultLocale(locale: string): void;
+    registerLocale(id: string, config: Partial<LocaleConfig>): void;
+    getNumberFormat(locale?: string): NumberFormatConfig;
+    getDateFormat(locale?: string): DateFormatConfig;
+    /**
+     * Extract default formatting rules from browser's Intl API
+     */
+    private getDefaults;
+    /**
+     * Detect date format based on locale.
+     *
+     * Uses Intl.DateTimeFormat to determine the date order for the locale,
+     * then maps to one of our supported patterns.
+     */
+    private detectDateFormat;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarLocaleService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CoarLocaleService>;
+}
+
+type CoarNumberInputSize = 'xs' | 'sm' | 'md' | 'lg';
+type CoarNumberInputStepperButtons = 'none' | 'increment' | 'decrement' | 'both';
+declare class CoarNumberInputComponent extends CoarControlValueAccessor<number | null> {
+    private readonly destroyRef;
+    private readonly localeService;
+    private maskitoInstance?;
+    /** Label text displayed above the input */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when input is empty */
+    placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Current numeric value.
+     * Using model() for two-way binding support.
+     */
+    value: _angular_core.ModelSignal<number | null>;
+    /** Input size - matches button/checkbox sizes for consistent layouts */
+    size: _angular_core.InputSignal<CoarNumberInputSize>;
+    /** Minimum allowed value */
+    min: _angular_core.InputSignal<number | undefined>;
+    /** Maximum allowed value */
+    max: _angular_core.InputSignal<number | undefined>;
+    /** Step increment for arrows and keyboard */
+    step: _angular_core.InputSignal<number>;
+    /** Number of decimal places to display */
+    decimals: _angular_core.InputSignal<number>;
+    /** Disables the input (greyed out, not focusable) */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Makes the input read-only (focusable but not editable) */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marks the input as required, shows asterisk on label */
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error message to display below the input */
+    error: _angular_core.InputSignal<string>;
+    /** Hint text displayed below the input */
+    hint: _angular_core.InputSignal<string>;
+    /** Show clear button when input has value and is focused/hovered */
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Controls visibility of increment/decrement stepper buttons.
+     * Supports both boolean attribute pattern and granular string control:
+     * - No attribute → no buttons
+     * - `stepperButtons` (attribute) → both buttons
+     * - `stepperButtons="increment"` → only increment
+     * - `stepperButtons="decrement"` → only decrement
+     * - `stepperButtons="both"` → both buttons (explicit)
+     * - `stepperButtons="none"` → no buttons (explicit)
+     */
+    stepperButtons: _angular_core.InputSignalWithTransform<CoarNumberInputStepperButtons, string | boolean>;
+    /** Text or symbol displayed before the input value */
+    prefix: _angular_core.InputSignal<string>;
+    /** Text or symbol displayed after the input value */
+    suffix: _angular_core.InputSignal<string>;
+    /**
+     * Locale identifier for number formatting (e.g., 'de-AT', 'en-US').
+     * Uses global locale service default if not specified.
+     */
+    locale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Number format configuration (decimal and thousand separators).
+     * If not provided, uses locale service default or falls back to { decimal: '.', thousand: '' }.
+     */
+    numberFormat: _angular_core.InputSignal<NumberFormatConfig | undefined>;
+    /** HTML id attribute for the input element */
+    id: _angular_core.InputSignal<string>;
+    /** HTML name attribute for form submission */
+    name: _angular_core.InputSignal<string>;
+    /** Emits when input value changes */
+    valueChange: _angular_core.OutputEmitterRef<number | null>;
+    /** Emits when input loses focus */
+    blurred: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Emits when input gains focus */
+    focused: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Emits when clear button is clicked */
+    clear: _angular_core.OutputEmitterRef<void>;
+    protected displayValue: _angular_core.WritableSignal<string>;
+    protected isFocused: _angular_core.WritableSignal<boolean>;
+    protected isDragging: _angular_core.WritableSignal<boolean>;
+    protected dragStartX: _angular_core.WritableSignal<number>;
+    protected dragStartValue: _angular_core.WritableSignal<number>;
+    protected inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected isDisabled: _angular_core.Signal<boolean>;
+    protected showClearButton: _angular_core.Signal<boolean>;
+    protected hasError: _angular_core.Signal<boolean>;
+    protected displayMessage: _angular_core.Signal<string>;
+    private readonly autoId;
+    protected inputId: _angular_core.Signal<string>;
+    protected messageId: _angular_core.Signal<string>;
+    protected iconSize: _angular_core.Signal<CoarIconSize>;
+    protected showIncrementButton: _angular_core.Signal<boolean>;
+    protected showDecrementButton: _angular_core.Signal<boolean>;
+    protected canDecrement: _angular_core.Signal<boolean>;
+    protected canIncrement: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Resolve number format configuration with priority chain:
+     * 1. numberFormat input (explicit config object)
+     * 2. localeService.getNumberFormat(locale) (service with locale override)
+     * 3. localeService.getNumberFormat() (service with default locale)
+     * 4. Hardcoded fallback { decimal: '.', thousand: '' }
+     */
+    private resolveNumberFormat;
+    private initializeMaskito;
+    protected formatValue(value: number | null): string;
+    /**
+     * Parse locale-formatted string (respects component's decimal/thousand separators).
+     * Used when user types or pastes into the input field.
+     */
+    protected parseValue(str: string): number | null;
+    protected clampValue(value: number): number;
+    protected onInput(event: Event): void;
+    protected onFocus(event: FocusEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    protected commitValue(): void;
+    writeValue(value: number | null): void;
+    protected onClear(): void;
+    protected onLabelClick(): void;
+    protected increment(): void;
+    protected decrement(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected onDragStart(event: MouseEvent): void;
+    protected onDragMove(event: MouseEvent): void;
+    protected onDragEnd(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarNumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarNumberInputComponent, "coar-number-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "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; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "stepperButtons": { "alias": "stepperButtons"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "numberFormat": { "alias": "numberFormat"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "blurred": "blurred"; "focused": "focused"; "clear": "clear"; }, never, ["[prefix]", "[suffix]"], true, never>;
+}
+
+type CoarPasswordInputSize = 'xs' | 'sm' | 'md' | 'lg';
+declare class CoarPasswordInputComponent extends CoarControlValueAccessor<string> {
+    /** Label text displayed above the input */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when input is empty */
+    placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Current password value.
+     * Using model() for two-way binding support.
+     */
+    value: _angular_core.ModelSignal<string>;
+    /** Input size - matches other form elements for consistent layouts */
+    size: _angular_core.InputSignal<CoarPasswordInputSize>;
+    /** Disables the input (greyed out, not focusable) */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Makes the input read-only (focusable but not editable) */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marks the input as required, shows asterisk on label */
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error message to display below the input */
+    error: _angular_core.InputSignal<string>;
+    /** Hint text displayed below the input */
+    hint: _angular_core.InputSignal<string>;
+    /** Show clear button when input has value and is focused/hovered */
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** HTML id attribute for the input element */
+    id: _angular_core.InputSignal<string>;
+    /** HTML name attribute for form submission */
+    name: _angular_core.InputSignal<string>;
+    /** HTML autocomplete attribute for browser autofill */
+    autocomplete: _angular_core.InputSignal<string>;
+    /** Maximum character length */
+    maxlength: _angular_core.InputSignal<number | undefined>;
+    /** Emits when password value changes */
+    valueChange: _angular_core.OutputEmitterRef<string>;
+    /** Emits when input loses focus */
+    blurred: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Emits when input gains focus */
+    focused: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Emits when clear button is clicked */
+    clear: _angular_core.OutputEmitterRef<void>;
+    protected isFocused: _angular_core.WritableSignal<boolean>;
+    protected showPassword: _angular_core.WritableSignal<boolean>;
+    protected inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected inputType: _angular_core.Signal<"text" | "password">;
+    protected toggleIcon: _angular_core.Signal<"eye-open" | "eye-closed">;
+    protected toggleAriaLabel: _angular_core.Signal<"Hide password" | "Show password">;
+    protected isDisabled: _angular_core.Signal<boolean>;
+    protected showClearButton: _angular_core.Signal<boolean>;
+    protected hasError: _angular_core.Signal<boolean>;
+    protected displayMessage: _angular_core.Signal<string>;
+    private readonly autoId;
+    protected inputId: _angular_core.Signal<string>;
+    protected messageId: _angular_core.Signal<string>;
+    writeValue(value: string | null): void;
+    protected onInput(event: Event): void;
+    protected onFocus(event: FocusEvent): void;
+    protected onBlur(event: FocusEvent): void;
+    protected onClear(): void;
+    protected onLabelClick(): void;
+    protected togglePasswordVisibility(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarPasswordInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarPasswordInputComponent, "coar-password-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "blurred": "blurred"; "focused": "focused"; "clear": "clear"; }, never, never, true, never>;
+}
+
+type CoarCheckboxSize = 'xs' | 'sm' | 'md' | 'lg';
+type CoarCheckboxState = 'checked' | 'unchecked' | 'indeterminate';
+declare class CoarCheckboxComponent extends CoarControlValueAccessor<CoarCheckboxState | undefined> {
+    /** Label text displayed next to the checkbox */
+    label: _angular_core.InputSignal<string>;
+    /**
+     * Checkbox state: 'checked', 'unchecked', 'indeterminate', or undefined (pristine).
+     * Using model() for two-way binding support.
+     */
+    checked: _angular_core.ModelSignal<CoarCheckboxState | undefined>;
+    /** Disables the checkbox (greyed out, not focusable) */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Prevents changes but keeps normal appearance and focus */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marks as required, shows asterisk on label */
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error message to display below the checkbox */
+    error: _angular_core.InputSignal<string>;
+    /** Hint text displayed below the checkbox */
+    hint: _angular_core.InputSignal<string>;
+    /** Checkbox size - matches input/button heights for consistent layouts */
+    size: _angular_core.InputSignal<CoarCheckboxSize>;
+    /** HTML id attribute for the checkbox element */
+    id: _angular_core.InputSignal<string>;
+    /** HTML name attribute for form submission */
+    name: _angular_core.InputSignal<string>;
+    /** Value submitted with form when checked */
+    value: _angular_core.InputSignal<string>;
+    /** Emits when state changes: 'checked' or 'unchecked' */
+    checkedChange: _angular_core.OutputEmitterRef<CoarCheckboxState>;
+    protected isFocused: _angular_core.WritableSignal<boolean>;
+    protected inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected isDisabled: _angular_core.Signal<boolean>;
+    protected isChecked: _angular_core.Signal<boolean>;
+    protected isIndeterminate: _angular_core.Signal<boolean>;
+    protected hasError: _angular_core.Signal<boolean>;
+    protected displayMessage: _angular_core.Signal<string>;
+    protected inputId: _angular_core.Signal<string>;
+    protected messageId: _angular_core.Signal<string>;
+    constructor();
+    writeValue(value: CoarCheckboxState | undefined | null): void;
+    protected onChange(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected onLabelClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarCheckboxComponent, "coar-checkbox", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "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; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "checkedChange": "checkedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Theme options for the scrollbar appearance.
+ * - 'dark': Dark scrollbar theme (default)
+ * - 'light': Light scrollbar theme
+ */
+type CoarScrollbarTheme = 'dark' | 'light';
+/**
+ * Auto-hide behavior for the scrollbar.
+ * - 'never': Scrollbars are always visible
+ * - 'scroll': Scrollbars hide when not scrolling
+ * - 'leave': Scrollbars hide when pointer leaves the element
+ * - 'move': Scrollbars hide when pointer stops moving
+ */
+type CoarScrollbarAutoHide = 'never' | 'scroll' | 'leave' | 'move';
+/**
+ * Overflow behavior for each axis.
+ * - 'hidden': Content is clipped, no scrollbar
+ * - 'scroll': Always show scrollbar
+ * - 'visible-hidden': Content visible but no scrollbar
+ * - 'visible-scroll': Content visible with scrollbar
+ */
+type CoarScrollbarOverflow = 'hidden' | 'scroll' | 'visible-hidden' | 'visible-scroll';
+/**
+ * Directive that applies custom overlay scrollbars to an element.
+ *
+ * Uses OverlayScrollbars library to replace native scrollbars with
+ * styleable overlay scrollbars while preserving native scroll behavior.
+ *
+ * @example
+ * ```html
+ * <!-- Basic usage -->
+ * <div coarScrollbar>Scrollable content</div>
+ *
+ * <!-- With options -->
+ * <div coarScrollbar [theme]="'light'" [autoHide]="'scroll'">
+ *   Scrollable content
+ * </div>
+ *
+ * <!-- Horizontal only -->
+ * <div coarScrollbar [overflowX]="'scroll'" [overflowY]="'hidden'">
+ *   Horizontal scrollable content
+ * </div>
+ * ```
+ */
+declare class CoarScrollbarDirective implements AfterViewInit, OnDestroy {
+    private readonly elementRef;
+    private readonly ngZone;
+    /** Theme for scrollbar appearance */
+    readonly theme: _angular_core.InputSignal<CoarScrollbarTheme>;
+    /** Auto-hide behavior for scrollbars */
+    readonly autoHide: _angular_core.InputSignal<CoarScrollbarAutoHide>;
+    /** Delay in ms before auto-hide triggers */
+    readonly autoHideDelay: _angular_core.InputSignal<number>;
+    /** Whether clicking the track scrolls to that position */
+    readonly clickScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Overflow behavior for x-axis */
+    readonly overflowX: _angular_core.InputSignal<CoarScrollbarOverflow>;
+    /** Overflow behavior for y-axis */
+    readonly overflowY: _angular_core.InputSignal<CoarScrollbarOverflow>;
+    /** Whether to defer initialization until browser is idle */
+    readonly defer: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Overscroll behavior to prevent scroll chaining to parent elements.
+     * - 'auto': Default browser behavior (scroll chains to parent)
+     * - 'contain': Prevents scroll chaining when reaching scroll boundaries
+     * - 'none': Prevents scroll chaining and disables bounce effects
+     */
+    readonly overscrollBehavior: _angular_core.InputSignal<"auto" | "none" | "contain">;
+    private osInstance;
+    private initialized;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Returns the OverlayScrollbars instance or null if not initialized.
+     */
+    getInstance(): OverlayScrollbars | null;
+    /**
+     * Scrolls to the specified position.
+     */
+    scrollTo(options: {
+        x?: number;
+        y?: number;
+    }): void;
+    /**
+     * Scrolls to the bottom of the scrollable content.
+     */
+    scrollToBottom(): void;
+    /**
+     * Scrolls to the top of the scrollable content.
+     */
+    scrollToTop(): void;
+    /**
+     * Updates the scrollbar (useful after dynamic content changes).
+     */
+    update(): void;
+    private deferInitialization;
+    private initialize;
+    private buildOptions;
+    private destroy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarScrollbarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoarScrollbarDirective, "[coarScrollbar]", never, { "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "autoHide": { "alias": "autoHide"; "required": false; "isSignal": true; }; "autoHideDelay": { "alias": "autoHideDelay"; "required": false; "isSignal": true; }; "clickScroll": { "alias": "clickScroll"; "required": false; "isSignal": true; }; "overflowX": { "alias": "overflowX"; "required": false; "isSignal": true; }; "overflowY": { "alias": "overflowY"; "required": false; "isSignal": true; }; "defer": { "alias": "defer"; "required": false; "isSignal": true; }; "overscrollBehavior": { "alias": "overscrollBehavior"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Represents a selectable option in select components.
+ *
+ * @template T - The type of the option value
+ */
+interface CoarSelectOption<T = unknown> {
+    /** The value stored when this option is selected */
+    value: T;
+    /** The display label shown in the dropdown and selected state */
+    label: string;
+    /** Whether this option is disabled and cannot be selected */
+    disabled?: boolean;
+    /** Optional group this option belongs to (for grouped options) */
+    group?: string;
+    /** Optional icon to display next to the label */
+    icon?: string;
+}
+
+type CoarSelectSize = 'xs' | 'sm' | 'md' | 'lg';
+/** Dropdown position relative to the trigger */
+type CoarDropdownPosition = 'top' | 'bottom';
+/**
+ * Base class providing shared functionality for all select components.
+ * Handles dropdown state, keyboard navigation, and common styling.
+ * Subclasses override openDropdown() to use the overlay system.
+ */
+declare abstract class CoarSelectBase<T> extends CoarControlValueAccessor<T> {
+    protected readonly elementRef: ElementRef<any>;
+    protected readonly destroyRef: DestroyRef;
+    /** Label text displayed above the select */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder text shown when no option is selected */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Available options to choose from */
+    options: _angular_core.InputSignal<CoarSelectOption<unknown>[]>;
+    /** Select size - matches button/input heights for consistent layouts */
+    size: _angular_core.InputSignal<CoarSelectSize>;
+    /** Disables the select (greyed out, not focusable) */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Makes the select read-only (focusable but not editable) */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Marks the select as required, shows asterisk on label */
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error message to display below the select */
+    error: _angular_core.InputSignal<string>;
+    /** Hint text displayed below the select */
+    hint: _angular_core.InputSignal<string>;
+    /** HTML id attribute for the select element */
+    id: _angular_core.InputSignal<string>;
+    /** HTML name attribute for form submission */
+    name: _angular_core.InputSignal<string>;
+    /** Enable search/filter functionality within the dropdown */
+    searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Search input placeholder when searchable is enabled */
+    searchPlaceholder: _angular_core.InputSignal<string>;
+    /**
+     * Comparison function to match values with options.
+     * Use this when value objects come from different sources (e.g., API vs form).
+     *
+     * @example
+     * ```typescript
+     * // Compare Country objects by their ID
+     * compareById = (a: Country | null, b: Country | null) => a?.id === b?.id;
+     * ```
+     */
+    compareWith: _angular_core.InputSignal<((o1: unknown, o2: unknown) => boolean) | undefined>;
+    /** Force dropdown position ('auto' calculates based on available space) */
+    dropdownPositionPreference: _angular_core.InputSignal<"auto" | "top" | "bottom">;
+    /** Reference to the scrollbar directive for scroll control */
+    protected scrollbarRef: _angular_core.Signal<CoarScrollbarDirective | undefined>;
+    /** Reference to the options list container for scroll-into-view */
+    protected optionsListRef: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    /** Reference to the search input for focusing (when searchable) */
+    protected searchInputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    /** DOM id for the dropdown search input (when searchable). */
+    protected searchInputId: _angular_core.Signal<string>;
+    /** Whether the dropdown is currently open */
+    protected isOpen: _angular_core.WritableSignal<boolean>;
+    /** Whether the select is focused */
+    protected isFocused: _angular_core.WritableSignal<boolean>;
+    /** Current search/filter query */
+    protected searchQuery: _angular_core.WritableSignal<string>;
+    /** Currently highlighted option index for keyboard navigation */
+    protected highlightedIndex: _angular_core.WritableSignal<number>;
+    /** Current dropdown position */
+    protected dropdownPosition: _angular_core.WritableSignal<CoarDropdownPosition>;
+    /** Combined disabled state from input and CVA */
+    protected isDisabled: _angular_core.Signal<boolean>;
+    /** Whether there's an error to display */
+    protected hasError: _angular_core.Signal<boolean>;
+    /** Message to display (error takes priority over hint) */
+    protected displayMessage: _angular_core.Signal<string>;
+    /** Generated unique ID for the select element */
+    protected inputId: _angular_core.Signal<string>;
+    /** ID for the message element (for aria-describedby) */
+    protected messageId: _angular_core.Signal<string>;
+    /** ID for the listbox element */
+    protected listboxId: _angular_core.Signal<string>;
+    /** Filtered options based on search query */
+    protected filteredOptions: _angular_core.Signal<CoarSelectOption<unknown>[]>;
+    /**
+     * Options for display, reversed when dropdown opens to top.
+     * This ensures the first option is always nearest to the trigger.
+     */
+    protected displayOptions: _angular_core.Signal<CoarSelectOption<unknown>[]>;
+    /**
+     * Check if a display index is highlighted.
+     * When reversed, converts display index to data index.
+     */
+    protected isHighlighted(displayIndex: number): boolean;
+    /**
+     * Set highlight from display index.
+     * When reversed, converts display index to data index.
+     */
+    protected setHighlightFromDisplay(displayIndex: number): void;
+    constructor();
+    /** Toggle dropdown open/closed state */
+    protected toggleDropdown(): void;
+    /**
+     * Open the dropdown.
+     * Subclasses MUST override this method to implement overlay-based dropdown.
+     */
+    protected openDropdown(): void;
+    /**
+     * Close the dropdown.
+     * Subclasses MUST override this method to implement overlay-based dropdown.
+     */
+    protected closeDropdown(): void;
+    /** Handle keyboard navigation */
+    protected onKeyDown(event: KeyboardEvent): void;
+    /** Move highlight to the next available option */
+    protected highlightNextOption(): void;
+    /** Move highlight to the previous available option */
+    protected highlightPreviousOption(): void;
+    /** Move highlight to the first available option */
+    protected highlightFirstOption(): void;
+    /** Move highlight to the last available option */
+    protected highlightLastOption(): void;
+    /** Scroll the highlighted option into view */
+    protected scrollToHighlighted(): void;
+    protected focusSearchInput(): void;
+    protected scrollOptionsToBottom(): void;
+    protected getOptionsListElement(): HTMLDivElement | null;
+    /**
+     * CSS selector for the highlighted option element.
+     * Each component defines its own selector based on its CSS class naming.
+     */
+    protected abstract get highlightedOptionSelector(): string;
+    /** Handle focus event */
+    protected onFocus(): void;
+    /** Handle blur event */
+    protected onBlur(): void;
+    /** Handle search input changes */
+    protected onSearchInput(event: Event): void;
+    /** Whether this select should close on document clicks outside its host element. */
+    protected shouldCloseOnOutsideClick(): boolean;
+    /** Setup click outside handler to close dropdown. */
+    protected installOutsideClickHandler(): void;
+    /** Abstract method to select the currently highlighted option */
+    protected abstract selectHighlightedOption(): void;
+    /** Abstract method to get the display text for the current selection */
+    abstract getDisplayText(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarSelectBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoarSelectBase<any>, never, never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "dropdownPositionPreference": { "alias": "dropdownPositionPreference"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Single-select dropdown component.
+ *
+ * Allows selecting one option from a list with keyboard navigation,
+ * search/filter support, and full forms integration.
+ *
+ * @example
+ * ```html
+ * <coar-single-select
+ *   label="Country"
+ *   [options]="countries"
+ *   [(value)]="selectedCountry"
+ *   placeholder="Select a country"
+ * />
+ * ```
+ */
+declare class CoarSingleSelectComponent<T = unknown> extends CoarSelectBase<T | null> {
+    private readonly overlayBuilder;
+    private readonly destroyRefLocal;
+    private readonly triggerRef;
+    private readonly dropdownTemplateRef;
+    private overlayRef;
+    /** Current selected value (two-way bindable with [(value)]) */
+    value: _angular_core.ModelSignal<T | null>;
+    /** Whether to show a clear button when a value is selected */
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emits when the selected value changes */
+    valueChange: _angular_core.OutputEmitterRef<T | null>;
+    /** CSS selector for highlighted option (used by base class scrollToHighlighted) */
+    protected get highlightedOptionSelector(): string;
+    /** The currently selected option object */
+    protected selectedOption: _angular_core.Signal<CoarSelectOption<unknown> | null>;
+    /** Whether to show the clear button */
+    protected showClearButton: _angular_core.Signal<boolean>;
+    /** Display text for the current selection */
+    getDisplayText(): string;
+    /** Write value from forms API */
+    writeValue(value: T | null): void;
+    /** Select an option by its value */
+    selectOption(option: CoarSelectOption<T>): void;
+    /** Select the currently highlighted option */
+    protected selectHighlightedOption(): void;
+    /** Clear the current selection */
+    protected clearSelection(event: Event): void;
+    /** Check if an option is currently selected */
+    protected isSelected(option: CoarSelectOption): boolean;
+    protected shouldCloseOnOutsideClick(): boolean;
+    protected openDropdown(): void;
+    protected closeDropdown(): void;
+    private resolvePlacement;
+    private estimatePanelHeight;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarSingleSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarSingleSelectComponent<any>, "coar-single-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Multi-select dropdown component.
+ *
+ * Allows selecting multiple options from a list with checkboxes,
+ * keyboard navigation, search/filter support, and full forms integration.
+ *
+ * @example
+ * ```html
+ * <coar-multi-select
+ *   label="Skills"
+ *   [options]="skills"
+ *   [(value)]="selectedSkills"
+ *   placeholder="Select skills..."
+ * />
+ * ```
+ */
+declare class CoarMultiSelectComponent<T = unknown> extends CoarSelectBase<T[]> {
+    private readonly overlayBuilder;
+    private readonly triggerRef;
+    private readonly dropdownTemplateRef;
+    private overlayRef;
+    /** Current selected values (two-way bindable with [(value)]) */
+    value: _angular_core.ModelSignal<T[]>;
+    /** Whether to show a clear button when values are selected */
+    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Maximum number of selected items to display before showing count */
+    maxDisplayItems: _angular_core.InputSignal<number>;
+    /** Whether to show "Select All" option */
+    showSelectAll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emits when the selected values change */
+    valueChange: _angular_core.OutputEmitterRef<T[]>;
+    /** CSS selector for highlighted option (used by base class scrollToHighlighted) */
+    protected get highlightedOptionSelector(): string;
+    /** The currently selected option objects */
+    protected selectedOptions: _angular_core.Signal<CoarSelectOption<unknown>[]>;
+    /** Whether to show the clear button */
+    protected showClearButton: _angular_core.Signal<boolean>;
+    /** Whether all options are selected */
+    protected allSelected: _angular_core.Signal<boolean>;
+    /** Whether some but not all options are selected */
+    protected someSelected: _angular_core.Signal<boolean>;
+    /** Display text for the current selection */
+    getDisplayText(): string;
+    /** Write value from forms API */
+    writeValue(value: T[] | null): void;
+    /** Toggle selection of an option */
+    toggleOption(option: CoarSelectOption<T>, event?: Event): void;
+    /** Select the currently highlighted option */
+    protected selectHighlightedOption(): void;
+    /** Toggle all options */
+    protected toggleAll(event?: Event): void;
+    /** Clear all selections */
+    protected clearSelection(event: Event): void;
+    /** Check if an option is currently selected */
+    protected isSelected(option: CoarSelectOption): boolean;
+    /** Handle keyboard for multi-select (space toggles instead of closing) */
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected shouldCloseOnOutsideClick(): boolean;
+    protected openDropdown(): void;
+    protected closeDropdown(): void;
+    private resolvePlacement;
+    private estimatePanelHeight;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarMultiSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarMultiSelectComponent<any>, "coar-multi-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "maxDisplayItems": { "alias": "maxDisplayItems"; "required": false; "isSignal": true; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Tag-based multi-select component.
+ *
+ * Displays selected items as removable tag chips with support for
+ * creating new tags on-the-fly (optional), keyboard navigation,
+ * and full forms integration.
+ *
+ * @example
+ * ```html
+ * <coar-tag-select
+ *   label="Tags"
+ *   [options]="availableTags"
+ *   [(value)]="selectedTags"
+ *   [allowCreate]="true"
+ *   placeholder="Add tags..."
+ * />
+ * ```
+ */
+declare class CoarTagSelectComponent<T = string> extends CoarSelectBase<T[]> {
+    private readonly overlayBuilder;
+    private readonly triggerRef;
+    private readonly dropdownTemplateRef;
+    private overlayRef;
+    /** Current selected values (two-way bindable with [(value)]) */
+    value: _angular_core.ModelSignal<T[]>;
+    /** Allow creating new tags that don't exist in options */
+    allowCreate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Maximum number of tags that can be selected (0 = unlimited) */
+    maxTags: _angular_core.InputSignal<number>;
+    /** Text shown when creating a new tag */
+    createPrefix: _angular_core.InputSignal<string>;
+    /** Emits when the selected values change */
+    valueChange: _angular_core.OutputEmitterRef<T[]>;
+    /** Emits when a new tag is created */
+    tagCreated: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Reference to the inline search input (tag-select uses inline input, not dropdown search).
+     * This is separate from the base class searchInputRef.
+     */
+    protected inlineInputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    /** CSS selector for highlighted option (used by base class scrollToHighlighted) */
+    protected get highlightedOptionSelector(): string;
+    /** The currently selected option objects */
+    protected selectedOptions: _angular_core.Signal<CoarSelectOption<unknown>[]>;
+    /** Available options that aren't already selected */
+    protected availableOptions: _angular_core.Signal<CoarSelectOption<unknown>[]>;
+    /**
+     * Available options for display, reversed when dropdown opens to top.
+     * This ensures the first option is always nearest to the trigger.
+     */
+    protected displayAvailableOptions: _angular_core.Signal<CoarSelectOption<unknown>[]>;
+    /**
+     * Check if a display index is highlighted (for availableOptions).
+     * When reversed, converts display index to data index.
+     */
+    protected isAvailableHighlighted(displayIndex: number): boolean;
+    /**
+     * Set highlight from display index (for availableOptions).
+     * When reversed, converts display index to data index.
+     */
+    protected setAvailableHighlightFromDisplay(displayIndex: number): void;
+    /** Whether the max tags limit has been reached */
+    protected maxReached: _angular_core.Signal<boolean>;
+    /** Whether to show the "Create" option */
+    protected showCreateOption: _angular_core.Signal<boolean>;
+    /** Display text for the current selection */
+    getDisplayText(): string;
+    /** Write value from forms API */
+    writeValue(value: T[] | null): void;
+    /** Add a tag from an option */
+    addTag(option: CoarSelectOption<T>): void;
+    /** Remove a tag by value */
+    removeTag(tagValue: T, event?: Event): void;
+    /** Create a new tag from the search query */
+    protected createTag(): void;
+    /** Select the currently highlighted option */
+    protected selectHighlightedOption(): void;
+    /** Handle keyboard for tag-select */
+    protected onKeyDown(event: KeyboardEvent): void;
+    /** Handle input changes */
+    protected onInputChange(event: Event): void;
+    /** Focus the inline input */
+    protected focusInput(): void;
+    /** Handle input focus */
+    protected onInputFocus(): void;
+    /** Handle input blur */
+    protected onInputBlur(): void;
+    /** Override to calculate highlighted index including create option */
+    protected highlightNextOption(): void;
+    /** Scroll highlighted option into view */
+    protected scrollToHighlighted(): void;
+    protected shouldCloseOnOutsideClick(): boolean;
+    protected openDropdown(): void;
+    protected closeDropdown(): void;
+    private resolvePlacement;
+    private estimatePanelHeight;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarTagSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarTagSelectComponent<any>, "coar-tag-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "allowCreate": { "alias": "allowCreate"; "required": false; "isSignal": true; }; "maxTags": { "alias": "maxTags"; "required": false; "isSignal": true; }; "createPrefix": { "alias": "createPrefix"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "tagCreated": "tagCreated"; }, never, never, true, never>;
+}
+
+type CoarIconRegisteredSource = Readonly<{
+    key: string;
+    isDefault: boolean;
+    canProvideIconKeys: boolean;
+}>;
+declare class CoarIconService {
+    private readonly builtInSource;
+    private readonly sourceEntries;
+    private readonly defaultSourceOverrides;
+    private readonly sourceByKey;
+    /**
+     * Get an icon by name from a specific icon source.
+     *
+     * - If `sourceKey` is omitted, the default source is used.
+     * - If no source is configured, this throws to make misconfiguration obvious.
+     */
+    getIcon(name: string, sourceKey?: string): Observable<string | null>;
+    /**
+     * List all registered icon sources.
+     *
+     * This is useful for UIs that allow users to browse icons grouped by source.
+     */
+    getRegisteredSources(): ReadonlyArray<CoarIconRegisteredSource>;
+    /**
+     * Get the available icon keys from a specific source.
+     *
+     * Throws if the source does not support listing keys.
+     */
+    getAvailableIconKeys(sourceKey?: string): Observable<readonly string[]>;
+    clearCache(): void;
+    clearIconCache(name: string): void;
+    private getSourceOrThrow;
+    private getSourceEntryOrThrow;
+    private getDefaultSourceKeyOrThrow;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarIconService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CoarIconService>;
+}
+
+interface CoarIconSource {
+    getIcon(name: string): Observable<string | null>;
+    getAvailableIconKeys?(): Observable<readonly string[]>;
+    clearCache?(): void;
+    clearIconCache?(name: string): void;
+}
+type CoarIconSourceEntry = Readonly<{
+    key: string;
+    source: CoarIconSource;
+}>;
+declare const COAR_ICON_SOURCE_ENTRY: InjectionToken<Readonly<{
+    key: string;
+    source: CoarIconSource;
+}>>;
+declare const COAR_DEFAULT_ICON_SOURCE_KEY: InjectionToken<string>;
+type ProvideCoarIconSourceOptions = Readonly<{
+    key: string;
+    source: CoarIconSource;
+}>;
+declare function provideCoarIconSource(options: ProvideCoarIconSourceOptions): Provider;
+type ProvideCoarIconMapSourceOptions = Readonly<{
+    key: string;
+    icons: Readonly<Record<string, string>>;
+}>;
+declare function provideCoarIconMapSource(options: ProvideCoarIconMapSourceOptions): Provider;
+declare function provideCoarDefaultIconSource(key: string): Provider;
+type ProvideCoarHttpIconSourceOptions = Readonly<{
+    key: string;
+    getUrl: (iconName: string) => string;
+    getAvailableIconKeys?: (http: HttpClient) => Observable<readonly string[]>;
+}>;
+declare function provideCoarHttpIconSource(options: ProvideCoarHttpIconSourceOptions): Provider;
+
+declare const COAR_BUILTIN_ICON_SOURCE_KEY: "coar-builtin";
+/**
+ * Overrides (and/or adds) built-in icons while keeping the built-in set as a base.
+ *
+ * This registers a map source under the fixed key `coar-builtin`, so it replaces the
+ * built-in fallback source inside `CoarIconService`.
+ */
+declare function provideCoarIconBuiltInOverrides(overrides: Readonly<Record<string, string>>): Provider;
+
+/**
+ * Loading strategy for tab content:
+ * - 'lazy': Content is only rendered when tab is active (default)
+ * - 'eager': Content is always rendered, hidden when inactive
+ */
+type TabLoadingStrategy = 'eager' | 'lazy';
+/**
+ * Content type that can be passed to a tab.
+ * Either a TemplateRef (from ng-template) or a Component class.
+ */
+type TabContent = TemplateRef<unknown> | Type<unknown>;
+/**
+ * Individual tab definition for use within CoarTabGroup.
+ *
+ * The tab label is provided as content projected into the component.
+ * This allows simple text, icons, badges, or any custom HTML.
+ *
+ * @example Simple text label
+ * ```html
+ * <coar-tab id="home" [content]="homeTemplate">Home</coar-tab>
+ * ```
+ *
+ * @example With icon
+ * ```html
+ * <coar-tab id="settings" [content]="SettingsComponent">⚙️ Settings</coar-tab>
+ * ```
+ *
+ * @example Rich label with badge
+ * ```html
+ * <coar-tab id="messages" [content]="messagesTemplate">
+ *   Messages <span class="badge">5</span>
+ * </coar-tab>
+ * ```
+ */
+declare class CoarTabComponent {
+    /** Unique identifier for the tab */
+    id: _angular_core.InputSignal<string>;
+    /** Whether the tab is disabled */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The content to display in the tab panel.
+     * Can be either a TemplateRef (from ng-template) or a Component class.
+     */
+    content: _angular_core.InputSignal<TabContent>;
+    /**
+     * Inputs to pass when content is a Component.
+     * Ignored when content is a TemplateRef.
+     */
+    contentInputs: _angular_core.InputSignal<Record<string, unknown>>;
+    /**
+     * Loading strategy for the tab content.
+     * - 'lazy' (default): Content is only rendered when tab becomes active
+     * - 'eager': Content is always rendered, just hidden when inactive
+     */
+    loadingStrategy: _angular_core.InputSignal<TabLoadingStrategy>;
+    /** Template reference for the projected label content */
+    labelTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    /**
+     * Whether the content is a Component (vs a TemplateRef)
+     */
+    get isComponent(): boolean;
+    /**
+     * Get content as TemplateRef (returns null if it's a component)
+     */
+    get templateContent(): TemplateRef<unknown> | null;
+    /**
+     * Get content as Component type (returns null if it's a template)
+     */
+    get componentContent(): Type<unknown> | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarTabComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarTabComponent, "coar-tab", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "contentInputs": { "alias": "contentInputs"; "required": false; "isSignal": true; }; "loadingStrategy": { "alias": "loadingStrategy"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class CoarTabGroupComponent implements AfterContentInit {
+    /** The currently active tab id */
+    activeTab: _angular_core.InputSignal<string>;
+    /** Emits when the active tab changes */
+    activeTabChange: _angular_core.OutputEmitterRef<string>;
+    /** All tab components projected into this group */
+    tabs: _angular_core.Signal<readonly CoarTabComponent[]>;
+    /** Internal active tab state */
+    protected internalActiveTab: _angular_core.WritableSignal<string>;
+    constructor();
+    ngAfterContentInit(): void;
+    /** Check if a tab is currently active */
+    isActive(tabId: string): boolean;
+    /**
+     * Determines whether the content of a tab should be rendered.
+     * - For 'eager' strategy: always render (content stays in DOM)
+     * - For 'lazy' strategy: only render when active
+     */
+    shouldRenderContent(tab: CoarTabComponent): boolean;
+    /** Select a tab by its id */
+    selectTab(tabId: string): void;
+    /** Handle keyboard navigation */
+    onKeydown(event: KeyboardEvent, currentTabId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarTabGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarTabGroupComponent, "coar-tab-group", never, { "activeTab": { "alias": "activeTab"; "required": false; "isSignal": true; }; }, { "activeTabChange": "activeTabChange"; }, ["tabs"], never, true, never>;
+}
+
+declare class CoarCodeBlockComponent {
+    private readonly injector;
+    /** The code to display */
+    code: _angular_core.InputSignal<string>;
+    /** Language for syntax highlighting */
+    language: _angular_core.InputSignal<string>;
+    /** Title/label for the code block */
+    title: _angular_core.InputSignal<string>;
+    /** Whether the code block can be collapsed */
+    collapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the code block starts collapsed */
+    collapsed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show the copy button */
+    showCopy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show line numbers */
+    showLineNumbers: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Maximum height before scrolling (0 = no limit) */
+    maxHeight: _angular_core.InputSignal<number>;
+    /** Internal collapsed state */
+    protected isCollapsed: _angular_core.WritableSignal<boolean>;
+    /** Copy feedback state */
+    protected copyFeedback: _angular_core.WritableSignal<"error" | "idle" | "copied">;
+    /** Highlighted code HTML */
+    protected highlightedCode: _angular_core.Signal<string>;
+    /** Highlighted code split by line for optional line-number rendering */
+    protected highlightedLines: _angular_core.Signal<string[]>;
+    constructor();
+    /** Map common language aliases to Prism language names */
+    private mapLanguage;
+    /** Escape HTML for plain text fallback */
+    private escapeHtml;
+    /** Toggle collapsed state */
+    toggleCollapsed(): void;
+    /** Copy code to clipboard */
+    copyCode(): Promise<void>;
+    /** Get lines for line numbers */
+    get lines(): number[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarCodeBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarCodeBlockComponent, "coar-code-block", never, { "code": { "alias": "code"; "required": true; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "showCopy": { "alias": "showCopy"; "required": false; "isSignal": true; }; "showLineNumbers": { "alias": "showLineNumbers"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type CardColor = 'neutral' | 'success' | 'warning' | 'error' | 'info' | 'accent';
+type CardPadding = 'none' | 'sm' | 'md' | 'lg';
+declare class CoarCardComponent {
+    /**
+     * Adds a box-shadow for elevation/depth.
+     * Use as boolean attribute: `<coar-card elevated>` or `[elevated]="true"`
+     */
+    elevated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Removes the border from the card, leaving only background color.
+     * By default (false), cards have a visible border matching their color.
+     * Use as boolean attribute: `<coar-card borderless>` or `[borderless]="true"`
+     */
+    borderless: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Card color scheme */
+    color: _angular_core.InputSignal<CardColor>;
+    /** Card padding size */
+    padding: _angular_core.InputSignal<CardPadding>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarCardComponent, "coar-card", never, { "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; "borderless": { "alias": "borderless"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["[coar-card-header]", "*", "[coar-card-footer]"], true, never>;
+}
+
+type NoteColor = 'neutral' | 'success' | 'warning' | 'error' | 'info' | 'accent';
+type NotePadding = 'sm' | 'md' | 'lg';
+/**
+ * A callout/note component for highlighting information.
+ *
+ * Features a colored left border and subtle background.
+ * Use for tips, warnings, important information, or behavioral notes.
+ *
+ * @example
+ * ```html
+ * <coar-note color="info">
+ *   <strong>Note:</strong> This is important information.
+ * </coar-note>
+ *
+ * <coar-note color="warning" padding="lg">
+ *   <h4>Warning</h4>
+ *   <p>Be careful with this action.</p>
+ * </coar-note>
+ * ```
+ */
+declare class CoarNoteComponent {
+    /**
+     * Note color scheme.
+     * Determines the left border color and background tint.
+     * @default 'info'
+     */
+    color: _angular_core.InputSignal<NoteColor>;
+    /**
+     * Note padding size.
+     * @default 'md'
+     */
+    padding: _angular_core.InputSignal<NotePadding>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarNoteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarNoteComponent, "coar-note", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type ButtonVariant = 'primary' | 'secondary' | 'tertiary' | 'danger' | 'ghost';
+type ButtonSize = 'xs' | 'sm' | 'md' | 'lg';
+declare class CoarButtonComponent {
+    /** Button visual variant */
+    variant: _angular_core.InputSignal<ButtonVariant>;
+    /** Button size */
+    size: _angular_core.InputSignal<ButtonSize>;
+    /** Whether the button is disabled */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the button is in loading state */
+    loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Button type attribute */
+    type: _angular_core.InputSignal<"button" | "reset" | "submit">;
+    /** Icon to display before the label */
+    iconStart: _angular_core.InputSignal<string | undefined>;
+    /** Icon to display after the label */
+    iconEnd: _angular_core.InputSignal<string | undefined>;
+    /** Whether the button should take full width */
+    fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Optional aria-label applied to the underlying <button> element */
+    ariaLabel: _angular_core.InputSignal<string>;
+    /** Emitted when the button is clicked (not emitted when disabled or loading) */
+    clicked: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** Maps button size to appropriate icon size */
+    protected readonly iconSize: _angular_core.Signal<CoarIconSize>;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarButtonComponent, "coar-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "iconStart": { "alias": "iconStart"; "required": false; "isSignal": true; }; "iconEnd": { "alias": "iconEnd"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+}
+
+type BadgeVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
+type BadgeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'auto';
+declare class CoarBadgeComponent {
+    /** Content to display in the badge (number, text, or icon) */
+    content: _angular_core.InputSignal<string | number>;
+    /** Badge visual variant */
+    variant: _angular_core.InputSignal<BadgeVariant>;
+    /** Badge size */
+    size: _angular_core.InputSignal<BadgeSize>;
+    /** Whether the badge should pulse/animate (for notifications) */
+    pulse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show as a dot without content */
+    dot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Maximum number to display (shows "99+" if exceeded) */
+    max: _angular_core.InputSignal<number | null>;
+    /** Whether to show a border around the badge */
+    bordered: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Computed display value */
+    protected displayValue: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarBadgeComponent, "coar-badge", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "pulse": { "alias": "pulse"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Tag color variants - mirrors CardColor for visual consistency.
+ * Tags are the "little brother" of Cards with the same color system.
+ */
+type TagColor = 'neutral' | 'success' | 'warning' | 'error' | 'info' | 'accent';
+/**
+ * Tag size variants.
+ * - sm: Compact tags for dense UIs (10px font)
+ * - md: Default size (12px font)
+ * - lg: Larger tags for emphasis (14px font)
+ */
+type TagSize = 'sm' | 'md' | 'lg';
+/**
+ * CoarTagComponent
+ *
+ * A compact label component for categorizing, labeling, or marking content.
+ * Shares the same color system as CoarCard for visual consistency.
+ *
+ * Unlike badges (pill-shaped, for counts/notifications), tags use
+ * slight rounding and support interactive features like closing.
+ *
+ * @example
+ * ```html
+ * <coar-tag>Default</coar-tag>
+ * <coar-tag color="success">Published</coar-tag>
+ * <coar-tag color="warning" closable (closed)="onRemove()">Draft</coar-tag>
+ * ```
+ */
+declare class CoarTagComponent {
+    /**
+     * Adds a box-shadow for elevation/depth.
+     * Use as boolean attribute: `<coar-tag elevated>` or `[elevated]="true"`
+     */
+    elevated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Removes the border from the tag, leaving only background color.
+     * By default (false), tags have a visible border matching their color.
+     * Use as boolean attribute: `<coar-tag borderless>` or `[borderless]="true"`
+     */
+    borderless: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Tag color scheme - matches Card colors */
+    color: _angular_core.InputSignal<TagColor>;
+    /** Tag size */
+    size: _angular_core.InputSignal<TagSize>;
+    /** Whether the tag can be closed/removed */
+    closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted when the close button is clicked */
+    closed: _angular_core.OutputEmitterRef<void>;
+    /** Handle close button click */
+    protected onClose(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarTagComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarTagComponent, "coar-tag", never, { "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; "borderless": { "alias": "borderless"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Content alignment options for the divider.
+ * - 'center': Content is centered with lines on both sides (default)
+ * - 'left': Content is aligned left with line on the right
+ * - 'right': Content is aligned right with line on the left
+ */
+type DividerAlign = 'left' | 'center' | 'right';
+/**
+ * Visual style variants for the divider line.
+ * - 'subtle': Light, unobtrusive divider (default)
+ * - 'strong': More prominent divider
+ */
+type DividerVariant = 'subtle' | 'strong';
+/**
+ * A flexible divider component for visually separating content sections.
+ *
+ * Supports optional content (text, icons, etc.) via ng-content that can be
+ * aligned left, center, or right. When content is present, the divider line
+ * splits around it.
+ *
+ * @example
+ * <!-- Simple divider -->
+ * <coar-divider />
+ *
+ * @example
+ * <!-- Divider with centered text -->
+ * <coar-divider>OR</coar-divider>
+ *
+ * @example
+ * <!-- Divider with left-aligned content -->
+ * <coar-divider align="left">Section Title</coar-divider>
+ */
+declare class CoarDividerComponent {
+    /** Content alignment when ng-content is provided */
+    align: _angular_core.InputSignal<DividerAlign>;
+    /** Visual style variant */
+    variant: _angular_core.InputSignal<DividerVariant>;
+    /** Width of the divider as a percentage (0-100) */
+    width: _angular_core.InputSignal<number>;
+    /** Spacing above the divider in pixels */
+    spacingTop: _angular_core.InputSignal<number>;
+    /** Spacing below the divider in pixels */
+    spacingBottom: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarDividerComponent, "coar-divider", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "spacingTop": { "alias": "spacingTop"; "required": false; "isSignal": true; }; "spacingBottom": { "alias": "spacingBottom"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A lightweight, hover/focus popover for rich tooltip-like content.
+ *
+ * Uses the overlay system for positioning with automatic placement and viewport clamping.
+ */
+declare class CoarPopoverComponent {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly popoverGroup;
+    private readonly overlayBuilder;
+    private static nextId;
+    private readonly popoverId;
+    protected readonly panelId: string;
+    private overlayRef;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    constructor();
+    /** Disable popover behavior (still renders trigger content). */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable hover/focus behavior (desktop-friendly). Default: false */
+    openOnHover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Enable click/tap behavior (touch-friendly). Default: false */
+    openOnClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the panel should receive pointer events. Default: true */
+    interactive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When a concrete placement is set, fall back to best-fit when it doesn't fit. Default: false */
+    fallbackToBestFit: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the panel should be clamped into the viewport. Default: true */
+    clampToViewport: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When true, the popover is "pinned" open via click and won't close on hover out. */
+    protected readonly pinnedByClick: _angular_core.WritableSignal<boolean>;
+    private closeTimer;
+    private readonly hoveringTrigger;
+    private readonly hoveringPanel;
+    private readonly closeOnDisable;
+    private readonly syncClampToViewport;
+    private readonly syncFallbackToBestFit;
+    private readonly triggerRef;
+    private readonly panelTemplateRef;
+    private getAnchorElement;
+    private readonly closeOnDocumentClick;
+    private openInternal;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onPanelMouseEnter(): void;
+    onPanelMouseLeave(): void;
+    onFocusIn(): void;
+    onPanelFocusIn(): void;
+    onTriggerClick(event: MouseEvent): void;
+    onHostClick(event: MouseEvent): void;
+    close(): void;
+    onFocusOut(event: FocusEvent): void;
+    onPanelFocusOut(event: FocusEvent): void;
+    private scheduleHoverClose;
+    private clearCloseTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarPopoverComponent, "coar-popover", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "openOnClick": { "alias": "openOnClick"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "fallbackToBestFit": { "alias": "fallbackToBestFit"; "required": false; "isSignal": true; }; "clampToViewport": { "alias": "clampToViewport"; "required": false; "isSignal": true; }; }, {}, never, ["[coarPopoverTrigger]", "[coarPopoverContent]"], true, never>;
+}
+
+/**
+ * Local coordination for popovers inside the same container (e.g. a date picker panel).
+ *
+ * Provided by a parent component to ensure only one popover in that scope is open at a time.
+ */
+declare class CoarPopoverGroupService {
+    private activeId;
+    private activeClose;
+    requestOpen(id: string, close: () => void): void;
+    notifyClosed(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarPopoverGroupService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CoarPopoverGroupService>;
+}
+
+type CoarTooltipOverlayContent = string | TemplateRef<unknown> | Type<unknown>;
+
+/** Tooltip placement preference - all 12 standard placements plus 'auto' for best-fit */
+type TooltipPlacement = 'auto' | 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+declare class CoarTooltipDirective {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly tooltipService;
+    /** Tooltip content (string, TemplateRef, or Component type). */
+    readonly coarTooltip: _angular_core.InputSignal<CoarTooltipOverlayContent | null>;
+    /** Optional context for TemplateRef tooltips. */
+    readonly coarTooltipContext: _angular_core.InputSignal<object | null>;
+    /** Disable tooltip behavior. */
+    readonly coarTooltipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Placement preference. Default: 'top'. Use 'auto' for best-fit. */
+    readonly coarTooltipPlacement: _angular_core.InputSignal<TooltipPlacement>;
+    /** Delay (ms) before opening on hover/focus. Default: 0 */
+    readonly coarTooltipOpenDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Delay (ms) before closing on leave/blur. Default: 0 */
+    readonly coarTooltipCloseDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Whether the tooltip should be clamped into the viewport. Default: true */
+    readonly coarTooltipClampToViewport: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** When placement is explicit (not auto), fall back to best-fit when it doesn't fit. Default: false */
+    readonly coarTooltipFallbackToBestFit: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly tooltipId;
+    private overlayRef;
+    private readonly overlayBuilder;
+    private openTimerId;
+    private closeTimerId;
+    private openReason;
+    private readonly hasContent;
+    constructor();
+    private clearTimers;
+    private openInternal;
+    private resolveOverlayPosition;
+    private scheduleOpen;
+    private scheduleClose;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocusIn(): void;
+    onFocusOut(event: FocusEvent): void;
+    close(immediate?: boolean): void;
+    open(): void;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoarTooltipDirective, "[coarTooltip]", ["coarTooltip"], { "coarTooltip": { "alias": "coarTooltip"; "required": false; "isSignal": true; }; "coarTooltipContext": { "alias": "coarTooltipContext"; "required": false; "isSignal": true; }; "coarTooltipDisabled": { "alias": "coarTooltipDisabled"; "required": false; "isSignal": true; }; "coarTooltipPlacement": { "alias": "coarTooltipPlacement"; "required": false; "isSignal": true; }; "coarTooltipOpenDelay": { "alias": "coarTooltipOpenDelay"; "required": false; "isSignal": true; }; "coarTooltipCloseDelay": { "alias": "coarTooltipCloseDelay"; "required": false; "isSignal": true; }; "coarTooltipClampToViewport": { "alias": "coarTooltipClampToViewport"; "required": false; "isSignal": true; }; "coarTooltipFallbackToBestFit": { "alias": "coarTooltipFallbackToBestFit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Available sizes for the label component.
+ * Matches the component size system used by buttons and inputs.
+ */
+type CoarLabelSize = 'xs' | 'sm' | 'md' | 'lg';
+/**
+ * Standalone label component for consistent form labeling across the design system.
+ *
+ * @example
+ * ```html
+ * <coar-label size="sm" [required]="true">Email Address</coar-label>
+ * <coar-text-input size="sm" placeholder="your@email.com" />
+ * ```
+ */
+declare class CoarLabelComponent {
+    /**
+     * Size of the label. Should match the size of the associated input/form element.
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<CoarLabelSize>;
+    /**
+     * Whether to show a required indicator (*) after the label text.
+     * @default false
+     */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The ID of the form element this label is associated with.
+     * Sets the 'for' attribute for accessibility.
+     */
+    readonly for: _angular_core.InputSignal<string | undefined>;
+    readonly text: _angular_core.InputSignal<string>;
+    get isXs(): boolean;
+    get isSm(): boolean;
+    get isMd(): boolean;
+    get isLg(): boolean;
+    get forAttr(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarLabelComponent, "coar-label", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "for": { "alias": "for"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type CoarTableVariant = 'default' | 'plain' | 'bordered';
+/**
+ * A simple table component that provides consistent styling.
+ *
+ * Default styling uses alternating row colors (zebra stripes) for readability.
+ * Use 'plain' variant for no stripes, or 'bordered' for full cell borders.
+ *
+ * Usage:
+ * ```html
+ * <coar-table>
+ *   <thead>
+ *     <tr>
+ *       <th>Property</th>
+ *       <th>Type</th>
+ *     </tr>
+ *   </thead>
+ *   <tbody>
+ *     <tr>
+ *       <td><code>name</code></td>
+ *       <td><code>string</code></td>
+ *     </tr>
+ *   </tbody>
+ * </coar-table>
+ * ```
+ */
+declare class CoarTableComponent {
+    /** Visual variant of the table: default (zebra stripes), plain (no stripes), bordered (cell borders) */
+    variant: _angular_core.InputSignal<CoarTableVariant>;
+    /** Whether to use compact padding */
+    compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether rows should highlight on hover */
+    hover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarTableComponent, "coar-table", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type CoarDatePickerSize = 'xs' | 'sm' | 'md' | 'lg';
+/**
+ * Represents a date marker for highlighting special dates (holidays, events, etc.)
+ * Supports single dates or date ranges.
+ */
+interface CoarDateMarker {
+    /** Start date of the marker (or single date if no endDate) */
+    startDate: Temporal.PlainDate;
+    /** Optional end date for date ranges (inclusive) */
+    endDate?: Temporal.PlainDate;
+    /** Description shown as tooltip on hover */
+    description: string;
+    /** Optional custom CSS class for styling different marker types */
+    cssClass?: string;
+}
+/**
+ * Date picker component using Temporal API.
+ *
+ * Supports Temporal.PlainDate values for timezone-independent date selection.
+ * Uses ISO string format internally for forms compatibility.
+ *
+ * @example
+ * ```html
+ * <coar-date-picker
+ *   label="Birth Date"
+ *   [(value)]="birthDate"
+ *   placeholder="Select date..."
+ * />
+ * ```
+ */
+declare class CoarDatePickerComponent extends CoarControlValueAccessor<Temporal.PlainDate | null> {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly localeService;
+    private readonly overlayBuilder;
+    private overlayRef;
+    /** Label text displayed above the input */
+    label: _angular_core.InputSignal<string>;
+    /** Placeholder text when no date is selected */
+    placeholder: _angular_core.InputSignal<string>;
+    /** Size variant */
+    size: _angular_core.InputSignal<CoarDatePickerSize>;
+    /** Whether the picker is readonly */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the picker is disabled */
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the field is required */
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Error state */
+    error: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Helper or error message */
+    message: _angular_core.InputSignal<string>;
+    /** Minimum selectable date */
+    min: _angular_core.InputSignal<Temporal.PlainDate | null>;
+    /** Maximum selectable date */
+    max: _angular_core.InputSignal<Temporal.PlainDate | null>;
+    /**
+     * Locale identifier for date formatting (e.g., 'de-AT', 'en-US').
+     * Uses global locale service default if not specified.
+     */
+    locale: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Date format configuration (pattern and first day of week).
+     * If not provided, uses locale service default or falls back to European format.
+     */
+    dateFormatConfig: _angular_core.InputSignal<DateFormatConfig | undefined>;
+    /** Whether to show a "Today" button */
+    showTodayButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to show week numbers */
+    showWeekNumbers: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to highlight weekend days (Saturday/Sunday) with a subtle background */
+    highlightWeekends: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Date markers for highlighting special dates (holidays, events, etc.) */
+    markers: _angular_core.InputSignal<CoarDateMarker[]>;
+    /** Maximum number of lines shown in the marker popover (including "+N" line). */
+    protected readonly markerPopoverMaxLines = 5;
+    /**
+     * Visible markers before switching to "+N other events".
+     * With a max of 5 lines, we show 4 markers + one summary line.
+     */
+    protected readonly markerPopoverVisibleMarkers = 4;
+    protected getVisibleMarkers(markers: CoarDateMarker[]): CoarDateMarker[];
+    protected getHiddenMarkerCount(markers: CoarDateMarker[]): number;
+    /** Current selected date (two-way bindable with [(value)]) */
+    value: _angular_core.ModelSignal<Temporal.PlainDate | null>;
+    /** Emitted when the selected date changes */
+    valueChange: _angular_core.OutputEmitterRef<Temporal.PlainDate | null>;
+    /** Emitted when the picker opens */
+    opened: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the picker closes */
+    closed: _angular_core.OutputEmitterRef<void>;
+    /** Unique ID counter for component instances */
+    private static nextId;
+    /** Unique ID for this component instance */
+    private readonly uid;
+    /** Maskito instance for input masking */
+    private maskitoInstance?;
+    /** ID for the label element */
+    protected labelId: _angular_core.Signal<string>;
+    /** ID for the input element */
+    protected inputId: _angular_core.Signal<string>;
+    /** ID for the calendar dropdown */
+    protected calendarId: _angular_core.Signal<string>;
+    /** Whether the calendar dropdown is open */
+    protected isOpen: _angular_core.WritableSignal<boolean>;
+    /** Calendar dropdown position (chosen before opening) */
+    protected calendarPosition: _angular_core.WritableSignal<"top" | "bottom">;
+    /** Currently viewed month/year in the calendar */
+    protected viewDate: _angular_core.WritableSignal<Temporal.PlainYearMonth>;
+    /** Focused date in the calendar (for keyboard navigation) */
+    protected focusedDate: _angular_core.WritableSignal<Temporal.PlainDate | null>;
+    /** Display value for the input field */
+    protected displayValue: _angular_core.WritableSignal<string>;
+    /** Days of week header (localized based on locale and firstDayOfWeek) */
+    protected daysOfWeek: _angular_core.Signal<string[]>;
+    /** Reference to the input element */
+    protected inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    /** Reference to the trigger element */
+    protected triggerRef: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** Reference to the calendar template (rendered via @cocoar/ui-overlay) */
+    protected calendarTemplateRef: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    /**
+     * Effective date format configuration.
+     * Priority: input dateFormatConfig > locale service > fallback
+     */
+    protected effectiveDateFormat: _angular_core.Signal<DateFormatConfig>;
+    /** Get the date format pattern */
+    protected dateFormat: _angular_core.Signal<"dd.mm.yyyy" | "dd/mm/yyyy" | "mm/dd/yyyy" | "yyyy-mm-dd">;
+    /** Get the first day of week */
+    protected firstDayOfWeek: _angular_core.Signal<1 | 7>;
+    /** Get the separator character for the current date format */
+    protected separator: _angular_core.Signal<"." | "/" | "-">;
+    /** Get placeholder text based on date format */
+    protected inputPlaceholder: _angular_core.Signal<string>;
+    /**
+     * Effective locale for calendar month/year display.
+     * Priority: input locale > locale service default > browser locale
+     */
+    protected effectiveLocale: _angular_core.Signal<string>;
+    /** Whether the picker has an error state */
+    protected hasError: _angular_core.Signal<boolean>;
+    /** Whether the picker is disabled */
+    protected isDisabled: _angular_core.Signal<boolean>;
+    /** Calendar grid for current view month */
+    protected calendarDays: _angular_core.Signal<CalendarDay[]>;
+    /** Month name for calendar header */
+    protected viewMonth: _angular_core.Signal<string>;
+    /** Year for calendar header */
+    protected viewYear: _angular_core.Signal<number>;
+    /** Week numbers for each row (6 rows) */
+    protected weekNumbers: _angular_core.Signal<number[]>;
+    /** Today's date */
+    protected today: Temporal.PlainDate;
+    constructor();
+    /** Open the calendar dropdown */
+    openCalendar(): void;
+    /** Close the calendar dropdown */
+    closeCalendar(): void;
+    /** Toggle the calendar dropdown */
+    toggleCalendar(): void;
+    /** Select a date */
+    selectDate(date: Temporal.PlainDate): void;
+    /** Select today's date */
+    selectToday(): void;
+    /** Clear the selected date */
+    clearDate(event: Event): void;
+    /** Navigate to previous month */
+    previousMonth(): void;
+    /** Navigate to next month */
+    nextMonth(): void;
+    /** Navigate to previous year */
+    previousYear(): void;
+    /** Navigate to next year */
+    nextYear(): void;
+    /** Go to today's month */
+    goToToday(): void;
+    writeValue(value: Temporal.PlainDate | string | null): void;
+    protected onTriggerClick(): void;
+    protected onDocumentKeydown(event: KeyboardEvent): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    private resolvePlacement;
+    private estimatePanelHeight;
+    /**
+     * Handle input changes from typed or pasted date values.
+     *
+     * Parses the masked input and updates the value if valid.
+     * Invalid or incomplete dates do not update the model.
+     */
+    protected onInputChange(event: Event): void;
+    /**
+     * Handle blur on the input field.
+     *
+     * If the input contains an invalid date, reset to the current value.
+     */
+    protected onInputBlur(): void;
+    /**
+     * Initialize Maskito for date input masking.
+     *
+     * Uses maskitoDateOptionsGenerator with the configured date format
+     * to provide automatic formatting and validation while typing.
+     */
+    private initializeMaskito;
+    /**
+     * Convert Temporal.PlainDate to native Date for Maskito compatibility.
+     */
+    private temporalToDate;
+    /**
+     * Calculate ISO week number for a date.
+     * ISO weeks start on Monday and week 1 contains the first Thursday of the year.
+     */
+    private calculateISOWeek;
+    /**
+     * Format a Temporal.PlainDate for display according to the configured format.
+     */
+    private formatDateForDisplay;
+    /**
+     * Parse a date string in the configured format to Temporal.PlainDate.
+     * Returns null if the string is incomplete or invalid.
+     */
+    private parseDateFromInput;
+    private createCalendarDay;
+    /**
+     * Find all markers that apply to the given date.
+     * Checks if date falls within any marker's range.
+     */
+    private getMarkersForDate;
+    private isDateDisabled;
+    private moveFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoarDatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoarDatePickerComponent, "coar-date-picker", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dateFormatConfig": { "alias": "dateFormatConfig"; "required": false; "isSignal": true; }; "showTodayButton": { "alias": "showTodayButton"; "required": false; "isSignal": true; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; "isSignal": true; }; "highlightWeekends": { "alias": "highlightWeekends"; "required": false; "isSignal": true; }; "markers": { "alias": "markers"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+/** Internal type for calendar day rendering */
+interface CalendarDay {
+    date: Temporal.PlainDate;
+    day: number;
+    isOutsideMonth: boolean;
+    isToday: boolean;
+    isSelected: boolean;
+    isFocused: boolean;
+    isDisabled: boolean;
+    isWeekend: boolean;
+    /** Markers applied to this date (if any) */
+    markers: CoarDateMarker[];
+    /** Optional CSS class from the first marker for styling */
+    markerCssClass: string | null;
+}
+
+export { COAR_BUILTIN_ICON_SOURCE_KEY, COAR_DEFAULT_ICON_SOURCE_KEY, COAR_ICON_SOURCE_ENTRY, COAR_LOCALE_SERVICE, CoarBadgeComponent, CoarButtonComponent, CoarCardComponent, CoarCheckboxComponent, CoarCodeBlockComponent, CoarControlValueAccessor, CoarDatePickerComponent, CoarDividerComponent, CoarIconComponent, CoarIconService, CoarLabelComponent, CoarLocaleService, CoarMultiSelectComponent, CoarNoteComponent, CoarNumberInputComponent, CoarPasswordInputComponent, CoarPopoverComponent, CoarPopoverGroupService, CoarScrollbarDirective, CoarSingleSelectComponent, CoarTabComponent, CoarTabGroupComponent, CoarTableComponent, CoarTagComponent, CoarTagSelectComponent, CoarTextInputComponent, CoarTooltipDirective, coarProvideValueAccessor, provideCoarDefaultIconSource, provideCoarHttpIconSource, provideCoarIconBuiltInOverrides, provideCoarIconMapSource, provideCoarIconSource };
+export type { BadgeSize, BadgeVariant, ButtonSize, ButtonVariant, CardColor, CardPadding, CoarCheckboxSize, CoarCheckboxState, CoarDateMarker, CoarDatePickerSize, CoarIconRegisteredSource, CoarIconSize, CoarIconSource, CoarIconSourceEntry, CoarLabelSize, CoarNumberInputSize, CoarNumberInputStepperButtons, CoarPasswordInputSize, CoarScrollbarAutoHide, CoarScrollbarOverflow, CoarScrollbarTheme, CoarSelectOption, CoarSelectSize, CoarTableVariant, CoarTextInputSize, DateFormatConfig, DividerAlign, DividerVariant, ICoarLocaleService, LocaleConfig, NoteColor, NotePadding, NumberFormatConfig, ProvideCoarHttpIconSourceOptions, ProvideCoarIconMapSourceOptions, ProvideCoarIconSourceOptions, TabContent, TabLoadingStrategy, TagColor, TagSize };