@raqm/ui 0.0.0-stage → 0.1.0

package/types/raqm-ui-slider.d.ts

@@ -0,0 +1,129 @@
+import * as i0 from "@angular/core";
+/** Shift+Arrow and PageUp/PageDown step. */
+declare const LARGE_STEP = 10;
+declare function decimalPrecision(value: number): number;
+declare function clamp(value: number, lower: number, upper: number): number;
+declare function roundToStep(value: number, step: number, min: number): number;
+/**
+ * Pushes neighbours past the thumb at `index`; `initialValues`, captured at drag start, lets a
+ * pushed neighbour return to its start value.
+ */
+declare function pushThumbValues(values: readonly number[], index: number, nextValue: number, min: number, max: number, initialValues: readonly number[]): number[];
+interface SliderThumb {
+  readonly index: number;
+  readonly value: number;
+  readonly style: Readonly<Record<string, string>>;
+}
+/** Edge alignment: `half-thumb + (track - thumb) * ratio` keeps both end thumbs inside the control. */
+declare function offsetExpression(ratio: number): string;
+declare function spanExpression(span: number): string;
+/**
+ * Selects a value from within a range; each thumb is a real `<input type="range">`, so focus, ARIA
+ * and the form value stay native. Binding `value` makes it controlled, else `defaultValue` then `min`
+ * seed it. RTL mirrors Left/Right from the computed direction, so a CSS-only `dir` ancestor works.
+ */
+export declare class RaqmSlider {
+  readonly value: import("@angular/core").InputSignal<number | readonly number[] | null>;
+  readonly defaultValue: import("@angular/core").InputSignal<number | readonly number[] | null>;
+  readonly min: import("@angular/core").InputSignal<number>;
+  readonly max: import("@angular/core").InputSignal<number>;
+  readonly step: import("@angular/core").InputSignal<number>;
+  readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly name: import("@angular/core").InputSignal<string | null>;
+  readonly form: import("@angular/core").InputSignal<string | null>;
+  readonly id: import("@angular/core").InputSignal<string | null>;
+  readonly thumbLabels: import("@angular/core").InputSignal<readonly string[] | null>;
+  readonly valueChange: import("@angular/core").OutputEmitterRef<number | readonly number[]>;
+  private readonly host;
+  private readonly destroyRef;
+  private readonly uncontrolled;
+  private readonly activeIndex;
+  private readonly lastUsedIndex;
+  private readonly thumbElements;
+  private readonly thumbInputs;
+  protected readonly orientation: import("@angular/core").Signal<"horizontal" | "vertical">;
+  protected readonly values: import("@angular/core").Signal<readonly number[]>;
+  protected readonly thumbs: import("@angular/core").Signal<readonly SliderThumb[]>;
+  /** min → thumb for one value, first → last thumb for a range. */
+  protected readonly rangeStyle: import("@angular/core").Signal<Readonly<Record<string, string>>>;
+  private readonly pointer;
+  private readonly keyboard;
+  constructor();
+  protected inputId(index: number): string | null;
+  protected thumbLabel(index: number): string | null;
+  protected onFocus(index: number): void;
+  protected onBlur(): void;
+  /** Accepts a change made through the native input (assistive technology). */
+  protected onInput(event: Event, index: number): void;
+  protected onKeydown(event: KeyboardEvent, index: number): void;
+  protected onPointerDown(event: PointerEvent): void;
+  private round;
+  /** The public step, never zero, which would make every ratio meaningless. */
+  private stepSize;
+  private ratio;
+  private applyClamped;
+  private setValues;
+  private direction;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmSlider, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmSlider, "raqm-slider", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultValue": {
+      "alias": "defaultValue";
+      "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;
+    };
+    "vertical": {
+      "alias": "vertical";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "form": {
+      "alias": "form";
+      "required": false;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": false;
+      "isSignal": true;
+    };
+    "thumbLabels": {
+      "alias": "thumbLabels";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "valueChange": "valueChange";
+  }, never, never, true, never>;
+}
+export {};

