@radix-ng/primitives 0.36.0 → 0.38.0

package/accordion/index.d.ts

@@ -4,6 +4,8 @@ import * as i2 from "./src/accordion-header.directive";
 import * as i3 from "./src/accordion-item.directive";
 import * as i4 from "./src/accordion-root.directive";
 import * as i5 from "./src/accordion-trigger.directive";
+import * as i6 from "./src/accordion-content-presence.directive";
+export * from './src/accordion-content-presence.directive';
 export * from './src/accordion-content.directive';
 export * from './src/accordion-header.directive';
 export * from './src/accordion-item.directive';
@@ -11,6 +13,6 @@ export * from './src/accordion-root.directive';
 export * from './src/accordion-trigger.directive';
 export declare class RdxAccordionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective], [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective, typeof i6.RdxAccordionContentPresenceDirective], [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective, typeof i6.RdxAccordionContentPresenceDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxAccordionModule>;
 }

package/accordion/src/accordion-content-presence.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
+export declare class RdxAccordionContentPresenceDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentPresenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentPresenceDirective, "ng-template[rdxAccordionContentPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentPresenceDirective; inputs: {}; outputs: {}; }]>;
+}

package/accordion/src/accordion-content.directive.d.ts

@@ -1,11 +1,8 @@
-import { RdxAccordionItemDirective } from './accordion-item.directive';
 import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
 export declare class RdxAccordionContentDirective {
-    protected readonly item: RdxAccordionItemDirective;
-    protected readonly nativeElement: any;
-    protected hidden: boolean;
-    protected onAnimationEnd(): void;
-    onToggle(): void;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", ["rdxAccordionContent"], {}, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentDirective; inputs: {}; outputs: {}; }]>;
 }

package/accordion/src/accordion-header.directive.d.ts

@@ -1,7 +1,7 @@
-import { RdxAccordionItemDirective } from './accordion-item.directive';
 import * as i0 from "@angular/core";
 export declare class RdxAccordionHeaderDirective {
-    protected readonly item: RdxAccordionItemDirective;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[rdxAccordionHeader]", never, {}, {}, never, never, true, never>;
 }

package/accordion/src/accordion-item.directive.d.ts

@@ -1,91 +1,32 @@
-import { FocusableOption } from '@angular/cdk/a11y';
-import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
-import { RdxAccordionContentDirective } from './accordion-content.directive';
-import { RdxAccordionOrientation } from './accordion-root.directive';
-import { RdxAccordionTriggerDirective } from './accordion-trigger.directive';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ElementRef, Signal } from '@angular/core';
 import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
 export type RdxAccordionItemState = 'open' | 'closed';
+export type AccordionItemContext = {
+    open: Signal<boolean>;
+    disabled: Signal<boolean>;
+    triggerId: string;
+    dataState: Signal<RdxAccordionItemState>;
+    dataDisabled: Signal<boolean>;
+    currentElement: ElementRef<HTMLElement>;
+    value: Signal<string | undefined>;
+};
+export declare const injectAccordionItemContext: (optional?: boolean) => AccordionItemContext | null, provideAccordionItemContext: (useFactory: () => AccordionItemContext) => import("@angular/core").Provider;
 /**
  * @group Components
  */
