@lumaui/angular 0.2.0 → 0.2.2

package/types/lumaui-angular.d.ts

@@ -1,27 +1,29 @@
 import * as _angular_core from '@angular/core';
 import { InjectionToken, Signal, OnDestroy, WritableSignal, ElementRef, OnInit, AfterViewInit } from '@angular/core';
-import { ButtonVariant, ButtonSize, CardVariant, CardTitleSize, CardDescriptionSize, AccordionItemVariant, AccordionTitleSize, TooltipPosition, TabsStyle } from '@lumaui/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 BadgeDirective {
+declare class LmBadgeDirective {
     classes: _angular_core.Signal<string>;
     get hostClasses(): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BadgeDirective, "[lumaBadge]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmBadgeDirective, "[lumaBadge]", never, {}, {}, never, never, true, never>;
 }
 
-declare class CardComponent {
+declare class LmCardComponent {
     /**
      * Card visual style variant
      * - default: Gradient border wrapper style (default)
@@ -32,32 +34,32 @@ 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 CardHeaderDirective {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardHeaderDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardHeaderDirective, "[lumaCardHeader]", never, {}, {}, 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 CardContentDirective {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardContentDirective, "[lumaCardContent]", 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>;
 }
 
 /**
@@ -86,7 +88,7 @@ declare class CardContentDirective {
  * </luma-accordion-group>
  * ```
  */
-declare class AccordionGroupComponent {
+declare class LmAccordionGroupComponent {
     /**
      * Controlled value for which items are open
      * - null: uncontrolled mode (each item manages its own state)
@@ -109,8 +111,8 @@ declare class AccordionGroupComponent {
      * Called by child AccordionItemComponent when toggled
      */
     toggleItem(itemId: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionGroupComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionGroupComponent, "luma-accordion-group", never, { "lmValue": { "alias": "lmValue"; "required": false; "isSignal": true; }; "lmSingle": { "alias": "lmSingle"; "required": false; "isSignal": true; }; }, { "lmValueChange": "lmValueChange"; }, never, ["*"], true, never>;
+    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>;
 }
 
 /**
@@ -154,7 +156,7 @@ declare const ACCORDION_ITEM: InjectionToken<AccordionItemBase>;
  * </luma-accordion-item>
  * ```
  */
-declare class AccordionItemComponent implements AccordionItemBase {
+declare class LmAccordionItemComponent implements AccordionItemBase {
     private group;
     private el;
     private renderer;
@@ -196,8 +198,8 @@ declare class AccordionItemComponent implements AccordionItemBase {
      * Toggle the accordion open/closed state
      */
     toggle(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItemComponent, "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>;
+    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>;
 }
 
 /**
@@ -231,7 +233,7 @@ declare class AccordionItemComponent implements AccordionItemBase {
  * </div>
  * ```
  */
-declare class AccordionTriggerDirective {
+declare class LmAccordionTriggerDirective {
     protected item: _lumaui_angular.AccordionItemBase;
     private id;
     triggerId: string;
@@ -239,8 +241,8 @@ declare class AccordionTriggerDirective {
     classes: _angular_core.Signal<string>;
     onClick(event: Event): void;
     onKeydown(event: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionTriggerDirective, "div[lumaAccordionTrigger]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmAccordionTriggerDirective, "div[lumaAccordionTrigger]", never, {}, {}, never, never, true, never>;
 }
 
 /**
@@ -259,7 +261,7 @@ declare class AccordionTriggerDirective {
  * <span lumaAccordionTitle lmSize="lg">Large Title</span>
  * ```
  */
-declare class AccordionTitleDirective {
+declare class LmAccordionTitleDirective {
     /**
      * Size variant for the title
      * - sm: Small text for compact UIs
@@ -268,8 +270,8 @@ declare class AccordionTitleDirective {
      */
     lmSize: _angular_core.InputSignal<AccordionTitleSize>;
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTitleDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionTitleDirective, "[lumaAccordionTitle]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    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>;
 }
 
 /**
@@ -302,11 +304,11 @@ declare class AccordionTitleDirective {
  * </span>
  * ```
  */
-declare class AccordionIconDirective {
+declare class LmAccordionIconDirective {
     protected item: _lumaui_angular.AccordionItemBase;
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionIconDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionIconDirective, "span[lumaAccordionIcon], div[lumaAccordionIcon]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmAccordionIconDirective, "span[lumaAccordionIcon], div[lumaAccordionIcon]", never, {}, {}, never, never, true, never>;
 }
 
 /**
@@ -322,18 +324,18 @@ declare class AccordionIconDirective {
  * </div>
  * ```
  */
-declare class AccordionContentDirective {
+declare class LmAccordionContentDirective {
     protected item: _lumaui_angular.AccordionItemBase;
-    protected trigger: AccordionTriggerDirective | null;
+    protected trigger: LmAccordionTriggerDirective | null;
     private id;
     contentId: string;
     triggerId: _angular_core.Signal<string | null>;
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionContentDirective, "[lumaAccordionContent]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmAccordionContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmAccordionContentDirective, "[lumaAccordionContent]", never, {}, {}, never, never, true, never>;
 }
 
-declare class TooltipDirective implements OnDestroy {
+declare class LmTooltipDirective implements OnDestroy {
     private el;
     private renderer;
     private platformId;
@@ -366,15 +368,15 @@ declare class TooltipDirective implements OnDestroy {
     hide(): void;
     toggle(): void;
     ngOnDestroy(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[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>;
+    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) */
-    lmStyle: Signal<TabsStyle>;
+    lmVariant: Signal<TabsStyle>;
     /** Whether to lazy load panel content */
     lmLazy: Signal<boolean>;
     /** Select a tab by value */
@@ -431,13 +433,13 @@ declare const TABS_LIST: InjectionToken<TabsListBase>;
  * </luma-tabs>
  * ```
  */
-declare class TabsComponent implements TabsGroupBase {
+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 */
-    lmStyle: _angular_core.InputSignal<TabsStyle>;
+    lmVariant: _angular_core.InputSignal<TabsStyle>;
     /** Whether to lazy load panel content */
     lmLazy: _angular_core.InputSignal<boolean>;
     /** Emits when selected tab changes */
@@ -483,8 +485,8 @@ declare class TabsComponent implements TabsGroupBase {
     focusLastTrigger(): void;
     private getCurrentTriggerIndex;
     private focusTriggerAtIndex;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "luma-tabs", never, { "lmValue": { "alias": "lmValue"; "required": false; "isSignal": true; }; "lmDefaultValue": { "alias": "lmDefaultValue"; "required": false; "isSignal": true; }; "lmStyle": { "alias": "lmStyle"; "required": false; "isSignal": true; }; "lmLazy": { "alias": "lmLazy"; "required": false; "isSignal": true; }; }, { "lmValueChange": "lmValueChange"; }, never, ["*"], true, never>;
+    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>;
 }
 
 /**
@@ -501,7 +503,7 @@ declare class TabsComponent implements TabsGroupBase {
  * </div>
  * ```
  */
-declare class TabsListDirective implements TabsListBase {
+declare class LmTabsListDirective implements TabsListBase {
     readonly elementRef: ElementRef<any>;
     protected readonly tabsGroup: _lumaui_angular.TabsGroupBase;
     /** Whether horizontal scrolling is enabled */
@@ -515,8 +517,8 @@ declare class TabsListDirective implements TabsListBase {
      * Handle mouse wheel for horizontal scroll
      */
     onWheel(event: WheelEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsListDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabsListDirective, "[lumaTabsList]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTabsListDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmTabsListDirective, "[lumaTabsList]", never, {}, {}, never, never, true, never>;
 }
 
 /**
@@ -530,7 +532,7 @@ declare class TabsListDirective implements TabsListBase {
  * <button lumaTabsTrigger="tab-1">Tab 1</button>
  * ```
  */
-declare class TabsTriggerDirective implements OnInit, OnDestroy {
+declare class LmTabsTriggerDirective implements OnInit, OnDestroy {
     private readonly el;
     private readonly tabsGroup;
     /** Tab value identifier */
@@ -549,8 +551,8 @@ declare class TabsTriggerDirective implements OnInit, OnDestroy {
     ngOnDestroy(): void;
     onClick(): void;
     onKeydown(event: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabsTriggerDirective, "[lumaTabsTrigger]", never, { "lumaTabsTrigger": { "alias": "lumaTabsTrigger"; "required": true; "isSignal": true; }; "lmDisabled": { "alias": "lmDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    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>;
 }
 
 /**
@@ -570,7 +572,7 @@ declare class TabsTriggerDirective implements OnInit, OnDestroy {
  * </ng-template>
  * ```
  */
-declare class TabsPanelDirective {
+declare class LmTabsPanelDirective {
     private readonly tabsGroup;
     private readonly templateRef;
     private readonly viewContainer;
@@ -591,8 +593,8 @@ declare class TabsPanelDirective {
     /** Computed: CSS classes from CVA */
     classes: _angular_core.Signal<string>;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsPanelDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabsPanelDirective, "[lumaTabsPanel]", never, { "lumaTabsPanel": { "alias": "lumaTabsPanel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    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>;
 }
 
 /**
@@ -610,7 +612,7 @@ declare class TabsPanelDirective {
  * </div>
  * ```
  */
-declare class TabsIndicatorComponent implements AfterViewInit, OnDestroy {
+declare class LmTabsIndicatorComponent implements AfterViewInit, OnDestroy {
     private readonly platformId;
     private readonly tabsGroup;
     private readonly tabsList;
@@ -628,8 +630,8 @@ declare class TabsIndicatorComponent implements AfterViewInit, OnDestroy {
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     private updateIndicatorPosition;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsIndicatorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsIndicatorComponent, "luma-tabs-indicator", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmTabsIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmTabsIndicatorComponent, "luma-tabs-indicator", never, {}, {}, never, never, true, never>;
 }
 
 /**
@@ -696,7 +698,7 @@ declare const MODAL_CONTEXT: InjectionToken<ModalContext>;
  * <button (click)="modal.open()">Open</button>
  * ```
  */
-declare class ModalComponent implements ModalContext, OnDestroy {
+declare class LmModalComponent implements ModalContext, OnDestroy {
     private readonly platformId;
     private readonly document;
     /** Controlled open state (null = uncontrolled mode) */
@@ -743,8 +745,8 @@ declare class ModalComponent implements ModalContext, OnDestroy {
     private unlockBodyScroll;
     private registerEscapeHandler;
     private unregisterEscapeHandler;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "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>;
+    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>;
 }
 
 /**
@@ -762,7 +764,7 @@ declare class ModalComponent implements ModalContext, OnDestroy {
  * </luma-modal>
  * ```
  */
-declare class ModalOverlayComponent {
+declare class LmModalOverlayComponent {
     private readonly modal;
     /** Computed classes from CVA */
     classes: _angular_core.Signal<string>;
@@ -770,8 +772,8 @@ declare class ModalOverlayComponent {
      * Handle click on overlay (not on children)
      */
     onOverlayClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalOverlayComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalOverlayComponent, "luma-modal-overlay", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmModalOverlayComponent, "luma-modal-overlay", never, {}, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -793,7 +795,7 @@ declare class ModalOverlayComponent {
  * </luma-modal-overlay>
  * ```
  */
-declare class ModalContainerComponent implements AfterViewInit, OnDestroy {
+declare class LmModalContainerComponent implements AfterViewInit, OnDestroy {
     readonly modal: _lumaui_angular.ModalContext;
     private readonly elementRef;
     private readonly platformId;
@@ -822,8 +824,8 @@ declare class ModalContainerComponent implements AfterViewInit, OnDestroy {
      * Remove focus trap handler
      */
     private removeFocusTrap;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalContainerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalContainerComponent, "luma-modal-container", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LmModalContainerComponent, "luma-modal-container", never, {}, {}, never, ["*"], true, never>;
 }
 
 /**
@@ -840,11 +842,11 @@ declare class ModalContainerComponent implements AfterViewInit, OnDestroy {
  * </div>
  * ```
  */
-declare class ModalHeaderDirective {
+declare class LmModalHeaderDirective {
     /** Computed classes from CVA */
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalHeaderDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalHeaderDirective, "[lumaModalHeader]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LmModalHeaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LmModalHeaderDirective, "[lumaModalHeader]", never, {}, {}, never, never, true, never>;
 }
 
 /**
@@ -859,7 +861,7 @@ declare class ModalHeaderDirective {
  * <h2 lumaModalTitle lmSize="lg">Large Title</h2>
  * ```
  */
-declare class ModalTitleDirective {
+declare class LmModalTitleDirective {
     private readonly modal;
     /** Title size variant */
     lmSize: _angular_core.InputSignal<"sm" | "md" | "lg">;
@@ -867,8 +869,8 @@ declare class ModalTitleDirective {
     titleId: _angular_core.Signal<string>;
     /** Computed classes from CVA */
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalTitleDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalTitleDirective, "[lumaModalTitle]", never, { "lmSize": { "alias": "lmSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    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>;
 }
 
 /**
@@ -888,13 +890,13 @@ declare class ModalTitleDirective {
  * </div>
  * ```
  */
-declare class ModalContentDirective {
+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<ModalContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalContentDirective, "[lumaModalContent]", never, { "lmScrollable": { "alias": "lmScrollable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    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>;
 }
 
 /**
@@ -916,13 +918,13 @@ declare class ModalContentDirective {
  * </div>
  * ```
  */
-declare class ModalFooterDirective {
+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<ModalFooterDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalFooterDirective, "[lumaModalFooter]", never, { "lmAlign": { "alias": "lmAlign"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    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>;
 }
 
 /**
@@ -945,7 +947,7 @@ declare class ModalFooterDirective {
  * </luma-modal-close>
  * ```
  */
-declare class ModalCloseComponent {
+declare class LmModalCloseComponent {
     readonly modal: _lumaui_angular.ModalContext;
     /** Accessible label for the close button */
     lmAriaLabel: _angular_core.InputSignal<string>;
@@ -953,9 +955,281 @@ declare class ModalCloseComponent {
     ariaLabel: _angular_core.Signal<string>;
     /** Computed classes from CVA */
     classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalCloseComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalCloseComponent, "luma-modal-close", never, { "lmAriaLabel": { "alias": "lmAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    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>;
 }
 
-export { ACCORDION_ITEM, AccordionContentDirective, AccordionGroupComponent, AccordionIconDirective, AccordionItemComponent, AccordionTitleDirective, AccordionTriggerDirective, BadgeDirective, ButtonDirective, CardComponent, CardContentDirective, CardDescriptionDirective, CardHeaderDirective, CardTitleDirective, MODAL_CONTEXT, ModalCloseComponent, ModalComponent, ModalContainerComponent, ModalContentDirective, ModalFooterDirective, ModalHeaderDirective, ModalOverlayComponent, ModalTitleDirective, TABS_GROUP, TABS_LIST, TabsComponent, TabsIndicatorComponent, TabsListDirective, TabsPanelDirective, TabsTriggerDirective, TooltipDirective };
-export type { AccordionItemBase, ModalContext, ModalSize, TabsGroupBase, TabsListBase };
+/**
+ * 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 _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;
+    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>;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * 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 { 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 };