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

package/types/radix-ng-primitives-alert-dialog.d.ts

@@ -1,57 +1,114 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, ViewContainerRef } from '@angular/core';
-import * as i1 from '@angular/cdk/a11y';
+import * as i1 from '@radix-ng/primitives/dialog';
+import { RdxDialogHandle } from '@radix-ng/primitives/dialog';
 
-declare class RdxAlertDialogRootDirective {
-    private readonly viewContainerRef;
-    private readonly alertDialogService;
-    set content(template: TemplateRef<any>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogRootDirective, "[rdxAlertDialogRoot]", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
+/**
+ * An overlay displayed beneath the alert dialog popup.
+ */
+declare class RdxAlertDialogBackdrop {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogBackdrop, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogBackdrop, "[rdxAlertDialogBackdrop]", ["rdxAlertDialogBackdrop"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogBackdrop; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxAlertDialogContentDirective {
-    private readonly renderer;
-    private readonly elementRef;
-    set maxWidth(value: string);
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogContentDirective, "[rdxAlertDialogContent]", never, { "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.CdkTrapFocus; inputs: {}; outputs: {}; }]>;
+/**
+ * Groups all parts of the alert dialog.
+ *
+ * Composes the Dialog primitive and forces alert-dialog semantics: it is always modal, never
+ * dismisses on outside pointer / focus-out interactions (Escape still closes), and renders its
+ * popup with `role="alertdialog"`. Assemble it from the `rdxAlertDialog*` parts (Popup, Backdrop,
+ * Title, Description, Close, Portal, Viewport), which are thin wrappers around the dialog parts.
+ */
+declare class RdxAlertDialogRoot {
+    private readonly dialog;
+    /** Whether the alert dialog is open (read-only mirror of the composed dialog state). */
+    readonly open: i0.ModelSignal<boolean>;
+    /** The active trigger's id. */
+    readonly triggerId: i0.ModelSignal<string | null>;
+    /** Payload of the active trigger. */
+    readonly payload: i0.WritableSignal<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogRoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogRoot, "[rdxAlertDialogRoot]", ["rdxAlertDialogRoot"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogRoot; inputs: { "open": "open"; "defaultOpen": "defaultOpen"; "triggerId": "triggerId"; "defaultTriggerId": "defaultTriggerId"; "handle": "handle"; }; outputs: { "openChange": "openChange"; "triggerIdChange": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }; }]>;
 }
 
-declare class RdxAlertDialogCancelDirective {
-    private readonly alertDialogService;
-    onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogCancelDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogCancelDirective, "[rdxAlertDialogCancel]", never, {}, {}, never, never, true, never>;
+/**
+ * A button that opens the alert dialog. Behaves exactly like the dialog trigger.
+ */
+declare class RdxAlertDialogTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTrigger, "button[rdxAlertDialogTrigger]", ["rdxAlertDialogTrigger"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogTrigger; inputs: { "handle": "handle"; "payload": "payload"; "id": "id"; "disabled": "disabled"; }; outputs: {}; }]>;
 }
 
-declare class RdxAlertDialogTriggerDirective {
-    private readonly alertDialogService;
-    handleClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTriggerDirective, "[rdxAlertDialogTrigger]", never, {}, {}, never, never, true, never>;
+/**
+ * Mounts the portal while the alert dialog is open and waits for CSS exit keyframes before unmounting.
+ */
+declare class RdxAlertDialogPortalPresence {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogPortalPresence, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogPortalPresence, "ng-template[rdxAlertDialogPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPortalPresence; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxAlertDialogTitleDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTitleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTitleDirective, "[rdxAlertDialogTitle]", never, {}, {}, never, never, true, never>;
+/**
+ * Moves the alert dialog to a different part of the DOM. Defaults to `document.body`.
+ */
+declare class RdxAlertDialogPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogPortal, "[rdxAlertDialogPortal]", ["rdxAlertDialogPortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
 }
 
-declare class RdxAlertDialogService {
-    private overlayRef;
-    private readonly overlay;
-    private dialogContent;
-    setDialogContent(viewContainerRef: ViewContainerRef, template: TemplateRef<any>): void;
-    open(): void;
-    close(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RdxAlertDialogService>;
+/**
+ * A scrollable positioning container for the alert dialog popup.
+ */
+declare class RdxAlertDialogViewport {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogViewport, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogViewport, "[rdxAlertDialogViewport]", ["rdxAlertDialogViewport"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogViewport; inputs: {}; outputs: {}; }]>;
 }
 
+/**
+ * A container for the alert dialog contents. Wraps the dialog popup, which reads alert semantics
+ * (role, modal, dismissal) from the alert root's variant.
+ */
+declare class RdxAlertDialogPopup {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogPopup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogPopup, "[rdxAlertDialogPopup]", ["rdxAlertDialogPopup"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPopup; inputs: {}; outputs: { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }; }]>;
+}
+
+/**
+ * An accessible title for the alert dialog.
+ */
+declare class RdxAlertDialogTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTitle, "[rdxAlertDialogTitle]", ["rdxAlertDialogTitle"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogTitle; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * An accessible description for the alert dialog.
+ */
+declare class RdxAlertDialogDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogDescription, "[rdxAlertDialogDescription]", ["rdxAlertDialogDescription"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogDescription; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A button that closes the alert dialog.
+ */
+declare class RdxAlertDialogClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogClose, "button[rdxAlertDialogClose]", ["rdxAlertDialogClose"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogClose; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Connects an alert dialog root with trigger elements rendered elsewhere in the DOM.
+ *
+ * Alert dialogs reuse the dialog handle implementation unchanged.
+ */
+declare const RdxAlertDialogHandle: typeof RdxDialogHandle;
+type RdxAlertDialogHandle<Payload = unknown> = RdxDialogHandle<Payload>;
+declare function createRdxAlertDialogHandle<Payload = unknown>(): RdxAlertDialogHandle<Payload>;
+
+declare const alertDialogImports: (typeof RdxAlertDialogBackdrop)[];
 declare class RdxAlertDialogModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAlertDialogModule, never, [typeof RdxAlertDialogRootDirective, typeof RdxAlertDialogContentDirective, typeof RdxAlertDialogCancelDirective, typeof RdxAlertDialogTriggerDirective, typeof RdxAlertDialogTitleDirective], [typeof RdxAlertDialogRootDirective, typeof RdxAlertDialogContentDirective, typeof RdxAlertDialogCancelDirective, typeof RdxAlertDialogTriggerDirective, typeof RdxAlertDialogTitleDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAlertDialogModule, never, [typeof RdxAlertDialogRoot, typeof RdxAlertDialogTrigger, typeof RdxAlertDialogPortalPresence, typeof RdxAlertDialogPortal, typeof RdxAlertDialogBackdrop, typeof RdxAlertDialogViewport, typeof RdxAlertDialogPopup, typeof RdxAlertDialogTitle, typeof RdxAlertDialogDescription, typeof RdxAlertDialogClose], [typeof RdxAlertDialogRoot, typeof RdxAlertDialogTrigger, typeof RdxAlertDialogPortalPresence, typeof RdxAlertDialogPortal, typeof RdxAlertDialogBackdrop, typeof RdxAlertDialogViewport, typeof RdxAlertDialogPopup, typeof RdxAlertDialogTitle, typeof RdxAlertDialogDescription, typeof RdxAlertDialogClose]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxAlertDialogModule>;
 }
 
-export { RdxAlertDialogCancelDirective, RdxAlertDialogContentDirective, RdxAlertDialogModule, RdxAlertDialogRootDirective, RdxAlertDialogService, RdxAlertDialogTitleDirective, RdxAlertDialogTriggerDirective };
+export { RdxAlertDialogBackdrop, RdxAlertDialogClose, RdxAlertDialogDescription, RdxAlertDialogHandle, RdxAlertDialogModule, RdxAlertDialogPopup, RdxAlertDialogPortal, RdxAlertDialogPortalPresence, RdxAlertDialogRoot, RdxAlertDialogTitle, RdxAlertDialogTrigger, RdxAlertDialogViewport, alertDialogImports, createRdxAlertDialogHandle };

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { NumberInput } from '@angular/cdk/coercion';
+import { NumberInput } from '@radix-ng/primitives/core';
 
 declare class RdxArrow {
     readonly width: _angular_core.InputSignalWithTransform<number, NumberInput>;

package/types/radix-ng-primitives-aspect-ratio.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { AfterViewInit } from '@angular/core';
-import { NumberInput } from '@angular/cdk/coercion';
+import { NumberInput } from '@radix-ng/primitives/core';
 
 /**
  * Directive to maintain an aspect ratio for an element.

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { WritableSignal, OnInit, OnDestroy, InjectionToken, Provider } from '@angular/core';
+import { WritableSignal, InjectionToken, Provider } from '@angular/core';
 
 type RdxImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
 type HTMLAttributeReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
@@ -28,7 +28,6 @@ declare class RdxAvatarFallbackDirective {
      */
     readonly delayMs: i0.InputSignal<number>;
     protected readonly canRender: i0.WritableSignal<boolean>;
-    private timeout;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarFallbackDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarFallbackDirective, "span[rdxAvatarFallback]", ["rdxAvatarFallback"], { "delayMs": { "alias": "delayMs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -37,7 +36,7 @@ declare class RdxAvatarFallbackDirective {
 /**
  * @group Components
  */
-declare class RdxAvatarImageDirective implements OnInit, OnDestroy {
+declare class RdxAvatarImageDirective {
     private readonly platformId;
     protected readonly rootContext: AvatarContextToken;
     /**
@@ -52,11 +51,8 @@ declare class RdxAvatarImageDirective implements OnInit, OnDestroy {
      * @group Emits
      */
     readonly onLoadingStatusChange: i0.OutputEmitterRef<RdxImageLoadingStatus>;
-    private readonly isMounted;
     private readonly loadingStatus;
     constructor();
-    ngOnInit(): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarImageDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarImageDirective, "img[rdxAvatarImage]", ["rdxAvatarImage"], { "src": { "alias": "src"; "required": false; "isSignal": true; }; "referrerPolicy": { "alias": "referrerPolicy"; "required": false; "isSignal": true; }; }, { "onLoadingStatusChange": "onLoadingStatusChange"; }, never, never, true, never>;
 }
@@ -74,11 +70,11 @@ declare const RdxAvatarConfigToken: InjectionToken<RdxAvatarConfig>;
 declare function provideRdxAvatarConfig(config: Partial<RdxAvatarConfig>): Provider[];
 declare function injectAvatarConfig(): RdxAvatarConfig;
 
-declare class RdxCheckboxModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective], [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCheckboxModule>;
+declare class RdxAvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAvatarModule, never, [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective], [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxAvatarModule>;
 }
 
-export { RdxAvatarConfigToken, RdxAvatarFallbackDirective, RdxAvatarImageDirective, RdxAvatarRootDirective, RdxCheckboxModule, defaultAvatarConfig, injectAvatarConfig, provideRdxAvatarConfig };
+export { RdxAvatarConfigToken, RdxAvatarFallbackDirective, RdxAvatarImageDirective, RdxAvatarModule, RdxAvatarRootDirective, defaultAvatarConfig, injectAvatarConfig, provideRdxAvatarConfig };
 export type { RdxAvatarConfig, RdxImageLoadingStatus };

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

@@ -0,0 +1,73 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@radix-ng/primitives/core';
+
+type RdxButtonType = 'button' | 'submit' | 'reset';
+interface RdxButtonProps {
+    /**
+     * Whether the button is disabled.
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * Whether the button should remain focusable when disabled. When `true`,
+     * the disabled state is expressed with `aria-disabled` (instead of the
+     * native `disabled` attribute) so the control stays in the tab order while
+     * its activation is suppressed.
+     * @defaultValue false
+     */
+    focusableWhenDisabled?: boolean;
+    /**
+     * The `type` attribute applied to native `<button>` hosts.
+     * @defaultValue 'button'
+     */
+    type?: RdxButtonType;
+}
+/**
+ * Headless button behavior, modeled on Base UI's `useButton`.
+ *
+ * Renders accessible button semantics on a native `<button>` or on any other
+ * element (e.g. `<a>`, `<span>`). Carries no styles — state is exposed via
+ * `data-disabled` for consumers to style.
+ *
+ * @group Components
+ */
+declare class RdxButtonDirective {
+    private readonly elementRef;
+    /**
+     * Whether the button is disabled.
+     * @group Props
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Keep the button focusable while disabled (uses `aria-disabled`).
+     * @group Props
+     */
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The `type` attribute applied to native `<button>` hosts.
+     * @group Props
+     */
+    readonly type: _angular_core.InputSignal<RdxButtonType>;
+    /**
+     * @ignore
+     */
+    protected readonly isNativeButton: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     * Express disabled via `aria-disabled` on non-button hosts, or whenever the
+     * control must stay focusable.
+     */
+    protected readonly ariaDisabled: _angular_core.Signal<"true" | undefined>;
+    /**
+     * @ignore
+     */
+    protected readonly tabIndex: _angular_core.Signal<-1 | 0 | undefined>;
+    constructor();
+    private handleClick;
+    private handleKeydown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxButtonDirective, "[rdxButton]", ["rdxButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { RdxButtonDirective };
+export type { RdxButtonProps, RdxButtonType };

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

@@ -1,12 +1,12 @@
 import * as _angular_core from '@angular/core';
-import { AfterViewInit, WritableSignal, InputSignal, ModelSignal, Signal } from '@angular/core';
+import { Signal, InputSignal, ModelSignal } from '@angular/core';
 import { DateValue } from '@internationalized/date';
-import { DateMatcher, Formatter, Month } from '@radix-ng/primitives/core';
-import { BooleanInput } from '@angular/cdk/coercion';
+import { DateMatcher, Formatter, BooleanInput, Month } from '@radix-ng/primitives/core';
 
-declare class RdxCalendarCellTriggerDirective implements AfterViewInit {
+declare class RdxCalendarCellTriggerDirective {
     private readonly rootContext;
     private readonly elementRef;
+    constructor();
     /**
      * The date value provided to the cell trigger
      */
@@ -36,10 +36,13 @@ declare class RdxCalendarCellTriggerDirective implements AfterViewInit {
      * @ignore
      */
     currentElement: HTMLElement;
-    ngAfterViewInit(): void;
     protected onClick(): void;
+    /** Select the date unless the cell is disabled/unavailable or the calendar is readonly. */
+    private select;
     protected onArrowKey(event: Event): void;
     private shiftFocus;
+    /** Focus the cell at `index`, skipping over a disabled cell in the same direction. */
+    private focusCell;
     /**
      * @ignore
      */
@@ -60,17 +63,20 @@ interface CalendarRootContextToken {
     nextPage?: (nextPageFunc?: (date: DateValue) => DateValue) => void;
     prevPage?: (nextPageFunc?: (date: DateValue) => DateValue) => void;
     isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
-    isPrevButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
-    headingValue: WritableSignal<string>;
+    isPrevButtonDisabled: (prevPageFunc?: (date: DateValue) => DateValue) => boolean;
+    headingValue: Signal<string>;
     dir: InputSignal<'ltr' | 'rtl'>;
-    readonly: boolean;
+    readonly: Signal<boolean>;
     numberOfMonths: InputSignal<number>;
     placeholder: ModelSignal<DateValue>;
-    pagedNavigation: boolean;
-    disabled: InputSignal<boolean>;
-    isDateSelected?: DateMatcher;
-    isDateDisabled?: DateMatcher;
-    isDateUnavailable: DateMatcher;
+    pagedNavigation: Signal<boolean>;
+    disabled: Signal<boolean>;
+    /** Resolved matcher: whether the given date is currently selected. */
+    isDateSelected: DateMatcher;
+    /** Resolved matcher: disabled = root `disabled` OR `isDateDisabled` input OR outside min/max. */
+    dateDisabled: DateMatcher;
+    /** Resolved matcher: unavailable = `isDateUnavailable` input. */
+    dateUnavailable: DateMatcher;
     formatter: Formatter;
     onDateChange: (date: DateValue) => void;
     currentElement: HTMLElement;
@@ -135,7 +141,7 @@ declare class RdxCalendarPrevDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCalendarPrevDirective, "button[rdxCalendarPrev]", ["rdxCalendarPrev"], { "prevPage": { "alias": "prevPage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class RdxCalendarRootDirective implements AfterViewInit {
+declare class RdxCalendarRootDirective {
     private readonly elementRef;
     /**
      * The controlled checked state of the calendar
@@ -146,7 +152,7 @@ declare class RdxCalendarRootDirective implements AfterViewInit {
      */
     readonly defaultPlaceholder: _angular_core.ModelSignal<DateValue | undefined>;
     readonly locale: _angular_core.InputSignal<string>;
-    readonly defaultDate: DateValue;
+    readonly defaultDate: _angular_core.Signal<DateValue>;
     /**
      * 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
@@ -224,11 +230,11 @@ declare class RdxCalendarRootDirective implements AfterViewInit {
     /**
      * @ignore
      */
-    readonly headingValue: _angular_core.WritableSignal<string>;
+    readonly headingValue: _angular_core.Signal<string>;
     /**
      * @ignore
      */
-    readonly fullCalendarLabel: _angular_core.WritableSignal<string>;
+    readonly fullCalendarLabel: _angular_core.Signal<string>;
     /**
      * @ignore
      */
@@ -246,13 +252,27 @@ declare class RdxCalendarRootDirective implements AfterViewInit {
      */
     isPrevButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
     /**
+     * Resolved matchers from the composable, exposed to child parts via context.
      * @ignore
      */
-    isDateSelected: DateMatcher;
+    dateDisabled: DateMatcher;
+    /**
+     * @ignore
+     */
+    dateUnavailable: DateMatcher;
+    /**
+     * Selection + validity state, recomputed when the value or the matchers change.
+     * @ignore
+     */
+    private readonly _state;
+    /**
+     * @ignore
+     */
+    readonly isDateSelected: DateMatcher;
     /**
      * @ignore
      */
-    isInvalid: boolean;
+    readonly isInvalid: _angular_core.Signal<boolean>;
     /**
      * @ignore
      */
@@ -267,7 +287,6 @@ declare class RdxCalendarRootDirective implements AfterViewInit {
     currentElement: HTMLElement;
     private readonly calendar;
     constructor();
-    ngAfterViewInit(): void;
     /**
      * @ignore
      */