-export declare class RdxAccordionItemDirective implements FocusableOption, OnDestroy {
-    protected readonly accordion: import("./accordion-root.directive").RdxAccordionRootDirective;
-    protected readonly changeDetectorRef: ChangeDetectorRef;
-    protected readonly expansionDispatcher: UniqueSelectionDispatcher;
-    /**
-     * @ignore
-     */
-    trigger: RdxAccordionTriggerDirective;
-    /**
-     * @ignore
-     */
-    content: RdxAccordionContentDirective;
-    get dataState(): RdxAccordionItemState;
-    /**
-     * The unique AccordionItem id.
-     * @ignore
-     */
-    readonly id: string;
-    get orientation(): RdxAccordionOrientation;
-    /**
-     * @defaultValue false
-     * @group Props
-     */
-    set expanded(expanded: boolean);
-    get expanded(): boolean;
-    private _expanded;
-    /**
-     * Accordion value.
-     *
-     * @group Props
-     */
-    set value(value: string);
-    get value(): string;
-    private _value?;
-    /**
-     * Whether the AccordionItem is disabled.
-     *
-     * @defaultValue false
-     * @group Props
-     */
-    set disabled(value: boolean);
-    get disabled(): boolean;
-    private _disabled;
-    /**
-     * Event emitted every time the AccordionItem is closed.
-     */
-    readonly closed: EventEmitter<void>;
-    /** Event emitted every time the AccordionItem is opened. */
-    readonly opened: EventEmitter<void>;
-    /**
-     * Event emitted when the AccordionItem is destroyed.
-     * @ignore
-     */
-    readonly destroyed: EventEmitter<void>;
-    /**
-     * Emits whenever the expanded state of the accordion changes.
-     * Primarily used to facilitate two-way binding.
-     * @group Emits
-     */
-    readonly expandedChange: EventEmitter<boolean>;
-    /** Unregister function for expansionDispatcher. */
-    private removeUniqueSelectionListener;
-    /** Subscription to openAll/closeAll events. */
-    private openCloseAllSubscription;
+export declare class RdxAccordionItemDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly collapsibleContext;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    readonly value: import("@angular/core").InputSignal<string | undefined>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly isDisabled: Signal<boolean>;
+    readonly open: Signal<boolean>;
+    readonly dataState: Signal<RdxAccordionItemState>;
     constructor();
-    /** Emits an event for the accordion item being destroyed. */
-    ngOnDestroy(): void;
-    focus(): void;
-    /** Toggles the expanded state of the accordion item. */
-    toggle(): void;
-    /** Sets the expanded state of the accordion item to false. */
-    close(): void;
-    /** Sets the expanded state of the accordion item to true. */
-    open(): void;
-    private subscribeToOpenCloseAllActions;
+    handleArrowKey(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[rdxAccordionItem]", ["rdxAccordionItem"], { "expanded": { "alias": "expanded"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "closed": "closed"; "opened": "opened"; "expandedChange": "expandedChange"; }, ["trigger", "content"], never, true, never>;
-    static ngAcceptInputType_expanded: unknown;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[rdxAccordionItem]", ["rdxAccordionItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleRootDirective; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
 }

package/accordion/src/accordion-root.directive.d.ts

@@ -1,112 +1,58 @@
-import { FocusKeyManager } from '@angular/cdk/a11y';
-import { Directionality } from '@angular/cdk/bidi';
-import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { AfterContentInit, EventEmitter, InjectionToken, OnDestroy, QueryList } from '@angular/core';
-import { Subject } from 'rxjs';
-import { RdxAccordionItemDirective } from './accordion-item.directive';
+import { Direction } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ElementRef, InputSignal, InputSignalWithTransform, ModelSignal, Signal } from '@angular/core';
+import { DataOrientation } from '@radix-ng/primitives/core';
 import * as i0 from "@angular/core";
-export type RdxAccordionType = 'single' | 'multiple';
-export type RdxAccordionOrientation = 'horizontal' | 'vertical';
-export declare const RdxAccordionRootToken: InjectionToken<RdxAccordionRootDirective>;
+export type AccordionRootContext = {
+    disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    direction: InputSignal<Direction>;
+    orientation: InputSignal<DataOrientation>;
+    value: ModelSignal<string | string[] | undefined>;
+    collapsible: Signal<boolean>;
+    isSingle: Signal<boolean>;
+    elementRef: ElementRef<HTMLElement>;
+    changeModelValue: (value: string, isOpen: boolean) => void;
+    isItemOpen: (value: string) => boolean;
+};
+export declare const injectAccordionRootContext: (optional?: boolean) => AccordionRootContext | null, provideAccordionRootContext: (useFactory: () => AccordionRootContext) => import("@angular/core").Provider;
 /**
  * @group Components
  */
