@lumaui/angular 0.1.4 → 0.2.1

package/types/lumaui-angular.d.ts

@@ -1,18 +1,29 @@
 import * as _angular_core from '@angular/core';
-import { ButtonVariant, ButtonSize, CardVariant, CardTitleSize, CardDescriptionSize } from '@lumaui/core';
+import { InjectionToken, Signal, OnDestroy, WritableSignal, ElementRef, OnInit, AfterViewInit } from '@angular/core';
+import { ButtonVariant, ButtonSize, CardVariant, CardTitleSize, CardDescriptionSize, AccordionItemVariant, AccordionTitleSize, TooltipPosition, TabsStyle, ToastPosition as ToastPosition$1, ToastVariant as ToastVariant$1 } from '@lumaui/core';
+export { ToastCloseVariants, ToastContainerVariants, ToastIconVariants, ToastItemVariants, ToastState } from '@lumaui/core';
+import * as _lumaui_angular from '@lumaui/angular';
+import { Observable } from 'rxjs';
 
-declare class ButtonDirective {
+declare class LmButtonDirective {
     lmVariant: _angular_core.InputSignal<ButtonVariant>;
     lmSize: _angular_core.InputSignal<ButtonSize>;
     lmDisabled: _angular_core.InputSignal<boolean>;
     lmType: _angular_core.InputSignal<"button" | "submit" | "reset">;
     classes: _angular_core.Signal<string>;
     get hostClasses(): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "button[lumaButton], a[lumaButton]", never, { "lmVariant": { "alias": "lmVariant"; "required": false; "isSignal": true; }; "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; "lmDisabled": { "alias": "lmDisabled"; "required": false; "isSignal": true; }; "lmType": { "alias": "lmType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmButtonDirective, "button[lumaButton], a[lumaButton]", never, { "lmVariant": { "alias": "lmVariant"; "required": false; "isSignal": true; }; "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; "lmDisabled": { "alias": "lmDisabled"; "required": false; "isSignal": true; }; "lmType": { "alias": "lmType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class CardComponent {
+declare class LmBadgeDirective {
+    classes: _angular_core.Signal<string>;
+    get hostClasses(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmBadgeDirective, "[lumaBadge]", never, {}, {}, never, never, true, never>;
+}
+
+declare class LmCardComponent {
     /**
      * Card visual style variant
      * - default: Gradient border wrapper style (default)
@@ -23,32 +34,1211 @@ declare class CardComponent {
     lmVariant: _angular_core.InputSignal<CardVariant>;
     wrapperClasses: _angular_core.Signal<string>;
     contentClasses: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "luma-card", never, { "lmVariant": { "alias": "lmVariant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmCardComponent, "luma-card", never, { "lmVariant": { "alias": "lmVariant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class CardTitleDirective {
+declare class LmCardTitleDirective {
     lmSize: _angular_core.InputSignal<CardTitleSize>;
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardTitleDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardTitleDirective, "[lumaCardTitle]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmCardTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmCardTitleDirective, "[lumaCardTitle]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class CardDescriptionDirective {
+declare class LmCardDescriptionDirective {
     lmSize: _angular_core.InputSignal<CardDescriptionSize>;
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardDescriptionDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardDescriptionDirective, "[lumaCardDescription]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmCardDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmCardDescriptionDirective, "[lumaCardDescription]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LmCardHeaderDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmCardHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmCardHeaderDirective, "[lumaCardHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class LmCardContentDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmCardContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmCardContentDirective, "[lumaCardContent]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * AccordionGroupComponent
+ *
+ * Optional wrapper component that coordinates multiple accordion items.
+ * Supports controlled pattern for implementing business logic like:
+ * - Single item open at a time
+ * - Multiple items open
+ * - Always keep first/last item open
+ * - Maximum number of open items
+ *
+ * @example Controlled single mode
+ * ```html
+ * <luma-accordion-group [lmValue]="activeItem()" (lmValueChange)="activeItem.set($event)">
+ *   <luma-accordion-item lmId="item-1">...</luma-accordion-item>
+ *   <luma-accordion-item lmId="item-2">...</luma-accordion-item>
+ * </luma-accordion-group>
+ * ```
+ *
+ * @example Controlled multiple mode
+ * ```html
+ * <luma-accordion-group [lmValue]="activeItems()" (lmValueChange)="activeItems.set($event)">
+ *   <luma-accordion-item lmId="item-1">...</luma-accordion-item>
+ *   <luma-accordion-item lmId="item-2">...</luma-accordion-item>
+ * </luma-accordion-group>
+ * ```
+ */
+declare class LmAccordionGroupComponent {
+    /**
+     * Controlled value for which items are open
+     * - null: uncontrolled mode (each item manages its own state)
+     * - string: single item mode (ID of open item)
+     * - string[]: multiple items mode (IDs of open items)
+     */
+    lmValue: _angular_core.InputSignal<string | string[] | null>;
+    /**
+     * Emitted when an item is toggled
+     * Returns the new value (string for single mode, string[] for multiple)
+     */
+    lmValueChange: _angular_core.OutputEmitterRef<string | string[]>;
+    /**
+     * Force single mode even when lmValue is an array
+     * When true, only one item can be open at a time
+     */
+    lmSingle: _angular_core.InputSignal<boolean>;
+    /**
+     * Toggle an item by its ID
+     * Called by child AccordionItemComponent when toggled
+     */
+    toggleItem(itemId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmAccordionGroupComponent, "luma-accordion-group", never, { "lmValue": { "alias": "lmValue"; "required": false; "isSignal": true; }; "lmSingle": { "alias": "lmSingle"; "required": false; "isSignal": true; }; }, { "lmValueChange": "lmValueChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Interface for accordion item state that child directives can access
+ */
+interface AccordionItemBase {
+    /** Whether the accordion item is currently open */
+    isOpen: Signal<boolean>;
+    /** Whether the accordion item is disabled */
+    lmDisabled: Signal<boolean>;
+    /** Toggle the accordion open/closed state */
+    toggle(): void;
+}
+/**
+ * Injection token for accordion item
+ * Allows child directives to access parent accordion item state
+ */
+declare const ACCORDION_ITEM: InjectionToken<AccordionItemBase>;
+
+/**
+ * AccordionItemComponent
+ *
+ * Wrapper component that contains the trigger and content.
+ * Can be used standalone or within an AccordionGroupComponent.
+ *
+ * @example Standalone usage
+ * ```html
+ * <luma-accordion-item>
+ *   <button lumaAccordionTrigger>
+ *     <span lumaAccordionTitle>Title</span>
+ *     <svg lumaAccordionIcon>...</svg>
+ *   </button>
+ *   <div lumaAccordionContent>Content here...</div>
+ * </luma-accordion-item>
+ * ```
+ *
+ * @example With variants
+ * ```html
+ * <luma-accordion-item lmVariant="filled">
+ *   ...
+ * </luma-accordion-item>
+ * ```
+ */
+declare class LmAccordionItemComponent implements AccordionItemBase {
+    private group;
+    private el;
+    private renderer;
+    private previousClasses;
+    constructor();
+    /**
+     * Unique identifier for this item (required when using AccordionGroup)
+     */
+    lmId: _angular_core.InputSignal<string>;
+    /**
+     * Visual style variant
+     * - default: Standard with border
+     * - bordered: FAQ-style stacked items
+     * - filled: Solid background (unified trigger/content)
+     */
+    lmVariant: _angular_core.InputSignal<AccordionItemVariant>;
+    /**
+     * Initial/controlled open state (for standalone usage)
+     */
+    lmOpen: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the accordion item is disabled
+     */
+    lmDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Emitted when the open state changes
+     * Useful for tracking/analytics
+     */
+    lmOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    private _isOpen;
+    /**
+     * Computed open state
+     * Priority: group controlled > lmOpen input > internal state
+     */
+    isOpen: _angular_core.Signal<boolean>;
+    wrapperClasses: _angular_core.Signal<string>;
+    contentWrapperClasses: _angular_core.Signal<string>;
+    /**
+     * Toggle the accordion open/closed state
+     */
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmAccordionItemComponent, "luma-accordion-item", never, { "lmId": { "alias": "lmId"; "required": false; "isSignal": true; }; "lmVariant": { "alias": "lmVariant"; "required": false; "isSignal": true; }; "lmOpen": { "alias": "lmOpen"; "required": false; "isSignal": true; }; "lmDisabled": { "alias": "lmDisabled"; "required": false; "isSignal": true; }; }, { "lmOpenChange": "lmOpenChange"; }, never, ["[lumaAccordionTrigger]", "[lumaAccordionContent]"], true, never>;
+}
+
+/**
+ * AccordionTriggerDirective
+ *
+ * Applied to a div element to make it the clickable trigger for the accordion.
+ * Uses div instead of button for maximum layout flexibility.
+ * Handles ARIA attributes and keyboard navigation automatically.
+ *
+ * @example Basic usage
+ * ```html
+ * <div lumaAccordionTrigger>
+ *   <span lumaAccordionTitle>Title</span>
+ *   <span lumaAccordionIcon>
+ *     <svg>...</svg>
+ *   </span>
+ * </div>
+ * ```
+ *
+ * @example Custom layout
+ * ```html
+ * <div lumaAccordionTrigger class="grid grid-cols-[auto_1fr_auto] gap-4">
+ *   <svg class="w-6 h-6">...</svg>
+ *   <div>
+ *     <span lumaAccordionTitle>Title</span>
+ *     <p class="text-sm">Description</p>
+ *   </div>
+ *   <span lumaAccordionIcon>
+ *     <svg>...</svg>
+ *   </span>
+ * </div>
+ * ```
+ */
+declare class LmAccordionTriggerDirective {
+    protected item: _lumaui_angular.AccordionItemBase;
+    private id;
+    triggerId: string;
+    contentId: string;
+    classes: _angular_core.Signal<string>;
+    onClick(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmAccordionTriggerDirective, "div[lumaAccordionTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * AccordionTitleDirective
+ *
+ * Applies typography styles to the accordion title.
+ * Supports size variants for different visual hierarchies.
+ *
+ * @example Basic usage
+ * ```html
+ * <span lumaAccordionTitle>What is Luma UI?</span>
+ * ```
+ *
+ * @example With size variant
+ * ```html
+ * <span lumaAccordionTitle lmSize="lg">Large Title</span>
+ * ```
+ */
+declare class LmAccordionTitleDirective {
+    /**
+     * Size variant for the title
+     * - sm: Small text for compact UIs
+     * - md: Default size (base text)
+     * - lg: Large text for emphasis
+     */
+    lmSize: _angular_core.InputSignal<AccordionTitleSize>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmAccordionTitleDirective, "[lumaAccordionTitle]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * AccordionIconDirective
+ *
+ * Applies rotation animation to the accordion icon (typically a chevron).
+ * Must be placed on a wrapper element (span or div), not directly on the SVG.
+ * Automatically rotates based on the open state of the parent accordion item.
+ *
+ * @example With span wrapper (recommended)
+ * ```html
+ * <span lumaAccordionIcon>
+ *   <svg viewBox="0 0 24 24" class="w-4 h-4">
+ *     <path stroke="currentColor" stroke-width="2" d="M19 9l-7 7-7-7" />
+ *   </svg>
+ * </span>
+ * ```
+ *
+ * @example With div wrapper
+ * ```html
+ * <div lumaAccordionIcon>
+ *   <my-chevron-icon></my-chevron-icon>
+ * </div>
+ * ```
+ *
+ * @example Customize rotation via CSS variable
+ * ```html
+ * <span lumaAccordionIcon style="--luma-accordion-icon-rotation: 90deg">
+ *   <svg>...</svg>
+ * </span>
+ * ```
+ */
+declare class LmAccordionIconDirective {
+    protected item: _lumaui_angular.AccordionItemBase;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmAccordionIconDirective, "span[lumaAccordionIcon], div[lumaAccordionIcon]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * AccordionContentDirective
+ *
+ * Applied to the content area of the accordion.
+ * Handles visibility, ARIA attributes, and fade animation.
+ *
+ * @example Basic usage
+ * ```html
+ * <div lumaAccordionContent>
+ *   <p>Your content here...</p>
+ * </div>
+ * ```
+ */
+declare class LmAccordionContentDirective {
+    protected item: _lumaui_angular.AccordionItemBase;
+    protected trigger: LmAccordionTriggerDirective | null;
+    private id;
+    contentId: string;
+    triggerId: _angular_core.Signal<string | null>;
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmAccordionContentDirective, "[lumaAccordionContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class LmTooltipDirective implements OnDestroy {
+    private el;
+    private renderer;
+    private platformId;
+    lumaTooltip: _angular_core.InputSignal<string>;
+    lmPosition: _angular_core.InputSignal<TooltipPosition>;
+    lmHtml: _angular_core.InputSignal<boolean>;
+    lmTrigger: _angular_core.InputSignal<"click" | "hover" | "focus">;
+    lmDelay: _angular_core.InputSignal<number>;
+    isVisible: _angular_core.WritableSignal<boolean>;
+    actualPosition: _angular_core.WritableSignal<TooltipPosition>;
+    tooltipId: string;
+    private tooltipElement;
+    private showTimeout;
+    classes: _angular_core.Signal<string>;
+    constructor();
+    private ensureTooltipElement;
+    private updateContent;
+    private updateClasses;
+    private isTouchDevice;
+    private getFlippedPosition;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onClick(): void;
+    onFocus(): void;
+    onBlur(): void;
+    onEscape(): void;
+    onDocumentClick(event: Event): void;
+    onDocumentTouch(event: TouchEvent): void;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmTooltipDirective, "[lumaTooltip]", never, { "lumaTooltip": { "alias": "lumaTooltip"; "required": true; "isSignal": true; }; "lmPosition": { "alias": "lmPosition"; "required": false; "isSignal": true; }; "lmHtml": { "alias": "lmHtml"; "required": false; "isSignal": true; }; "lmTrigger": { "alias": "lmTrigger"; "required": false; "isSignal": true; }; "lmDelay": { "alias": "lmDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TabsGroupBase {
+    /** Currently selected tab value */
+    value: WritableSignal<string | null>;
+    /** Visual style of the tabs (underline, background, pill) */
+    lmVariant: Signal<TabsStyle>;
+    /** Whether to lazy load panel content */
+    lmLazy: Signal<boolean>;
+    /** Select a tab by value */
+    select(value: string): void;
+    /** Register a trigger element */
+    registerTrigger(value: string, element: HTMLElement): void;
+    /** Unregister a trigger element */
+    unregisterTrigger(value: string): void;
+    /** Get all registered triggers */
+    getTriggers(): Map<string, HTMLElement>;
+    /** Focus next trigger (for keyboard navigation) */
+    focusNextTrigger(): void;
+    /** Focus previous trigger (for keyboard navigation) */
+    focusPreviousTrigger(): void;
+    /** Focus first trigger */
+    focusFirstTrigger(): void;
+    /** Focus last trigger */
+    focusLastTrigger(): void;
+}
+interface TabsListBase {
+    /** Reference to the native element */
+    elementRef: {
+        nativeElement: HTMLElement;
+    };
+    /** Get the currently active trigger element */
+    getActiveTrigger(): HTMLElement | null;
+}
+/**
+ * Injection token for tabs group
+ * Allows child components to access parent tabs state
+ */
+declare const TABS_GROUP: InjectionToken<TabsGroupBase>;
+/**
+ * Injection token for tabs list
+ * Allows indicator to access trigger positions
+ */
+declare const TABS_LIST: InjectionToken<TabsListBase>;
+
+/**
+ * Tabs container component
+ *
+ * Manages tab selection state, keyboard navigation, and provides context
+ * to child components (TabsList, TabsTrigger, TabsPanel).
+ *
+ * @example
+ * ```html
+ * <luma-tabs [lmValue]="selectedTab()" (lmValueChange)="onSelect($event)">
+ *   <div lumaTabsList>
+ *     <button lumaTabsTrigger="tab-1">Tab 1</button>
+ *     <button lumaTabsTrigger="tab-2">Tab 2</button>
+ *   </div>
+ *   <div lumaTabsPanel="tab-1">Content 1</div>
+ *   <div lumaTabsPanel="tab-2">Content 2</div>
+ * </luma-tabs>
+ * ```
+ */
+declare class LmTabsComponent implements TabsGroupBase {
+    /** Controlled value - currently selected tab */
+    lmValue: _angular_core.InputSignal<string | null>;
+    /** Default value for uncontrolled mode */
+    lmDefaultValue: _angular_core.InputSignal<string>;
+    /** Visual style: underline, background, or pill */
+    lmVariant: _angular_core.InputSignal<TabsStyle>;
+    /** Whether to lazy load panel content */
+    lmLazy: _angular_core.InputSignal<boolean>;
+    /** Emits when selected tab changes */
+    lmValueChange: _angular_core.OutputEmitterRef<string>;
+    /** Internal state for the selected value */
+    value: _angular_core.WritableSignal<string | null>;
+    /** Map of registered triggers for keyboard navigation */
+    private triggers;
+    /** Ordered list of trigger values for navigation */
+    private triggerOrder;
+    constructor();
+    /**
+     * Select a tab by value
+     */
+    select(tabValue: string): void;
+    /**
+     * Register a trigger element for keyboard navigation
+     */
+    registerTrigger(tabValue: string, element: HTMLElement): void;
+    /**
+     * Unregister a trigger element
+     */
+    unregisterTrigger(tabValue: string): void;
+    /**
+     * Get all registered triggers
+     */
+    getTriggers(): Map<string, HTMLElement>;
+    /**
+     * Focus next trigger in the list
+     */
+    focusNextTrigger(): void;
+    /**
+     * Focus previous trigger in the list
+     */
+    focusPreviousTrigger(): void;
+    /**
+     * Focus first trigger
+     */
+    focusFirstTrigger(): void;
+    /**
+     * Focus last trigger
+     */
+    focusLastTrigger(): void;
+    private getCurrentTriggerIndex;
+    private focusTriggerAtIndex;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmTabsComponent, "luma-tabs", never, { "lmValue": { "alias": "lmValue"; "required": false; "isSignal": true; }; "lmDefaultValue": { "alias": "lmDefaultValue"; "required": false; "isSignal": true; }; "lmVariant": { "alias": "lmVariant"; "required": false; "isSignal": true; }; "lmLazy": { "alias": "lmLazy"; "required": false; "isSignal": true; }; }, { "lmValueChange": "lmValueChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Tabs list directive
+ *
+ * Container for tab triggers with role="tablist".
+ * Provides context for the indicator component.
+ *
+ * @example
+ * ```html
+ * <div lumaTabsList>
+ *   <button lumaTabsTrigger="tab-1">Tab 1</button>
+ *   <button lumaTabsTrigger="tab-2">Tab 2</button>
+ * </div>
+ * ```
+ */
+declare class LmTabsListDirective implements TabsListBase {
+    readonly elementRef: ElementRef<any>;
+    protected readonly tabsGroup: _lumaui_angular.TabsGroupBase;
+    /** Whether horizontal scrolling is enabled */
+    lmScrollable: boolean;
+    classes: _angular_core.Signal<string>;
+    /**
+     * Get the currently active trigger element
+     */
+    getActiveTrigger(): HTMLElement | null;
+    /**
+     * Handle mouse wheel for horizontal scroll
+     */
+    onWheel(event: WheelEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTabsListDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmTabsListDirective, "[lumaTabsList]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Tabs trigger directive
+ *
+ * Individual tab button with role="tab" and keyboard navigation support.
+ * Follows WAI-ARIA tabs pattern with roving tabindex.
+ *
+ * @example
+ * ```html
+ * <button lumaTabsTrigger="tab-1">Tab 1</button>
+ * ```
+ */
+declare class LmTabsTriggerDirective implements OnInit, OnDestroy {
+    private readonly el;
+    private readonly tabsGroup;
+    /** Tab value identifier */
+    lumaTabsTrigger: _angular_core.InputSignal<string>;
+    /** Whether this trigger is disabled */
+    lmDisabled: _angular_core.InputSignal<boolean>;
+    /** Computed: whether this tab is selected */
+    isSelected: _angular_core.Signal<boolean>;
+    /** Computed: ID for the trigger element */
+    triggerId: _angular_core.Signal<string>;
+    /** Computed: ID for the corresponding panel */
+    panelId: _angular_core.Signal<string>;
+    /** Computed: CSS classes from CVA */
+    classes: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onClick(): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTabsTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmTabsTriggerDirective, "[lumaTabsTrigger]", never, { "lumaTabsTrigger": { "alias": "lumaTabsTrigger"; "required": true; "isSignal": true; }; "lmDisabled": { "alias": "lmDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Tabs panel directive
+ *
+ * Content panel with role="tabpanel" and lazy loading support.
+ * When lazy loading is enabled, content is only rendered after
+ * the tab has been selected at least once, then cached.
+ *
+ * @example
+ * ```html
+ * <div lumaTabsPanel="tab-1">Content 1</div>
+ *
+ * <!-- With lazy loading (default when lmLazy=true on parent) -->
+ * <ng-template lumaTabsPanel="tab-1">
+ *   <expensive-component />
+ * </ng-template>
+ * ```
+ */
+declare class LmTabsPanelDirective {
+    private readonly tabsGroup;
+    private readonly templateRef;
+    private readonly viewContainer;
+    /** Panel value identifier */
+    lumaTabsPanel: _angular_core.InputSignal<string>;
+    /** Track if panel has ever been selected (for lazy loading cache) */
+    private hasBeenSelected;
+    /** Computed: whether this panel is currently selected */
+    isSelected: _angular_core.Signal<boolean>;
+    /** Computed: whether this panel should be visible/rendered */
+    isVisible: _angular_core.Signal<boolean>;
+    /** Computed: whether content should be rendered (for lazy loading) */
+    shouldRender: _angular_core.Signal<boolean>;
+    /** Computed: ID for the panel element */
+    panelId: _angular_core.Signal<string>;
+    /** Computed: ID for the corresponding trigger */
+    triggerId: _angular_core.Signal<string>;
+    /** Computed: CSS classes from CVA */
+    classes: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTabsPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmTabsPanelDirective, "[lumaTabsPanel]", never, { "lumaTabsPanel": { "alias": "lumaTabsPanel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Tabs indicator component
+ *
+ * Animated indicator that slides between tabs for the underline style.
+ * Uses CSS transform for smooth, GPU-accelerated animation.
+ *
+ * @example
+ * ```html
+ * <div lumaTabsList>
+ *   <button lumaTabsTrigger="tab-1">Tab 1</button>
+ *   <button lumaTabsTrigger="tab-2">Tab 2</button>
+ *   <luma-tabs-indicator />
+ * </div>
+ * ```
+ */
+declare class LmTabsIndicatorComponent implements AfterViewInit, OnDestroy {
+    private readonly platformId;
+    private readonly tabsGroup;
+    private readonly tabsList;
+    /** Indicator width in pixels */
+    indicatorWidth: _angular_core.WritableSignal<number>;
+    /** Indicator X or Y position */
+    private indicatorPosition;
+    /** Resize observer for recalculating position */
+    private resizeObserver;
+    /** Computed: CSS classes from CVA */
+    classes: _angular_core.Signal<string>;
+    /** Computed: CSS transform for positioning */
+    indicatorTransform: _angular_core.Signal<string>;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private updateIndicatorPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTabsIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmTabsIndicatorComponent, "luma-tabs-indicator", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Modal size variants
+ */
+type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+/**
+ * Interface for modal context that child components/directives can access
+ */
+interface ModalContext {
+    /** Whether the modal is currently open */
+    isOpen: Signal<boolean>;
+    /** Open the modal */
+    open: () => void;
+    /** Close the modal */
+    close: () => void;
+    /** Modal size variant */
+    size: Signal<ModalSize>;
+    /** Whether to close on overlay click */
+    closeOnOverlay: Signal<boolean>;
+    /** Whether to close on Escape key */
+    closeOnEscape: Signal<boolean>;
+    /** Unique ID for accessibility */
+    modalId: string;
+}
+/**
+ * Injection token for modal context
+ * Allows child components to access parent modal state
+ */
+declare const MODAL_CONTEXT: InjectionToken<ModalContext>;
+
+/**
+ * Modal container component
+ *
+ * Manages modal open/close state, escape key handling, and provides context
+ * to child components (ModalOverlay, ModalContainer, etc.).
+ *
+ * Supports both controlled and uncontrolled modes:
+ * - Controlled: Use [lmOpen] and (lmOpenChange)
+ * - Uncontrolled: Use [lmDefaultOpen] and access via template reference
+ *
+ * @example
+ * ```html
+ * <!-- Controlled mode -->
+ * <luma-modal [lmOpen]="isOpen()" (lmOpenChange)="isOpen.set($event)">
+ *   <luma-modal-overlay>
+ *     <luma-modal-container>
+ *       <div lumaModalHeader>
+ *         <h2 lumaModalTitle>Title</h2>
+ *         <luma-modal-close />
+ *       </div>
+ *       <div lumaModalContent>Content</div>
+ *       <div lumaModalFooter>
+ *         <button lumaButton (click)="isOpen.set(false)">Close</button>
+ *       </div>
+ *     </luma-modal-container>
+ *   </luma-modal-overlay>
+ * </luma-modal>
+ *
+ * <!-- Uncontrolled mode -->
+ * <luma-modal #modal [lmDefaultOpen]="false">
+ *   ...
+ * </luma-modal>
+ * <button (click)="modal.open()">Open</button>
+ * ```
+ */
+declare class LmModalComponent implements ModalContext, OnDestroy {
+    private readonly platformId;
+    private readonly document;
+    /** Controlled open state (null = uncontrolled mode) */
+    lmOpen: _angular_core.InputSignal<boolean | null>;
+    /** Default open state for uncontrolled mode */
+    lmDefaultOpen: _angular_core.InputSignal<boolean>;
+    /** Size variant */
+    lmSize: _angular_core.InputSignal<ModalSize>;
+    /** Close when clicking the overlay */
+    lmCloseOnOverlay: _angular_core.InputSignal<boolean>;
+    /** Close when pressing Escape key */
+    lmCloseOnEscape: _angular_core.InputSignal<boolean>;
+    /** Emits when open state changes */
+    lmOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    /** Internal open state for uncontrolled mode */
+    private internalOpen;
+    /** Unique modal ID for accessibility */
+    readonly modalId: string;
+    /** Previously focused element for focus restoration */
+    private previouslyFocused;
+    /** Escape key handler */
+    private escapeHandler;
+    /** Computed: current open state (controlled or uncontrolled) */
+    isOpen: _angular_core.Signal<boolean>;
+    /** Computed: size signal for context */
+    size: _angular_core.Signal<ModalSize>;
+    /** Computed: closeOnOverlay signal for context */
+    closeOnOverlay: _angular_core.Signal<boolean>;
+    /** Computed: closeOnEscape signal for context */
+    closeOnEscape: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Open the modal
+     */
+    open(): void;
+    /**
+     * Close the modal
+     */
+    close(): void;
+    private storeFocus;
+    private restoreFocus;
+    private lockBodyScroll;
+    private unlockBodyScroll;
+    private registerEscapeHandler;
+    private unregisterEscapeHandler;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmModalComponent, "luma-modal", never, { "lmOpen": { "alias": "lmOpen"; "required": false; "isSignal": true; }; "lmDefaultOpen": { "alias": "lmDefaultOpen"; "required": false; "isSignal": true; }; "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; "lmCloseOnOverlay": { "alias": "lmCloseOnOverlay"; "required": false; "isSignal": true; }; "lmCloseOnEscape": { "alias": "lmCloseOnEscape"; "required": false; "isSignal": true; }; }, { "lmOpenChange": "lmOpenChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Modal overlay component (backdrop)
+ *
+ * Provides a semi-transparent backdrop behind the modal.
+ * Handles click-to-close when enabled on the parent modal.
+ *
+ * @example
+ * ```html
+ * <luma-modal [lmOpen]="isOpen()">
+ *   <luma-modal-overlay>
+ *     <luma-modal-container>...</luma-modal-container>
+ *   </luma-modal-overlay>
+ * </luma-modal>
+ * ```
+ */
+declare class LmModalOverlayComponent {
+    private readonly modal;
+    /** Computed classes from CVA */
+    classes: _angular_core.Signal<string>;
+    /**
+     * Handle click on overlay (not on children)
+     */
+    onOverlayClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmModalOverlayComponent, "luma-modal-overlay", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Modal container component (dialog box)
+ *
+ * Contains the modal content and handles:
+ * - ARIA attributes for accessibility
+ * - Focus trap when modal is open
+ * - Size variants
+ *
+ * @example
+ * ```html
+ * <luma-modal-overlay>
+ *   <luma-modal-container>
+ *     <div lumaModalHeader>...</div>
+ *     <div lumaModalContent>...</div>
+ *     <div lumaModalFooter>...</div>
+ *   </luma-modal-container>
+ * </luma-modal-overlay>
+ * ```
+ */
+declare class LmModalContainerComponent implements AfterViewInit, OnDestroy {
+    readonly modal: _lumaui_angular.ModalContext;
+    private readonly elementRef;
+    private readonly platformId;
+    /** Focus trap keydown handler */
+    private focusTrapHandler;
+    /** ID for aria-labelledby */
+    titleId: _angular_core.Signal<string>;
+    /** Computed classes from CVA */
+    classes: _angular_core.Signal<string>;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Get all focusable elements within the modal
+     */
+    private getFocusableElements;
+    /**
+     * Focus the first focusable element
+     */
+    private focusFirstElement;
+    /**
+     * Setup focus trap to keep focus within modal
+     */
+    private setupFocusTrap;
+    /**
+     * Remove focus trap handler
+     */
+    private removeFocusTrap;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmModalContainerComponent, "luma-modal-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Modal header directive
+ *
+ * Container for modal title and close button.
+ * Provides consistent padding and border styling.
+ *
+ * @example
+ * ```html
+ * <div lumaModalHeader>
+ *   <h2 lumaModalTitle>Modal Title</h2>
+ *   <luma-modal-close />
+ * </div>
+ * ```
+ */
+declare class LmModalHeaderDirective {
+    /** Computed classes from CVA */
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmModalHeaderDirective, "[lumaModalHeader]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Modal title directive
+ *
+ * Provides consistent typography for modal titles.
+ * Automatically links to aria-labelledby on the modal container.
+ *
+ * @example
+ * ```html
+ * <h2 lumaModalTitle>Modal Title</h2>
+ * <h2 lumaModalTitle lmSize="lg">Large Title</h2>
+ * ```
+ */
+declare class LmModalTitleDirective {
+    private readonly modal;
+    /** Title size variant */
+    lmSize: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    /** ID for aria-labelledby connection */
+    titleId: _angular_core.Signal<string>;
+    /** Computed classes from CVA */
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmModalTitleDirective, "[lumaModalTitle]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Modal content directive
+ *
+ * Container for the main modal content.
+ * Supports scrolling when content exceeds available space.
+ *
+ * @example
+ * ```html
+ * <div lumaModalContent>
+ *   Content that doesn't scroll
+ * </div>
+ *
+ * <div lumaModalContent [lmScrollable]="true">
+ *   Long content that scrolls...
+ * </div>
+ * ```
+ */
+declare class LmModalContentDirective {
+    /** Enable scroll when content overflows */
+    lmScrollable: _angular_core.InputSignal<boolean>;
+    /** Computed classes from CVA */
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmModalContentDirective, "[lumaModalContent]", never, { "lmScrollable": { "alias": "lmScrollable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Modal footer directive
+ *
+ * Container for modal actions (buttons, etc.).
+ * Provides consistent padding and flexible alignment.
+ *
+ * @example
+ * ```html
+ * <div lumaModalFooter>
+ *   <button lumaButton lmVariant="ghost">Cancel</button>
+ *   <button lumaButton>Confirm</button>
+ * </div>
+ *
+ * <div lumaModalFooter lmAlign="between">
+ *   <span>Left content</span>
+ *   <button lumaButton>Action</button>
+ * </div>
+ * ```
+ */
+declare class LmModalFooterDirective {
+    /** Alignment of footer content */
+    lmAlign: _angular_core.InputSignal<"start" | "center" | "end" | "between">;
+    /** Computed classes from CVA */
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalFooterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmModalFooterDirective, "[lumaModalFooter]", never, { "lmAlign": { "alias": "lmAlign"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Modal close button component
+ *
+ * Provides a styled close button with an X icon.
+ * Can be customized with different content via ng-content.
+ *
+ * @example
+ * ```html
+ * <!-- Default X icon -->
+ * <luma-modal-close />
+ *
+ * <!-- Custom aria label -->
+ * <luma-modal-close lmAriaLabel="Fechar modal" />
+ *
+ * <!-- Custom icon -->
+ * <luma-modal-close>
+ *   <svg>...</svg>
+ * </luma-modal-close>
+ * ```
+ */
+declare class LmModalCloseComponent {
+    readonly modal: _lumaui_angular.ModalContext;
+    /** Accessible label for the close button */
+    lmAriaLabel: _angular_core.InputSignal<string>;
+    /** Computed aria label */
+    ariaLabel: _angular_core.Signal<string>;
+    /** Computed classes from CVA */
+    classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalCloseComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmModalCloseComponent, "luma-modal-close", never, { "lmAriaLabel": { "alias": "lmAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Toast variant types
+ */
+type ToastVariant = 'info' | 'success' | 'warning' | 'error';
+/**
+ * Toast position options
+ */
+type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+/**
+ * Toast configuration options passed to ToastService.show()
+ */
+interface ToastOptions {
+    /** Toast message (required) */
+    message: string;
+    /** Optional title */
+    title?: string;
+    /** Visual variant */
+    variant?: ToastVariant;
+    /** Screen position */
+    position?: ToastPosition;
+    /** Auto-close duration in milliseconds (0 = no auto-close) */
+    duration?: number;
+    /** Show close button */
+    dismissible?: boolean;
+    /** Pause timer on hover */
+    pauseOnHover?: boolean;
+    /** ARIA role override */
+    role?: 'alert' | 'status';
+}
+/**
+ * Internal toast representation with all required fields
+ */
+interface Toast extends Required<Omit<ToastOptions, 'role'>> {
+    /** Unique identifier */
+    id: string;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Whether toast is currently animating out */
+    isExiting: boolean;
+    /** ARIA role */
+    role: 'alert' | 'status';
+}
+/**
+ * Toast reference for programmatic control
+ */
+interface ToastRef {
+    /** Unique toast ID */
+    readonly id: string;
+    /** Dismiss this toast */
+    dismiss(): void;
+    /** Observable that emits when dismissed */
+    readonly afterDismissed: Observable<void>;
+}
+/**
+ * Global toast configuration
+ */
+interface ToastConfig {
+    /** Default position */
+    position: ToastPosition;
+    /** Default duration in milliseconds */
+    duration: number;
+    /** Default dismissible state */
+    dismissible: boolean;
+    /** Maximum visible toasts */
+    maxVisible: number;
+    /** Pause on hover by default */
+    pauseOnHover: boolean;
+}
+/**
+ * Default toast configuration
+ */
+declare const DEFAULT_TOAST_CONFIG: ToastConfig;
+/**
+ * Injection token for global toast configuration
+ */
+declare const TOAST_CONFIG: InjectionToken<ToastConfig>;
+/**
+ * Provider function for custom toast configuration
+ */
+declare function provideToastConfig(config: Partial<ToastConfig>): {
+    provide: InjectionToken<ToastConfig>;
+    useValue: {
+        position: ToastPosition;
+        duration: number;
+        dismissible: boolean;
+        maxVisible: number;
+        pauseOnHover: boolean;
+    };
+};
+
+/**
+ * ToastService
+ *
+ * Injectable service for showing toast notifications programmatically.
+ * Provides convenience methods for info, success, warning, and error toasts.
+ *
+ * @example
+ * ```typescript
+ * private toast = inject(ToastService);
+ *
+ * showSuccess() {
+ *   this.toast.success('Changes saved successfully!');
+ * }
+ *
+ * showError() {
+ *   this.toast.error('Failed to save', {
+ *     title: 'Error',
+ *     duration: 0
+ *   });
+ * }
+ * ```
+ */
+declare class LmToastService implements OnDestroy {
+    private readonly config;
+    private readonly appRef;
+    private readonly injector;
+    private readonly document;
+    private readonly platformId;
+    private readonly liveAnnouncer;
+    private readonly _toasts;
+    private containerRef;
+    private nextId;
+    private readonly toastRefs;
+    /** Observable list of current toasts */
+    readonly toasts: _angular_core.Signal<Toast[]>;
+    ngOnDestroy(): void;
+    /**
+     * Show a toast notification
+     * @param options - Toast configuration options
+     * @returns ToastRef for programmatic control
+     */
+    show(options: ToastOptions): ToastRef;
+    /**
+     * Show info toast
+     * @param message - Toast message
+     * @param options - Additional options
+     */
+    info(message: string, options?: Partial<ToastOptions>): ToastRef;
+    /**
+     * Show success toast
+     * @param message - Toast message
+     * @param options - Additional options
+     */
+    success(message: string, options?: Partial<ToastOptions>): ToastRef;
+    /**
+     * Show warning toast
+     * @param message - Toast message
+     * @param options - Additional options
+     */
+    warning(message: string, options?: Partial<ToastOptions>): ToastRef;
+    /**
+     * Show error toast
+     * @param message - Toast message
+     * @param options - Additional options
+     */
+    error(message: string, options?: Partial<ToastOptions>): ToastRef;
+    /**
+     * Dismiss a specific toast
+     * @param id - Toast ID to dismiss
+     */
+    dismiss(id: string): void;
+    /**
+     * Dismiss all toasts
+     */
+    dismissAll(): void;
+    /**
+     * Ensure toast container exists in DOM
+     */
+    private ensureContainer;
+    /**
+     * Remove container from DOM
+     */
+    private destroyContainer;
+    /**
+     * Announce toast to screen readers
+     */
+    private announceToast;
+    /**
+     * Get announcement prefix for variant
+     */
+    private getVariantPrefix;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LmToastService>;
+}
+
+/**
+ * ToastContainerComponent
+ *
+ * Fixed-position container that renders all active toasts.
+ * Supports all 6 positions simultaneously by grouping toasts by their position.
+ *
+ * @internal This component is created programmatically by ToastService
+ */
+declare class LmToastContainerComponent {
+    /** Toasts signal passed from ToastService */
+    _toasts: Signal<Toast[]>;
+    /** Dismiss callback passed from ToastService */
+    _onDismiss: (id: string) => void;
+    /** Group toasts by their position */
+    protected readonly toastsByPosition: Signal<Record<ToastPosition$1, Toast[]>>;
+    /** Get CSS classes for a specific position */
+    protected getPositionClasses(position: ToastPosition$1): string;
+    /** Handle dismiss event from toast item */
+    protected onDismiss(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmToastContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmToastContainerComponent, "luma-toast-container", never, {}, {}, never, never, true, never>;
 }
 
-declare class CardHeaderDirective {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardHeaderDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardHeaderDirective, "[lumaCardHeader]", never, {}, {}, never, never, true, never>;
+/**
+ * ToastItemComponent
+ *
+ * Individual toast notification with timer and icon.
+ *
+ * @internal Created by ToastContainerComponent
+ */
+declare class LmToastItemComponent implements OnInit, OnDestroy {
+    /** Toast data */
+    toast: _angular_core.InputSignal<Toast>;
+    /** Emits when toast should be dismissed */
+    dismiss: _angular_core.OutputEmitterRef<string>;
+    /** Timer subscription */
+    private timerSubscription;
+    /** Remaining time in ms */
+    private remainingTime;
+    /** Whether timer is paused */
+    private isPaused;
+    /** Animation state */
+    private animationState;
+    /** Item CSS classes */
+    protected readonly itemClasses: _angular_core.Signal<string>;
+    /** Icon CSS classes */
+    protected readonly iconClasses: _angular_core.Signal<string>;
+    /** Content CSS classes */
+    protected readonly contentClasses: _angular_core.Signal<string>;
+    /** Title CSS classes */
+    protected readonly titleClasses: _angular_core.Signal<string>;
+    /** Message CSS classes */
+    protected readonly messageClasses: _angular_core.Signal<string>;
+    /** Whether toast has interactive elements */
+    protected readonly hasInteractiveElements: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Start auto-close timer */
+    private startTimer;
+    /** Stop timer */
+    private stopTimer;
+    /** Dismiss this toast */
+    private dismissToast;
+    /** Handle close button click */
+    protected onClose(): void;
+    /** Pause timer on mouse enter */
+    protected onMouseEnter(): void;
+    /** Resume timer on mouse leave */
+    protected onMouseLeave(): void;
+    /** Pause timer on focus */
+    protected onFocus(): void;
+    /** Resume timer on blur */
+    protected onBlur(): void;
+    /** Dismiss on Escape key */
+    protected onEscapeKey(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmToastItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmToastItemComponent, "luma-toast-item", never, { "toast": { "alias": "toast"; "required": true; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, never, true, never>;
 }
 
-declare class CardContentDirective {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardContentDirective, "[lumaCardContent]", never, {}, {}, never, never, true, never>;
+/**
+ * ToastCloseComponent
+ *
+ * Close button for toast notifications.
+ * Styled according to the toast variant.
+ *
+ * @internal Used by ToastItemComponent
+ */
+declare class LmToastCloseComponent {
+    /** Toast variant for styling */
+    lmVariant: _angular_core.InputSignal<ToastVariant$1>;
+    /** CSS classes */
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmToastCloseComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmToastCloseComponent, "luma-toast-close", never, { "lmVariant": { "alias": "lmVariant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { ButtonDirective, CardComponent, CardContentDirective, CardDescriptionDirective, CardHeaderDirective, CardTitleDirective };
+export { ACCORDION_ITEM, DEFAULT_TOAST_CONFIG, LmAccordionContentDirective, LmAccordionGroupComponent, LmAccordionIconDirective, LmAccordionItemComponent, LmAccordionTitleDirective, LmAccordionTriggerDirective, LmBadgeDirective, LmButtonDirective, LmCardComponent, LmCardContentDirective, LmCardDescriptionDirective, LmCardHeaderDirective, LmCardTitleDirective, LmModalCloseComponent, LmModalComponent, LmModalContainerComponent, LmModalContentDirective, LmModalFooterDirective, LmModalHeaderDirective, LmModalOverlayComponent, LmModalTitleDirective, LmTabsComponent, LmTabsIndicatorComponent, LmTabsListDirective, LmTabsPanelDirective, LmTabsTriggerDirective, LmToastCloseComponent, LmToastContainerComponent, LmToastItemComponent, LmToastService, LmTooltipDirective, MODAL_CONTEXT, TABS_GROUP, TABS_LIST, TOAST_CONFIG, provideToastConfig };
+export type { AccordionItemBase, ModalContext, ModalSize, TabsGroupBase, TabsListBase, Toast, ToastConfig, ToastOptions, ToastPosition, ToastRef, ToastVariant };