@radix-ng/primitives 0.51.0 → 1.0.0-beta.1

package/types/radix-ng-primitives-time-field.d.ts

@@ -1,13 +1,10 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, AfterViewInit, WritableSignal, InputSignal, ModelSignal, Signal, InjectionToken } from '@angular/core';
+import { Signal, WritableSignal, InjectionToken, InputSignal, ModelSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { TimeValue, HourCycle, Granularity, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
+import { TimeValue, HourCycle, Granularity, Direction, BooleanInput, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
 import * as _internationalized_date from '@internationalized/date';
-import { Direction } from '@angular/cdk/bidi';
-import { BooleanInput } from '@angular/cdk/coercion';
 
-declare class RdxTimeFieldRootDirective implements OnInit, AfterViewInit {
-    private readonly elementRef;
+declare class RdxTimeFieldRootDirective {
     /**
      * The controlled checked state of the calendar.
      */
@@ -47,47 +44,61 @@ declare class RdxTimeFieldRootDirective implements OnInit, AfterViewInit {
      * The stepping interval for the time fields. Defaults to 1
      */
     readonly step: _angular_core.InputSignal<DateStep | undefined>;
-    readonly step$: _angular_core.Signal<DateStep>;
+    readonly step$: Signal<DateStep>;
     /**
+     * Locale- and hour-cycle-aware formatter. Recomputed whenever `locale` or
+     * `hourCycle` change so segments always render with the current settings.
      * @ignore
      */
-    readonly defaultDate: _angular_core.Signal<TimeValue>;
+    readonly formatter: Signal<Formatter>;
+    /**
+     * @ignore
+     */
+    readonly defaultDate: Signal<TimeValue>;
     /**
      * The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view
      */
     readonly placeholder: _angular_core.ModelSignal<TimeValue | undefined>;
     /**
+     * Segment input parts, collected from the projected content in DOM order. This
+     * stays in sync with `segmentContents()` (granularity / locale / value changes
+     * add or remove segments) instead of being captured once after view init.
      * @ignore
      */
-    readonly segmentElements: _angular_core.WritableSignal<Set<HTMLElement>>;
+    private readonly segmentInputs;
     /**
+     * The focusable (non-literal) segment elements, in DOM order.
      * @ignore
      */
-    readonly currentFocusedElement: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly segmentElements: Signal<HTMLElement[]>;
     /**
      * @ignore
      */
-    formatter: Formatter;
+    readonly currentFocusedElement: _angular_core.WritableSignal<HTMLElement | null>;
     /**
      * @ignore
      */
-    readonly segmentValues: _angular_core.WritableSignal<SegmentValueObj>;
+    readonly inferredGranularity: Signal<Granularity>;
+    readonly convertedMinValue: Signal<_internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime | undefined>;
+    readonly convertedMaxValue: Signal<_internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime | undefined>;
+    readonly convertedModelValue: _angular_core.WritableSignal<TimeValue | undefined>;
+    readonly convertedPlaceholder: _angular_core.WritableSignal<TimeValue>;
     /**
+     * The per-segment values. Writable so segment editing (via `useDateField`) can
+     * update individual parts, but re-synced from the model whenever the value,
+     * granularity or formatter change — so a controlled `value` set after init is
+     * reflected, and an empty field re-initializes when granularity changes.
      * @ignore
      */
-    readonly inferredGranularity: _angular_core.Signal<Granularity | undefined>;
-    readonly convertedMinValue: _angular_core.Signal<_internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime | undefined>;
-    readonly convertedMaxValue: _angular_core.Signal<_internationalized_date.CalendarDateTime | _internationalized_date.ZonedDateTime | undefined>;
-    readonly convertedModelValue: _angular_core.WritableSignal<TimeValue | undefined>;
-    readonly convertedPlaceholder: _angular_core.WritableSignal<TimeValue>;
+    readonly segmentValues: _angular_core.WritableSignal<SegmentValueObj>;
     /**
      * @ignore
      */
-    readonly isInvalid: _angular_core.Signal<boolean>;
+    readonly isInvalid: Signal<boolean>;
     /**
      * @ignore
      */
-    readonly allSegmentContent: _angular_core.Signal<{
+    readonly allSegmentContent: Signal<{
         obj: _radix_ng_primitives_core.SegmentContentObj;
         arr: {
             part: _radix_ng_primitives_core.SegmentPart;
@@ -97,29 +108,27 @@ declare class RdxTimeFieldRootDirective implements OnInit, AfterViewInit {
     /**
      * An array of segments that should be readonly, which prevent user input on them.
      */
-    readonly segmentContents: _angular_core.Signal<{
+    readonly segmentContents: Signal<{
         part: _radix_ng_primitives_core.SegmentPart;
         value: string;
     }[]>;
     /**
      * @ignore
      */
-    readonly currentSegmentIndex: _angular_core.Signal<number>;
+    readonly currentSegmentIndex: Signal<number>;
     /**
      * @ignore
      */
-    readonly prevFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    readonly prevFocusableSegment: Signal<HTMLElement | null>;
     /**
      * @ignore
      */
-    readonly nextFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    readonly nextFocusableSegment: Signal<HTMLElement | null>;
     /**
      * @ignore
      */
     readonly focusNext: () => void;
     constructor();
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
     /**
      * @ignore
      */
@@ -129,11 +138,17 @@ declare class RdxTimeFieldRootDirective implements OnInit, AfterViewInit {
      */
     setFocusedElement(el: HTMLElement): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTimeFieldRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTimeFieldRootDirective, "[rdxTimeFieldRoot]", ["rdxTimeFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTimeFieldRootDirective, "[rdxTimeFieldRoot]", ["rdxTimeFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, ["segmentInputs"], never, true, never>;
 }
 
 declare class RdxTimeFieldInputDirective {
     private readonly el;
+    /**
+     * The host element of this segment. Consumed by the root to collect focusable
+     * segments in DOM order.
+     * @ignore
+     */
+    readonly element: HTMLElement;
     private readonly rootContext;
     /**
      * The part of the date to render
@@ -190,7 +205,7 @@ interface TimeFieldContextToken {
     isInvalid: Signal<boolean>;
     disabled: InputSignal<boolean>;
     readonly: InputSignal<boolean>;
-    formatter: Formatter;
+    formatter: Signal<Formatter>;
     hourCycle: InputSignal<HourCycle>;
     segmentValues: WritableSignal<SegmentValueObj>;
     focusNext: () => void;

package/types/radix-ng-primitives-toast.d.ts

@@ -0,0 +1,378 @@
+import * as i0 from '@angular/core';
+import { Provider } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/portal';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { RdxTransitionStatus } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import { RdxPopperAnchorElement, Side, Align, RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
+import * as _radix_ng_primitives_toast from '@radix-ng/primitives/toast';
+
+/**
+ * Moves the toast viewport to a different part of the DOM — the Angular counterpart of
+ * `<Toast.Portal>`. Defaults to `document.body`; pass `container` to target another element.
+ */
+declare class RdxToastPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastPortal, "[rdxToastPortal]", ["rdxToastPortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/** Relative ordering hint for a toast. `high` toasts are announced assertively. */
+type RdxToastPriority = 'low' | 'high';
+/** Action-button options carried on a toast and read back by the consumer (e.g. an "Undo" button). */
+interface RdxToastActionProps {
+    /** Visible button label. */
+    label?: string;
+    /** Invoked when the action button is clicked. */
+    onClick?: (event: MouseEvent) => void;
+}
+/**
+ * Anchoring options for a toast rendered through `rdxToastPositioner` instead of the stack. The
+ * `anchor` is any popper-compatible reference (element, `ElementRef`, or virtual element).
+ */
+interface RdxToastPositionerProps {
+    anchor: RdxPopperAnchorElement;
+    side?: Side;
+    sideOffset?: number;
+    align?: Align;
+    alignOffset?: number;
+}
+/**
+ * A single toast in the {@link RdxToastManager} queue. `id` is stable for the toast's lifetime;
+ * `transitionStatus` reflects the enter/leave animation phase (mirrors Base UI's transition system).
+ */
+interface RdxToastObject<Data = unknown> {
+    /** Stable id; generated by the manager when omitted from {@link RdxToastAddOptions}. */
+    id: string;
+    /** Short heading text. */
+    title?: string;
+    /** Supporting body text. */
+    description?: string;
+    /** Caller-defined category (e.g. `'success' | 'error'`) for styling/branching. */
+    type?: string;
+    /** Auto-dismiss delay in ms. `0` (or a negative value) disables auto-dismiss. */
+    timeout?: number;
+    /** Announcement priority. `high` → `role="alert"` (assertive); `low` → `role="status"`. */
+    priority?: RdxToastPriority;
+    /** Arbitrary caller payload, surfaced back to templates/handlers. */
+    data?: Data;
+    /** Enter/leave phase, set by the manager while a toast mounts or is being removed. */
+    transitionStatus?: RdxTransitionStatus;
+    /** Set while a `promise()` toast is awaiting its source promise. */
+    loading?: boolean;
+    /** Action-button options surfaced to the template. */
+    actionProps?: RdxToastActionProps;
+    /** Anchoring options; when present the toast is positioned with `rdxToastPositioner`. */
+    positionerProps?: RdxToastPositionerProps;
+    /** Bump on an upsert (same `id`) to replay the enter animation. */
+    updateKey?: number | string;
+    /** Invoked when the toast is dismissed (by timeout, swipe, or `close()`). */
+    onClose?: () => void;
+    /** Invoked after the leave animation completes and the toast leaves the queue. */
+    onRemove?: () => void;
+}
+/** Options accepted by {@link RdxToastManager.add} / {@link RdxToastManager.update}. */
+interface RdxToastAddOptions<Data = unknown> {
+    id?: string;
+    title?: string;
+    description?: string;
+    type?: string;
+    timeout?: number;
+    priority?: RdxToastPriority;
+    data?: Data;
+    /** Marks the toast as pending (used by `promise()`); pending toasts skip auto-dismiss. */
+    loading?: boolean;
+    actionProps?: RdxToastActionProps;
+    positionerProps?: RdxToastPositionerProps;
+    updateKey?: number | string;
+    onClose?: () => void;
+    onRemove?: () => void;
+}
+/** Per-state copy used by {@link RdxToastManager.promise}. */
+interface RdxToastPromiseOptions<Value = unknown, Data = unknown> {
+    loading: RdxToastAddOptions<Data> | string;
+    success: RdxToastAddOptions<Data> | string | ((value: Value) => RdxToastAddOptions<Data> | string);
+    error: RdxToastAddOptions<Data> | string | ((error: unknown) => RdxToastAddOptions<Data> | string);
+}
+
+/**
+ * App-level coordinator and imperative API for toasts — the Angular counterpart of Base UI's
+ * `<Toast.Provider>` plus `useToastManager()`. Holds the queue as a signal that `RdxToastViewport`
+ * renders, owns each toast's auto-dismiss timer (pausable while the viewport is hovered/focused),
+ * and exposes `add` / `update` / `close` / `promise`.
+ *
+ * Provide it once near the app root with {@link provideRdxToastManager} or the `[rdxToastProvider]`
+ * directive, then inject `RdxToastManager` anywhere to push toasts.
+ */
+declare class RdxToastManager {
+    private readonly idGenerator;
+    private readonly _toasts;
+    /** The live queue, oldest first. Render it in `RdxToastViewport` (e.g. via `@for`). */
+    readonly toasts: i0.Signal<RdxToastObject<unknown>[]>;
+    /** Whether any toast is currently in the queue. */
+    readonly hasToasts: i0.Signal<boolean>;
+    private readonly _expanded;
+    /** Whether the stack is expanded (viewport hovered or focused) — drives `data-expanded`. */
+    readonly expanded: i0.Signal<boolean>;
+    private readonly _heights;
+    /** Measured heights (px) per toast id, reported by each `RdxToastRoot` for expanded-stack offsets. */
+    readonly heights: i0.Signal<Record<string, number>>;
+    /**
+     * Per-toast stacking metrics, computed once for the whole queue (front = newest, index `0`):
+     * `index` is the distance from the front and `offsetY` is the combined height of the toasts
+     * stacked in front. Roots read this by id instead of each rescanning the queue (O(n) vs O(n²)).
+     */
+    readonly layout: i0.Signal<Record<string, {
+        index: number;
+        offsetY: number;
+    }>>;
+    /** Max number of simultaneously visible toasts. Configurable via `[rdxToastProvider]`. */
+    limit: number;
+    /** Default auto-dismiss delay (ms) for toasts that omit `timeout`. Set via `[rdxToastProvider]`. */
+    defaultTimeout: number;
+    private readonly timers;
+    /** Nested-pause depth so overlapping holds (hover + swipe) resume only when all release. */
+    private pauseDepth;
+    /** Queue a new toast. Returns its id (generated when not supplied). */
+    add<Data = unknown>(options: RdxToastAddOptions<Data>): string;
+    /** Merge new options into an existing toast (no-op if the id is unknown). */
+    update<Data = unknown>(id: string, options: Partial<RdxToastAddOptions<Data>>): void;
+    /**
+     * Begin dismissing a toast: fire `onClose`, then remove it after the leave animation.
+     * Omit `id` to dismiss every toast at once (mirrors Base UI's `close()`).
+     */
+    close(id?: string): void;
+    /**
+     * Remove a toast from the queue immediately. `RdxToastRoot` calls this once its leave animation
+     * has finished; call it directly only when there is no exit animation.
+     */
+    remove(id: string): void;
+    /** Toggle the expanded (hover/focus) state of the stack. Called by the viewport. */
+    setExpanded(expanded: boolean): void;
+    /** Record a toast's measured height (px) for expanded-stack offset math. Called by each root. */
+    setHeight(id: string, height: number): void;
+    /** Pause every auto-dismiss timer (e.g. while the viewport is hovered, focused, or being swiped). */
+    pauseAll(): void;
+    /** Release one pause; auto-dismiss timers resume only once every hold has released. */
+    resumeAll(): void;
+    /**
+     * Drive a toast through a promise's lifecycle: show `loading`, then swap to `success` or
+     * `error` copy when it settles. Returns the original promise for chaining.
+     */
+    promise<Value, Data = unknown>(promise: Promise<Value>, options: RdxToastPromiseOptions<Value, Data>): Promise<Value>;
+    private scheduleTimeout;
+    private clearTimer;
+    private clearHeight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdxToastManager>;
+}
+/** Provide a {@link RdxToastManager} for an app (e.g. in `app.config.ts`). */
+declare function provideRdxToastManager(): Provider[];
+/**
+ * Hosts a {@link RdxToastManager} for its subtree. Put it on a wrapping element (or the app root)
+ * so descendant viewports and components share one queue. `limit` caps simultaneously visible toasts.
+ */
+declare class RdxToastProvider {
+    private readonly manager;
+    /** Max number of toasts shown at once. */
+    readonly limit: i0.InputSignal<number>;
+    /** Default auto-dismiss delay (ms) for toasts that omit their own `timeout`. `0` disables it. */
+    readonly timeout: i0.InputSignal<number>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastProvider, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastProvider, "[rdxToastProvider]", ["rdxToastProvider"], { "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "timeout": { "alias": "timeout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The positioned region that holds the visible toasts — the Angular counterpart of
+ * `<Toast.Viewport>`. Exposes the queue for templates to render, and while it is hovered or focused
+ * it expands the stack (`data-expanded` on each root) and pauses every auto-dismiss timer, resuming
+ * once neither hover nor focus remains — matching Base UI.
+ *
+ * Headless: it carries no positioning styles. Consumers position it (e.g. fixed bottom-right) and
+ * iterate `viewport.toasts()` with `@for`.
+ */
+declare class RdxToastViewport {
+    protected readonly manager: RdxToastManager;
+    /** The live toast queue to render. */
+    readonly toasts: i0.Signal<_radix_ng_primitives_toast.RdxToastObject<unknown>[]>;
+    protected readonly hovered: i0.WritableSignal<boolean>;
+    protected readonly focused: i0.WritableSignal<boolean>;
+    /** Tracks the last expanded state so pause/resume stay balanced across transitions. */
+    private wasExpanded;
+    constructor();
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastViewport, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastViewport, "[rdxToastViewport]", ["rdxToastViewport"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Positions an anchored toast against an element — the Angular counterpart of `<Toast.Positioner>`.
+ * Composes the popper machinery so a toast can point at a trigger instead of living in the stack.
+ *
+ * Bind `anchor` (and optionally `side`/`align`/offsets) — typically from a toast's `positionerProps`.
+ * It hosts its own `RdxPopper` so it is self-contained (no surrounding `rdxPopperRoot` needed), and
+ * mirrors the popper measurements as friendlier CSS variables plus `data-side` / `data-align`.
+ */
+declare class RdxToastPositioner {
+    protected readonly wrapper: RdxPopperContentWrapper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastPositioner, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastPositioner, "[rdxToastPositioner]", ["rdxToastPositioner"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }, { directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "anchor": "anchor"; "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "positionStrategy": "positionStrategy"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
+}
+
+/** Direction a swipe travels to dismiss a toast. */
+type RdxToastSwipeDirection = 'up' | 'down' | 'left' | 'right';
+interface RdxToastSwipeConfig {
+    /** The toast element the gesture lives on (CSS variables + data attributes are written here). */
+    element: () => HTMLElement;
+    /** Allowed dismiss directions; the gesture follows whichever the user drags toward most. */
+    directions: () => RdxToastSwipeDirection[];
+    /** Whether the gesture is armed (false while the toast is leaving). */
+    enabled: () => boolean;
+    /** Travel (px) past which a release dismisses. Defaults to {@link DEFAULT_THRESHOLD}. */
+    threshold?: number;
+    /** Called once per release that commits to dismissal. */
+    onDismiss: (event: PointerEvent) => void;
+    /** Called when a swipe actually begins (e.g. to pause auto-dismiss timers). */
+    onPress?: () => void;
+    /** Called when a started swipe ends, dismissing or not (balances {@link RdxToastSwipeConfig.onPress}). */
+    onRelease?: () => void;
+}
+/**
+ * Headless swipe-to-dismiss for a toast, built on the shared {@link usePointerDrag} lifecycle (which
+ * owns pointer capture, the start threshold, window listeners, and tap/cancel handling). This layer
+ * adds the toast-specific direction projection, rubber-banding, flick detection, and the styling
+ * contract — it applies no transform itself:
+ *
+ * - `--toast-swipe-movement-x` / `--toast-swipe-movement-y` — signed px offset along the active axis.
+ * - `[data-swiping]` — present while a gesture is active (drive `transition: none` off this).
+ * - `[data-swipe-direction]` — the active direction.
+ * - `[data-swipe-dismiss]` — present briefly when a release commits to dismissal.
+ *
+ * Mark inner interactive regions with `[data-toast-swipe-ignore]` to opt them out of the gesture.
+ * `RdxToastRoot` (the gesture host) sets `touch-action: none` so a touch-drag is not stolen by native
+ * scrolling — without it the gesture only works with a mouse, not on touch devices.
+ * Must be called from an injection context (a directive constructor).
+ */
+declare function useToastSwipe(config: RdxToastSwipeConfig): void;
+
+interface RdxToastRootContext {
+    /** The toast model this part tree renders. */
+    readonly toast: () => RdxToastObject;
+    /** `id` of the title element, wired to `aria-labelledby` once a title registers. */
+    readonly titleId: string;
+    /** `id` of the description element, wired to `aria-describedby` once a description registers. */
+    readonly descriptionId: string;
+    /** Register/unregister the title part so the root only points `aria-labelledby` at a real element. */
+    readonly setTitlePresent: (present: boolean) => void;
+    /** Register/unregister the description part so `aria-describedby` only targets a real element. */
+    readonly setDescriptionPresent: (present: boolean) => void;
+    /** Begin dismissing this toast. */
+    readonly close: () => void;
+}
+declare const injectRdxToastRootContext: _radix_ng_primitives_core.InjectContext<RdxToastRootContext>;
+declare const provideRdxToastRootContext: (useFactory: () => RdxToastRootContext) => i0.Provider;
+/**
+ * A single toast — the Angular counterpart of `<Toast.Root>`. Bind the toast model from the
+ * viewport's `@for`; this directive owns the announcement `role`, the `data-state` enter/leave
+ * contract, swipe-to-dismiss, and the stacking variables consumers style against.
+ *
+ * Stacking / styling contract written to the host (no transform is applied for you):
+ * - `--toast-index` — position from the front (`0` = frontmost).
+ * - `--toast-height` — this toast's measured height (px).
+ * - `--toast-offset-y` — combined height (px) of the toasts stacked in front, for expanded layout.
+ * - `--toast-swipe-movement-x` / `--toast-swipe-movement-y` — live swipe offset (px).
+ * - `[data-front]` — present on the frontmost toast.
+ * - `[data-expanded]` — present while the viewport is hovered/focused.
+ * - `[data-state]` — `open` while visible, `closed` once dismissal begins.
+ * - `[data-swiping]` / `[data-swipe-direction]` / `[data-swipe-dismiss]` — gesture state.
+ *
+ * When the leave animation (driven by `data-state="closed"`) ends, the toast leaves the queue.
+ */
+declare class RdxToastRoot {
+    protected readonly manager: RdxToastManager;
+    private readonly elementRef;
+    private readonly injector;
+    /** The toast model to render — pass the item from the viewport's `@for`. */
+    readonly toast: i0.InputSignal<RdxToastObject<unknown>>;
+    /** Allowed swipe-to-dismiss directions. Accepts a single direction or a list. */
+    readonly swipeDirection: i0.InputSignal<RdxToastSwipeDirection | RdxToastSwipeDirection[]>;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    /** Whether a title / description part has registered, gating the aria-* references. */
+    readonly titlePresent: i0.WritableSignal<boolean>;
+    readonly descriptionPresent: i0.WritableSignal<boolean>;
+    private readonly size;
+    /** This toast's measured height (px). */
+    readonly height: i0.Signal<number>;
+    /** Position from the front of the stack — `0` is the newest/frontmost toast. */
+    readonly index: i0.Signal<number>;
+    /** Combined height (px) of the toasts stacked in front of this one (for expanded layout). */
+    readonly offsetY: i0.Signal<number>;
+    /** `alert` (assertive) for high-priority toasts, otherwise `status`. */
+    readonly role: i0.Signal<"alert" | "status">;
+    /** `open` while visible, `closed` once dismissal begins — drives enter/leave animations. */
+    readonly dataState: i0.Signal<"closed" | "open">;
+    private readonly directions;
+    constructor();
+    close(): void;
+    protected onAnimationEnd(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastRoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastRoot, "[rdxToastRoot]", ["rdxToastRoot"], { "toast": { "alias": "toast"; "required": true; "isSignal": true; }; "swipeDirection": { "alias": "swipeDirection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Wraps a toast's inner parts (title, description, actions) — the Angular counterpart of
+ * `<Toast.Content>`. Headless: it carries no styles; consumers apply `overflow: hidden` to clip
+ * taller toasts during the stack/expand animation. It mirrors the root's `data-state` so content
+ * can transition together with the root.
+ */
+declare class RdxToastContent {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastContent, "[rdxToastContent]", ["rdxToastContent"], {}, {}, never, never, true, never>;
+}
+
+/** Accessible title for a toast; registers so the root only points `aria-labelledby` at a real node. */
+declare class RdxToastTitle {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastTitle, "[rdxToastTitle]", ["rdxToastTitle"], {}, {}, never, never, true, never>;
+}
+
+/** Supporting body text for a toast; registers so `aria-describedby` only targets a real node. */
+declare class RdxToastDescription {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastDescription, "[rdxToastDescription]", ["rdxToastDescription"], {}, {}, never, never, true, never>;
+}
+
+/** Button that dismisses its toast. Put it on a native `<button>` for built-in semantics. */
+declare class RdxToastClose {
+    protected readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastClose, "[rdxToastClose]", ["rdxToastClose"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * An action button inside a toast (e.g. "Undo"). Unlike {@link RdxToastClose} it does not dismiss
+ * on its own — wire your handler with `(click)` and call `close()` from the exposed context when
+ * the action should also close the toast.
+ */
+declare class RdxToastAction {
+    /** The toast root context, so handlers can read the toast or dismiss it after acting. */
+    readonly rootContext: _radix_ng_primitives_toast.RdxToastRootContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastAction, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToastAction, "[rdxToastAction]", ["rdxToastAction"], {}, {}, never, never, true, never>;
+}
+
+declare const toastImports: (typeof RdxToastPortal)[];
+declare class RdxToastModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToastModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxToastModule, never, [typeof RdxToastProvider, typeof RdxToastPortal, typeof RdxToastViewport, typeof RdxToastPositioner, typeof RdxToastRoot, typeof RdxToastContent, typeof RdxToastTitle, typeof RdxToastDescription, typeof RdxToastClose, typeof RdxToastAction], [typeof RdxToastProvider, typeof RdxToastPortal, typeof RdxToastViewport, typeof RdxToastPositioner, typeof RdxToastRoot, typeof RdxToastContent, typeof RdxToastTitle, typeof RdxToastDescription, typeof RdxToastClose, typeof RdxToastAction]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxToastModule>;
+}
+
+export { RdxToastAction, RdxToastClose, RdxToastContent, RdxToastDescription, RdxToastManager, RdxToastModule, RdxToastPortal, RdxToastPositioner, RdxToastProvider, RdxToastRoot, RdxToastTitle, RdxToastViewport, injectRdxToastRootContext, provideRdxToastManager, provideRdxToastRootContext, toastImports, useToastSwipe };
+export type { RdxToastActionProps, RdxToastAddOptions, RdxToastObject, RdxToastPositionerProps, RdxToastPriority, RdxToastPromiseOptions, RdxToastRootContext, RdxToastSwipeConfig, RdxToastSwipeDirection };