-export declare class RdxAccordionRootDirective implements AfterContentInit, OnDestroy {
-    /**
-     * @ignore
-     */
-    protected readonly selectionDispatcher: UniqueSelectionDispatcher;
-    /**
-     * @ignore
-     */
-    protected readonly dir: Directionality | null;
-    /**
-     * @ignore
-     */
-    protected keyManager: FocusKeyManager<RdxAccordionItemDirective>;
-    /**
-     * @ignore
-     */
-    readonly id: string;
-    /**
-     * @ignore
-     */
-    readonly openCloseAllActions: Subject<boolean>;
-    get isMultiple(): boolean;
+export declare class RdxAccordionRootDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly id: InputSignal<string>;
+    readonly dir: InputSignal<Direction>;
     /** Whether the Accordion is disabled.
      * @defaultValue false
      * @group Props
      */
-    disabled: boolean;
+    readonly disabled: InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * The orientation of the accordion.
      *
      * @defaultValue 'vertical'
      * @group Props
      */
-    orientation: RdxAccordionOrientation;
-    /**
-     * @private
-     * @ignore
-     */
-    items: QueryList<RdxAccordionItemDirective>;
-    /**
-     * The value of the item to expand when initially rendered and type is "single".
-     * Use when you do not need to control the state of the items.
-     * @group Props
-     */
-    set defaultValue(value: string[] | string);
-    get defaultValue(): string[] | string;
-    /**
-     * Determines whether one or multiple items can be opened at the same time.
-     * @group Props
-     * @defaultValue 'single'
-     */
-    type: RdxAccordionType;
-    /**
-     * @ignore
-     */
-    collapsible: boolean;
+    readonly orientation: InputSignal<DataOrientation>;
+    readonly defaultValue: InputSignal<string | string[] | undefined>;
     /**
      * The controlled value of the item to expand.
      *
      * @group Props
      */
-    set value(value: string[] | string);
-    get value(): string[] | string;
+    readonly value: ModelSignal<string | string[] | undefined>;
+    readonly collapsible: InputSignalWithTransform<boolean, BooleanInput>;
+    readonly type: InputSignal<"multiple" | "single">;
     /**
      * Event handler called when the expanded state of an item changes and type is "multiple".
      * @group Emits
      */
-    readonly onValueChange: EventEmitter<void>;
-    private _value?;
-    private _defaultValue;
-    private onValueChangeSubscription;
-    /**
-     * @ignore
-     */
-    ngAfterContentInit(): void;
-    /**
-     * @ignore
-     */
-    ngOnDestroy(): void;
-    /**
-     * @ignore
-     */
-    handleKeydown(event: KeyboardEvent): void;
-    /** Opens all enabled accordion items in an accordion where multi is enabled.
-     * @ignore
-     */
-    openAll(): void;
-    /** Closes all enabled accordion items.
-     * @ignore
-     */
-    closeAll(): void;
-    /**
-     * @ignore
-     */
-    setActiveItem(item: RdxAccordionItemDirective): void;
+    readonly onValueChange: import("@angular/core").OutputEmitterRef<void>;
+    readonly isCollapsible: Signal<boolean>;
+    readonly isSingle: Signal<boolean>;
+    constructor();
+    changeModelValue: (value: string, isOpen: boolean) => void;
+    isItemOpen: (value: string) => boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", never, { "disabled": { "alias": "disabled"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; "type": { "alias": "type"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onValueChange": "onValueChange"; }, ["items"], never, true, never>;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", ["rdxAccordionRoot"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
 }

package/accordion/src/accordion-trigger.directive.d.ts

@@ -1,15 +1,9 @@
-import { RdxAccordionItemDirective } from './accordion-item.directive';
-import { RdxAccordionRootDirective } from './accordion-root.directive';
 import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/collapsible";
 export declare class RdxAccordionTriggerDirective {
-    protected readonly nativeElement: any;
-    protected readonly accordionRoot: RdxAccordionRootDirective;
-    protected readonly item: RdxAccordionItemDirective;
-    /**
-     * Fires when trigger clicked
-     */
-    onClick(): void;
-    focus(): void;
+    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
+    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleTriggerDirective; inputs: {}; outputs: {}; }]>;
 }