package/types/raqm-ui-spinner.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from "@angular/core";
+/** Raqm spinner — rotates projected content or its default glyph; `decorative`, `start` and `end` are boolean attributes. */
+export declare class RaqmSpinner {
+  readonly decorative: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly label: import("@angular/core").InputSignal<string | null>;
+  protected readonly announces: import("@angular/core").Signal<boolean>;
+  readonly start: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly end: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmSpinner, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmSpinner, "raqm-spinner", never, {
+    "decorative": {
+      "alias": "decorative";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "start": {
+      "alias": "start";
+      "required": false;
+      "isSignal": true;
+    };
+    "end": {
+      "alias": "end";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}

package/types/raqm-ui-switch.d.ts

@@ -0,0 +1,32 @@
+import { ControlValueAccessor } from "@angular/forms";
+import * as i0 from "@angular/core";
+/**
+ * Attaches the `raqm-switch` class to a native `<input>` and exposes it as `role="switch"`.
+ *
+ * @remarks
+ * `type="checkbox"` is set when absent, so Angular's checkbox validator does not match: with Forms,
+ * use `Validators.requiredTrue` for a required switch.
+ */
+export declare class RaqmSwitch implements ControlValueAccessor {
+  private readonly host;
+  private onChange;
+  private onTouched;
+  private disabledStateFired;
+  /** `false` is the default track, `true` the small one. */
+  readonly small: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  writeValue(value: boolean | null | undefined): void;
+  registerOnChange(fn: (value: boolean) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(isDisabled: boolean): void;
+  protected handleChange(event: Event): void;
+  protected handleBlur(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmSwitch, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmSwitch, "input[raqm-switch]", never, {
+    "small": {
+      "alias": "small";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/raqm-ui-table.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from "@angular/core";
+/** Native `<table>` host; no data engine, and selection/expansion are CSS-only row hooks. */
+export declare class RaqmTableDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableDirective, "table[raqm-table]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmTableHeaderDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableHeaderDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableHeaderDirective, "thead[raqm-table-header]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmTableBodyDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableBodyDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableBodyDirective, "tbody[raqm-table-body]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmTableFooterDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableFooterDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableFooterDirective, "tfoot[raqm-table-footer]", never, {}, {}, never, never, true, never>;
+}
+/** CSS-only state hooks: `data-state="selected"` and a tint while a descendant reports `aria-expanded="true"`. */
+export declare class RaqmTableRowDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableRowDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableRowDirective, "tr[raqm-table-row]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmTableHeadDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableHeadDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableHeadDirective, "th[raqm-table-head]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmTableCellDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableCellDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableCellDirective, "td[raqm-table-cell]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmTableCaptionDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTableCaptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTableCaptionDirective, "caption[raqm-table-caption]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmTable: readonly [typeof RaqmTableDirective, typeof RaqmTableHeaderDirective, typeof RaqmTableBodyDirective, typeof RaqmTableFooterDirective, typeof RaqmTableRowDirective, typeof RaqmTableHeadDirective, typeof RaqmTableCellDirective, typeof RaqmTableCaptionDirective];

package/types/raqm-ui-tabs.d.ts

@@ -0,0 +1,154 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, OnInit, Signal } from "@angular/core";
+interface RaqmTabsTriggerRef {
+  /** Unique, non-empty trigger value used by the root's selection contract. */
+  readonly value: string;
+  /** Disabled triggers are skipped by the tab stop and arrows. */
+  readonly disabled: Signal<boolean>;
+  /** The trigger's native `<button>`, used only to move focus. */
+  readonly host: HTMLElement;
+}
+/** Root contract published under {@link RAQM_TABS}; the dedicated token avoids a runtime module cycle. */
+interface RaqmTabsContext {
+  /** Used for `aria-orientation` and arrow-key mapping. */
+  readonly vertical: Signal<boolean>;
+  readonly line: Signal<boolean>;
+  /** Bound model, else seed, else the first enabled trigger. */
+  readonly selectedValue: Signal<string | undefined>;
+  isSelected(value: string): boolean;
+  /** Missing, disabled or already-selected values are a no-op. */
+  select(value: string): void;
+  register(trigger: RaqmTabsTriggerRef): void;
+  /** Never changes the selection. */
+  unregister(trigger: RaqmTabsTriggerRef): void;
+  isTabStop(trigger: RaqmTabsTriggerRef): boolean;
+  /** Records the roving tab stop without changing the selection. */
+  noteFocus(trigger: RaqmTabsTriggerRef): void;
+  /** Moves focus without selecting (manual activation). */
+  moveFocus(trigger: RaqmTabsTriggerRef, event: KeyboardEvent): void;
+  triggerIdOf(trigger: RaqmTabsTriggerRef): string | null;
+  triggerIdFor(value: string): string | null;
+  panelIdFor(value: string): string | null;
+}
+/** Root token; injected optionally so a misplaced part renders and only logs a dev-mode error. */
+declare const RAQM_TABS: InjectionToken<RaqmTabsContext>;
+/** Tabs panel; `role="tabpanel"` paired by owned ids. Panels stay mounted, `hidden` when unselected, and only the visible panel is a tab stop. */
+export declare class RaqmTabsContentComponent {
+  private readonly tabs;
+  readonly value: import("@angular/core").InputSignal<string>;
+  protected readonly selected: import("@angular/core").Signal<boolean>;
+  protected readonly panelId: import("@angular/core").Signal<string | null>;
+  protected readonly triggerId: import("@angular/core").Signal<string | null>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTabsContentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmTabsContentComponent, "raqm-tabs-content", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Tabs list; the real `role="tablist"`, and appearance comes from the root context so list and triggers cannot drift. */
+export declare class RaqmTabsListComponent {
+  private readonly tabs;
+  protected readonly line: import("@angular/core").Signal<boolean>;
+  protected readonly vertical: import("@angular/core").Signal<boolean>;
+  protected readonly ariaOrientation: import("@angular/core").Signal<"vertical" | null>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTabsListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmTabsListComponent, "raqm-tabs-list", never, {}, {}, never, ["*"], true, never>;
+}
+/** Tabs trigger on the native `<button>`; ARIA, owned id and roving `tabindex` come from the root, and it registers from `ngOnInit`. */
+export declare class RaqmTabsTriggerComponent implements OnInit {
+  private readonly host;
+  private readonly authoredDisabled;
+  private readonly tabs;
+  private readonly destroyRef;
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly ref;
+  protected readonly vertical: import("@angular/core").Signal<boolean>;
+  protected readonly disabledAttribute: import("@angular/core").Signal<"" | null>;
+  protected readonly selected: import("@angular/core").Signal<boolean>;
+  protected readonly id: import("@angular/core").Signal<string | null>;
+  protected readonly panelId: import("@angular/core").Signal<string | null>;
+  protected readonly tabIndex: import("@angular/core").Signal<-1 | 0>;
+  constructor();
+  ngOnInit(): void;
+  protected onClick(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  protected onFocus(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTabsTriggerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmTabsTriggerComponent, "button[raqm-tabs-trigger]", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Tabs root; carries no ARIA role (`tablist` belongs on the list) and uses roving tabindex with manual activation: arrows move focus, Space/Enter selects. */
+export declare class RaqmTabsComponent implements RaqmTabsContext {
+  private readonly host;
+  readonly value: import("@angular/core").ModelSignal<string | undefined>;
+  readonly defaultValue: import("@angular/core").InputSignal<string | undefined>;
+  readonly vertical: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly line: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly tabs;
+  private readonly rootId;
+  private sequence;
+  private readonly enabledTabs;
+  private readonly focused;
+  readonly selectedValue: import("@angular/core").Signal<string | undefined>;
+  private readonly tabStop;
+  private readonly keyboard;
+  isSelected(value: string): boolean;
+  select(value: string): void;
+  /** Registers a trigger in DOM order, minting its ids; called from `ngOnInit` so `value` is bound. */
+  register(trigger: RaqmTabsTriggerRef): void;
+  /** Unregisters a trigger on destroy; survives keep their minted ids. */
+  unregister(trigger: RaqmTabsTriggerRef): void;
+  /** Whether the trigger is the set's single roving tab stop. */
+  isTabStop(trigger: RaqmTabsTriggerRef): boolean;
+  triggerIdOf(trigger: RaqmTabsTriggerRef): string | null;
+  triggerIdFor(value: string): string | null;
+  panelIdFor(value: string): string | null;
+  /** Records the last focused trigger as the roving tab stop; manual activation, so no selection change. */
+  noteFocus(trigger: RaqmTabsTriggerRef): void;
+  /** Moves focus among enabled triggers with wrapping; Left/Right follow the resolved direction (RTL reverses them). */
+  moveFocus(trigger: RaqmTabsTriggerRef, event: KeyboardEvent): void;
+  private isRtl;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTabsComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmTabsComponent, "raqm-tabs", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultValue": {
+      "alias": "defaultValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "vertical": {
+      "alias": "vertical";
+      "required": false;
+      "isSignal": true;
+    };
+    "line": {
+      "alias": "line";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}
+export declare const RaqmTabs: readonly [typeof RaqmTabsComponent, typeof RaqmTabsListComponent, typeof RaqmTabsTriggerComponent, typeof RaqmTabsContentComponent];
+export {};

package/types/raqm-ui-textarea.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+/** Native `<textarea>` host; value, validation and IME stay browser- and Forms-owned. */
+export declare class RaqmTextarea {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmTextarea, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmTextarea, "textarea[raqm-textarea]", never, {}, {}, never, never, true, never>;
+}

package/types/raqm-ui-toast.d.ts

@@ -0,0 +1,190 @@
+import * as i0 from "@angular/core";
+import { OnDestroy } from "@angular/core";
+type RaqmToastId = string;
+type RaqmToastType = 'success' | 'info' | 'warning' | 'error' | 'loading';
+/** Native action; its callback explicitly owns dismissal. */
+interface RaqmToastActionOptions {
+  readonly label: string;
+  readonly onClick: (id: RaqmToastId, event: MouseEvent) => void;
+  readonly disabled?: boolean;
+}
+/** Text notification options; a timeout of 0 disables automatic dismissal. */
+interface RaqmToastOptions {
+  readonly id?: RaqmToastId;
+  readonly title?: string;
+  readonly description?: string;
+  readonly type?: RaqmToastType;
+  readonly timeout?: number;
+  readonly action?: RaqmToastActionOptions;
+  readonly onClose?: () => void;
+}
+/** Immutable notification state; updates preserve its id and increment updateKey. */
+interface RaqmToastRecord extends Omit<RaqmToastOptions, 'id' | 'timeout'> {
+  readonly id: RaqmToastId;
+  readonly timeout: number;
+  readonly updateKey: number;
+  readonly ending?: boolean;
+}
+export declare class RaqmToastService implements OnDestroy {
+  private readonly browser;
+  private readonly records;
+  private readonly clocks;
+  private readonly document;
+  private readonly exits;
+  private owner;
+  private paused;
+  private nextId;
+  private destroyed;
+  /** Newest first; older records queue behind the visible three. */
+  readonly toasts: import("@angular/core").Signal<readonly RaqmToastRecord[]>;
+  readonly visibleToasts: import("@angular/core").Signal<RaqmToastRecord[]>;
+  /** Visible roots plus retained, inert roots finishing the exit. */
+  readonly renderedToasts: import("@angular/core").Signal<RaqmToastRecord[]>;
+  /** Adds a notification, or upserts an existing explicit id without duplication. */
+  show(options: RaqmToastOptions): RaqmToastId;
+  success(options: Omit<RaqmToastOptions, 'type'>): RaqmToastId;
+  error(options: Omit<RaqmToastOptions, 'type'>): RaqmToastId;
+  /** Updates one id for loading → success/error workflows; dismissed ids stay dismissed. */
+  update(id: RaqmToastId, options: Partial<Omit<RaqmToastOptions, 'id'>>): void;
+  /** Dismisses one notification, or all notifications when no id is supplied. */
+  dismiss(id?: RaqmToastId): void;
+  /** Internal host ownership guard: duplicate hosts never create duplicate overlays. */
+  claimViewport(owner: object): boolean;
+  releaseViewport(owner: object): void;
+  pauseViewport(owner: object, paused: boolean): void;
+  ngOnDestroy(): void;
+  private timeout;
+  private createId;
+  private stopClock;
+  private syncClocks;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Composable notification root; never takes focus automatically. */
+export declare class RaqmToastComponent implements OnDestroy {
+  readonly toast: import("@angular/core").InputSignal<RaqmToastRecord>;
+  /** Internal viewport clock-pause signal for captured touch or mouse gestures. */
+  readonly swipingChange: import("@angular/core").OutputEmitterRef<boolean>;
+  private readonly service;
+  private readonly element;
+  private pointer;
+  private start;
+  private initial;
+  private axis;
+  private firstMove;
+  private maximum;
+  private baseline;
+  private intended;
+  private cancelled;
+  private delta;
+  constructor();
+  protected pointerDown(event: PointerEvent): void;
+  protected pointerMove(event: PointerEvent): void;
+  protected pointerEnd(event: PointerEvent): void;
+  ngOnDestroy(): void;
+  private releasePointer;
+  /** Closes this record and contains Escape within the notification. */
+  dismiss(event?: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmToastComponent, "raqm-toast", never, {
+    "toast": {
+      "alias": "toast";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {
+    "swipingChange": "swipingChange";
+  }, never, ["*"], true, never>;
+}
+export declare class RaqmToastTitleDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmToastTitleDirective, "[raqm-toast-title]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmToastContentDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmToastContentDirective, "[raqm-toast-content]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmToastDescriptionDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastDescriptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmToastDescriptionDirective, "[raqm-toast-description]", never, {}, {}, never, never, true, never>;
+}
+/** Native action; the consumer click callback owns its behavior and dismissal. */
+export declare class RaqmToastActionDirective {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastActionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmToastActionDirective, "button[raqm-toast-action]", never, {}, {}, never, never, true, never>;
+}
+/** Native close button operating on its enclosing toast; the application names it. */
+export declare class RaqmToastCloseComponent {
+  protected readonly root: RaqmToastComponent;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastCloseComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmToastCloseComponent, "button[raqm-toast-close]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Decorative inline status glyphs. */
+export declare class RaqmToastIconComponent {
+  readonly type: import("@angular/core").InputSignal<RaqmToastType | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToastIconComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmToastIconComponent, "raqm-toast-icon", never, {
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Nonmodal CDK viewport; mounted once near the application root. */
+export declare class RaqmToasterComponent implements OnDestroy {
+  /** Accessible name of the notification viewport region. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the close control the toaster renders for each toast. */
+  readonly closeLabel: import("@angular/core").InputSignal<string>;
+  protected readonly service: RaqmToastService;
+  private readonly document;
+  private readonly overlay;
+  private readonly container;
+  private readonly host;
+  private readonly panel;
+  private overlayRef?;
+  private observer?;
+  private announcementTimer?;
+  private previousFocus;
+  private hovered;
+  private focused;
+  private swiping;
+  private readonly indices;
+  protected readonly expanded: import("@angular/core").WritableSignal<boolean>;
+  protected readonly announcement: import("@angular/core").WritableSignal<string>;
+  protected readonly ready: import("@angular/core").WritableSignal<boolean>;
+  protected readonly announcementKey: import("@angular/core").Signal<string>;
+  private announced;
+  private readonly pendingAnnouncements;
+  constructor();
+  ngOnDestroy(): void;
+  protected hover(value: boolean): void;
+  protected focusIn(event: FocusEvent): void;
+  protected focusOut(event: FocusEvent): void;
+  protected action(toast: RaqmToastRecord, event: MouseEvent): void;
+  protected toastIndex(toast: RaqmToastRecord): number;
+  protected swipe(value: boolean): void;
+  private syncPause;
+  private measure;
+  private ensureFocus;
+  private restoreFocus;
+  private readonly onDocumentKeydown;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmToasterComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmToasterComponent, "raqm-toaster", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const RaqmToast: readonly [typeof RaqmToastComponent, typeof RaqmToastTitleDirective, typeof RaqmToastContentDirective, typeof RaqmToastDescriptionDirective, typeof RaqmToastActionDirective, typeof RaqmToastCloseComponent, typeof RaqmToastIconComponent, typeof RaqmToasterComponent];
+export type { RaqmToastActionOptions, RaqmToastId, RaqmToastOptions, RaqmToastRecord, RaqmToastType };