package/avatar/index.d.ts

@@ -5,8 +5,8 @@ import * as i3 from "./src/avatar-image.directive";
 export * from './src/avatar-fallback.directive';
 export * from './src/avatar-image.directive';
 export * from './src/avatar-root.directive';
-export type { RdxImageLoadingStatus } from './src/avatar-root.directive';
 export * from './src/avatar.config';
+export type { RdxImageLoadingStatus } from './src/types';
 export declare class RdxCheckboxModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof i1.RdxAvatarRootDirective, typeof i2.RdxAvatarFallbackDirective, typeof i3.RdxAvatarImageDirective], [typeof i1.RdxAvatarRootDirective, typeof i2.RdxAvatarFallbackDirective, typeof i3.RdxAvatarImageDirective]>;

package/avatar/src/avatar-context.token.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken, WritableSignal } from '@angular/core';
+import { RdxImageLoadingStatus } from './types';
+export interface AvatarContextToken {
+    imageLoadingStatus: WritableSignal<RdxImageLoadingStatus>;
+}
+export declare const AVATAR_ROOT_CONTEXT: InjectionToken<AvatarContextToken>;
+export declare function injectAvatarRootContext(): AvatarContextToken;

package/avatar/src/avatar-fallback.directive.d.ts

@@ -1,12 +1,10 @@
-import { OnDestroy } from '@angular/core';
-import { RdxAvatarRootContext } from './avatar-root.directive';
 import * as i0 from "@angular/core";
 /**
  * @group Components
  */
-export declare class RdxAvatarFallbackDirective implements OnDestroy {
-    protected readonly avatarRoot: RdxAvatarRootContext;
+export declare class RdxAvatarFallbackDirective {
     private readonly config;
+    protected readonly rootContext: import("./avatar-context.token").AvatarContextToken;
     /**
      * Useful for delaying rendering so it only appears for those with slower connections.
      *
@@ -14,13 +12,9 @@ export declare class RdxAvatarFallbackDirective implements OnDestroy {
      * @defaultValue 0
      */
     readonly delayMs: import("@angular/core").InputSignal<number>;
-    readonly shouldRender: import("@angular/core").Signal<boolean>;
     protected readonly canRender: import("@angular/core").WritableSignal<boolean>;
-    private timeoutId;
+    private timeout;
     constructor();
-    private startDelayTimer;
-    private clearDelayTimer;
-    ngOnDestroy(): void;
     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>;
 }

package/avatar/src/avatar-image.directive.d.ts

@@ -1,16 +1,17 @@
-import { OnInit } from '@angular/core';
-import { RdxImageLoadingStatus } from './avatar-root.directive';
+import { OnDestroy, OnInit } from '@angular/core';
+import { HTMLAttributeReferrerPolicy, RdxImageLoadingStatus } from './types';
 import * as i0 from "@angular/core";
 /**
  * @group Components
  */
-export declare class RdxAvatarImageDirective implements OnInit {
-    private readonly avatarRoot;
-    private readonly elementRef;
+export declare class RdxAvatarImageDirective implements OnInit, OnDestroy {
+    private readonly platformId;
+    protected readonly rootContext: import("./avatar-context.token").AvatarContextToken;
     /**
      * @group Props
      */
     readonly src: import("@angular/core").InputSignal<string | undefined>;
+    readonly referrerPolicy: import("@angular/core").InputSignal<HTMLAttributeReferrerPolicy | undefined>;
     /**
      * A callback providing information about the loading status of the image.
      * This is useful in case you want to control more precisely what to render as the image is loading.
@@ -18,12 +19,11 @@ export declare class RdxAvatarImageDirective implements OnInit {
      * @group Emits
      */
     readonly onLoadingStatusChange: import("@angular/core").OutputEmitterRef<RdxImageLoadingStatus>;
-    protected readonly imageLoadingStatus: import("@angular/core").Signal<RdxImageLoadingStatus>;
+    private readonly isMounted;
+    private readonly loadingStatus;
+    constructor();
     ngOnInit(): void;
-    onLoad(): void;
-    onError(): void;
-    private setImageStatus;
-    get nativeElement(): any;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarImageDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarImageDirective, "img[rdxAvatarImage]", ["rdxAvatarImage"], { "src": { "alias": "src"; "required": false; "isSignal": true; }; }, { "onLoadingStatusChange": "onLoadingStatusChange"; }, never, never, true, 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>;
 }

package/avatar/src/avatar-root.directive.d.ts

@@ -1,11 +1,8 @@
+import { AvatarContextToken } from './avatar-context.token';
+import { RdxImageLoadingStatus } from './types';
 import * as i0 from "@angular/core";
-export type RdxImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
-export declare class RdxAvatarRootContext {
+export declare class RdxAvatarRootDirective implements AvatarContextToken {
     readonly imageLoadingStatus: import("@angular/core").WritableSignal<RdxImageLoadingStatus>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarRootContext, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RdxAvatarRootContext>;
-}
-export declare class RdxAvatarRootDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarRootDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarRootDirective, "span[rdxAvatarRoot]", ["rdxAvatarRoot"], {}, {}, never, never, true, never>;
 }

package/avatar/src/types.d.ts

@@ -0,0 +1,2 @@
+export type RdxImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
+export type HTMLAttributeReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';

package/checkbox/index.d.ts

@@ -11,6 +11,6 @@ export type { CheckboxState } from './src/checkbox.directive';
 export * from './src/checkbox.token';
 export declare class RdxCheckboxModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof i1.RdxCheckboxInputDirective, typeof i2.RdxCheckboxDirective, typeof i3.RdxCheckboxButtonDirective, typeof i4.RdxCheckboxIndicatorDirective], [typeof i1.RdxCheckboxInputDirective, typeof i2.RdxCheckboxDirective, typeof i3.RdxCheckboxButtonDirective, typeof i4.RdxCheckboxIndicatorDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof i1.RdxCheckboxInputDirective, typeof i2.RdxCheckboxRootDirective, typeof i3.RdxCheckboxButtonDirective, typeof i4.RdxCheckboxIndicatorDirective], [typeof i1.RdxCheckboxInputDirective, typeof i2.RdxCheckboxRootDirective, typeof i3.RdxCheckboxButtonDirective, typeof i4.RdxCheckboxIndicatorDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxCheckboxModule>;
 }

package/checkbox/src/checkbox-button.directive.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from "@angular/core";
 export declare class RdxCheckboxButtonDirective {
-    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxDirective;
+    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxRootDirective;
     readonly id: import("@angular/core").InputSignal<string | null>;
     protected readonly elementId: import("@angular/core").Signal<string | null>;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxButtonDirective, never>;

package/checkbox/src/checkbox-indicator.directive.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from "@angular/core";
 export declare class RdxCheckboxIndicatorDirective {
-    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxDirective;
+    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxRootDirective;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxIndicatorDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCheckboxIndicatorDirective, "[rdxCheckboxIndicator]", never, {}, {}, never, never, true, never>;
 }

package/checkbox/src/checkbox-input.directive.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@radix-ng/primitives/visually-hidden";
 export declare class RdxCheckboxInputDirective {
-    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxDirective;
+    protected readonly checkbox: import("@radix-ng/primitives/checkbox").RdxCheckboxRootDirective;
     readonly id: import("@angular/core").InputSignal<string | undefined>;
     protected readonly elementId: import("@angular/core").Signal<string | undefined>;
     protected readonly value: import("@angular/core").Signal<"" | "on" | "off">;

package/checkbox/src/checkbox.directive.d.ts

@@ -5,7 +5,7 @@ export type CheckboxState = 'unchecked' | 'checked' | 'indeterminate';
 /**
  * @group Components
  */
-export declare class RdxCheckboxDirective implements ControlValueAccessor, OnChanges {
+export declare class RdxCheckboxRootDirective implements ControlValueAccessor, OnChanges {
     /**
      * The controlled checked state of the checkbox. Must be used in conjunction with onCheckedChange.
      * @group Props
@@ -77,8 +77,8 @@ export declare class RdxCheckboxDirective implements ControlValueAccessor, OnCha
      * @internal
      */
     setDisabledState(isDisabled: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCheckboxDirective, "[rdxCheckboxRoot]", never, { "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; }, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCheckboxRootDirective, "[rdxCheckboxRoot]", never, { "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; }, never, never, true, never>;
     static ngAcceptInputType_checked: unknown;
     static ngAcceptInputType_indeterminate: unknown;
     static ngAcceptInputType_disabled: unknown;

package/checkbox/src/checkbox.token.d.ts

@@ -1,4 +1,4 @@
 import { InjectionToken } from '@angular/core';
-import type { RdxCheckboxDirective } from './checkbox.directive';
-export declare const RdxCheckboxToken: InjectionToken<RdxCheckboxDirective>;
-export declare function injectCheckbox(): RdxCheckboxDirective;
+import type { RdxCheckboxRootDirective } from './checkbox.directive';
+export declare const RdxCheckboxToken: InjectionToken<RdxCheckboxRootDirective>;
+export declare function injectCheckbox(): RdxCheckboxRootDirective;

package/collapsible/index.d.ts

@@ -1,3 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./src/collapsible-content.directive";
+import * as i2 from "./src/collapsible-root.directive";
+import * as i3 from "./src/collapsible-trigger.directive";
+import * as i4 from "./src/collapsible-content-presence.directive";
+export * from './src/collapsible-content-presence.directive';
 export * from './src/collapsible-content.directive';
 export * from './src/collapsible-root.directive';
 export * from './src/collapsible-trigger.directive';
+export declare class RdxCollapsibleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCollapsibleModule, never, [typeof i1.RdxCollapsibleContentDirective, typeof i2.RdxCollapsibleRootDirective, typeof i3.RdxCollapsibleTriggerDirective, typeof i4.RdxCollapsibleContentPresenceDirective], [typeof i1.RdxCollapsibleContentDirective, typeof i2.RdxCollapsibleRootDirective, typeof i3.RdxCollapsibleTriggerDirective, typeof i4.RdxCollapsibleContentPresenceDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCollapsibleModule>;
+}

package/collapsible/src/collapsible-content-presence.directive.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@radix-ng/primitives/presence";
+export declare class RdxCollapsibleContentPresenceDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleContentPresenceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleContentPresenceDirective, "ng-template[rdxCollapsibleContentPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
+}

package/collapsible/src/collapsible-content.directive.d.ts

@@ -1,14 +1,15 @@
-import { ElementRef } from '@angular/core';
-import { RdxCollapsibleRootDirective } from './collapsible-root.directive';
 import * as i0 from "@angular/core";
 export declare class RdxCollapsibleContentDirective {
-    protected readonly collapsible: RdxCollapsibleRootDirective;
-    /**
-     * Reference to CollapsibleContent host element
-     * @ignore
-     */
-    readonly elementRef: ElementRef<HTMLElement>;
-    getDisabled(): string | undefined;
+    private readonly elementRef;
+    protected readonly rootContext: import("./collapsible-root.directive").CollapsibleRootContext;
+    readonly isOpen: import("@angular/core").Signal<boolean>;
+    readonly height: import("@angular/core").WritableSignal<number>;
+    readonly width: import("@angular/core").WritableSignal<number>;
+    readonly isMountAnimationPrevented: import("@angular/core").WritableSignal<boolean>;
+    private originalStyles;
+    protected readonly hiddenSignal: import("@angular/core").WritableSignal<boolean>;
+    constructor();
+    onAnimationEnd(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxCollapsibleContentDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxCollapsibleContentDirective, "[rdxCollapsibleContent]", never, {}, {}, never, never, true, never>;
 }