@radix-ng/primitives 0.43.0 → 0.44.0

package/accordion/index.d.ts

@@ -1,18 +1,163 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/accordion-content.directive";
-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';
-export * from './src/accordion-root.directive';
-export * from './src/accordion-trigger.directive';
-export declare class RdxAccordionModule {
+import * as i0 from '@angular/core';
+import { InputSignalWithTransform, InputSignal, ModelSignal, Signal, ElementRef } from '@angular/core';
+import { Direction } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { DataOrientation } from '@radix-ng/primitives/core';
+import * as i1 from '@radix-ng/primitives/collapsible';
+
+type AcceptableValue = string | Record<string, any> | null;
+type AccordionRootContext = {
+    disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    direction: InputSignal<Direction>;
+    orientation: InputSignal<DataOrientation>;
+    value: ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+    collapsible: Signal<boolean>;
+    isSingle: Signal<boolean>;
+    elementRef: ElementRef<HTMLElement>;
+    changeModelValue: (value: string) => void;
+};
+declare const injectAccordionRootContext: (optional?: boolean) => AccordionRootContext | null;
+declare const provideAccordionRootContext: (useFactory: () => AccordionRootContext) => i0.Provider;
+/**
+ * @group Components
+ */
+declare class RdxAccordionRootDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly id: InputSignal<string>;
+    /**
+     * The reading direction of the accordion when applicable. If omitted, assumes LTR (left-to-right) reading mode.
+     *
+     * @group Props
+     */
+    readonly dir: InputSignal<Direction>;
+    /** Whether the Accordion is disabled.
+     * @defaultValue false
+     * @group Props
+     */
+    readonly disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The orientation of the accordion.
+     *
+     * @defaultValue 'vertical'
+     * @group Props
+     */
+    readonly orientation: InputSignal<DataOrientation>;
+    /**
+     * The default active value of the item(s).
+     *
+     * Use when you do not need to control the state of the item(s).
+     * @group Props
+     */
+    readonly defaultValue: InputSignal<string | string[] | undefined>;
+    /**
+     * The controlled value of the item to expand.
+     *
+     * @group Props
+     */
+    readonly value: ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+    /**
+     * When type is "single", allows closing content when clicking trigger for an open item.
+     * When type is "multiple", this prop has no effect.
+     *
+     * @defaultValue false
+     * @group Props
+     */
+    readonly collapsible: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Determines whether a "single" or "multiple" items can be selected at a time.
+     *
+     * @defaultValue 'single'
+     * @group Props
+     */
+    readonly type: InputSignal<"multiple" | "single">;
+    /**
+     * Event handler called when the expanded state of an item changes and type is "multiple".
+     * @group Emits
+     */
+    readonly onValueChange: i0.OutputEmitterRef<void>;
+    readonly isSingle: Signal<boolean>;
+    constructor();
+    changeModelValue: (newValue: string) => void;
+    private isValueEqualOrExist;
+    private isEqual;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionRootDirective, never>;
+    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>;
+}
+
+type RdxAccordionItemState = 'open' | 'closed';
+type AccordionItemContext = {
+    open: Signal<boolean>;
+    disabled: Signal<boolean>;
+    triggerId: string;
+    dataState: Signal<RdxAccordionItemState>;
+    dataDisabled: Signal<boolean>;
+    currentElement: ElementRef<HTMLElement>;
+    value: Signal<string | undefined>;
+    updateOpen: () => void;
+};
+declare const injectAccordionItemContext: (optional?: boolean) => AccordionItemContext | null;
+declare const provideAccordionItemContext: (useFactory: () => AccordionItemContext) => i0.Provider;
+/**
+ * @group Components
+ */
+declare class RdxAccordionItemDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly collapsibleContext;
+    protected readonly rootContext: AccordionRootContext;
+    /**
+     * A string value for the accordion item. All items within an accordion should use a unique value.
+     * @group Props
+     */
+    readonly value: i0.InputSignal<string | undefined>;
+    /**
+     * Whether or not an accordion item is disabled from user interaction.
+     * When `true`, prevents the user from interacting with the item.
+     * @group Props
+     */
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly isDisabled: Signal<boolean>;
+    readonly open: Signal<any>;
+    readonly dataState: Signal<RdxAccordionItemState>;
+    constructor();
+    updateOpen: () => void;
+    handleArrowKey(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionItemDirective, never>;
+    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"; "open": "open"; }; outputs: {}; }]>;
+}
+
+declare class RdxAccordionContentDirective {
+    protected readonly rootContext: AccordionRootContext;
+    protected readonly itemContext: AccordionItemContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxAccordionHeaderDirective {
+    protected readonly rootContext: AccordionRootContext;
+    protected readonly itemContext: AccordionItemContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[rdxAccordionHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxAccordionTriggerDirective {
+    protected readonly rootContext: AccordionRootContext;
+    protected readonly itemContext: AccordionItemContext;
+    constructor();
+    changeItem(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleTriggerDirective; inputs: {}; outputs: {}; }]>;
+}
+
+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: {}; }]>;
+}
+
+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 i6.RdxAccordionContentPresenceDirective], [typeof i1.RdxAccordionContentDirective, typeof i2.RdxAccordionHeaderDirective, typeof i3.RdxAccordionItemDirective, typeof i4.RdxAccordionRootDirective, typeof i5.RdxAccordionTriggerDirective, typeof i6.RdxAccordionContentPresenceDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof RdxAccordionContentDirective, typeof RdxAccordionHeaderDirective, typeof RdxAccordionItemDirective, typeof RdxAccordionRootDirective, typeof RdxAccordionTriggerDirective, typeof RdxAccordionContentPresenceDirective], [typeof RdxAccordionContentDirective, typeof RdxAccordionHeaderDirective, typeof RdxAccordionItemDirective, typeof RdxAccordionRootDirective, typeof RdxAccordionTriggerDirective, typeof RdxAccordionContentPresenceDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxAccordionModule>;
 }
+
+export { RdxAccordionContentDirective, RdxAccordionContentPresenceDirective, RdxAccordionHeaderDirective, RdxAccordionItemDirective, RdxAccordionModule, RdxAccordionRootDirective, RdxAccordionTriggerDirective, injectAccordionItemContext, injectAccordionRootContext, provideAccordionItemContext, provideAccordionRootContext };
+export type { AccordionItemContext, AccordionRootContext, RdxAccordionItemState };

package/alert-dialog/index.d.ts

@@ -1,17 +1,57 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/alert-dialog-root.directive";
-import * as i2 from "./src/alert-dialog-content.directive";
-import * as i3 from "./src/alert-dialog-cancel.directive";
-import * as i4 from "./src/alert-dialog-trigger.directive";
-import * as i5 from "./src/alert-dialog-title.directive";
-export * from './src/alert-dialog-cancel.directive';
-export * from './src/alert-dialog-content.directive';
-export * from './src/alert-dialog-root.directive';
-export * from './src/alert-dialog-title.directive';
-export * from './src/alert-dialog-trigger.directive';
-export * from './src/alert-dialog.service';
-export declare class RdxAlertDialogModule {
+import * as i0 from '@angular/core';
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i1 from '@angular/cdk/a11y';
+
+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>;
+}
+
+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: {}; }]>;
+}
+
+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>;
+}
+
+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>;
+}
+
+declare class RdxAlertDialogTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTitleDirective, "[rdxAlertDialogTitle]", never, {}, {}, never, never, true, never>;
+}
+
+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>;
+}
+
+declare class RdxAlertDialogModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAlertDialogModule, never, [typeof i1.RdxAlertDialogRootDirective, typeof i2.RdxAlertDialogContentDirective, typeof i3.RdxAlertDialogCancelDirective, typeof i4.RdxAlertDialogTriggerDirective, typeof i5.RdxAlertDialogTitleDirective], [typeof i1.RdxAlertDialogRootDirective, typeof i2.RdxAlertDialogContentDirective, typeof i3.RdxAlertDialogCancelDirective, typeof i4.RdxAlertDialogTriggerDirective, typeof i5.RdxAlertDialogTitleDirective]>;
+    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 ɵinj: i0.ɵɵInjectorDeclaration<RdxAlertDialogModule>;
 }
+
+export { RdxAlertDialogCancelDirective, RdxAlertDialogContentDirective, RdxAlertDialogModule, RdxAlertDialogRootDirective, RdxAlertDialogService, RdxAlertDialogTitleDirective, RdxAlertDialogTriggerDirective };

package/arrow/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/arrow

package/arrow/index.d.ts

@@ -0,0 +1,11 @@
+import * as _angular_core from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+
+declare class RdxArrow {
+    readonly width: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly height: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxArrow, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxArrow, "rdx-arrow", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { RdxArrow };

package/aspect-ratio/index.d.ts

@@ -1 +1,35 @@
-export * from './src/aspect-ratio.directive';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit } from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+
+/**
+ * Directive to maintain an aspect ratio for an element.
+ * The element will have its `padding-bottom` dynamically calculated
+ * based on the provided aspect ratio to maintain the desired ratio.
+ * The content inside the element will be positioned absolutely.
+ * @group Components
+ */
+declare class RdxAspectRatioDirective implements AfterViewInit {
+    private readonly element;
+    private readonly renderer;
+    /**
+     * The desired aspect ratio (e.g., 16/9).
+     * By default, it is set to 1 (which results in a square, 1:1).
+     * @group Props
+     * @defaultValue 1
+     */
+    readonly ratio: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Dynamically computed `padding-bottom` style for the element.
+     * This value is calculated based on the inverse of the aspect ratio.
+     *
+     * If the ratio is zero, it defaults to `0%` to avoid division by zero.
+     *
+     */
+    protected readonly paddingBottom: _angular_core.Signal<string>;
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxAspectRatioDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxAspectRatioDirective, "[rdxAspectRatio]", ["rdxAspectRatio"], { "ratio": { "alias": "ratio"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { RdxAspectRatioDirective };

package/avatar/index.d.ts

@@ -1,14 +1,84 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/avatar-root.directive";
-import * as i2 from "./src/avatar-fallback.directive";
-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 * from './src/avatar.config';
-export type { RdxImageLoadingStatus } from './src/types';
-export declare class RdxCheckboxModule {
+import * as i0 from '@angular/core';
+import { WritableSignal, OnInit, OnDestroy, 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';
+
+interface AvatarContextToken {
+    imageLoadingStatus: WritableSignal<RdxImageLoadingStatus>;
+}
+
+declare class RdxAvatarRootDirective implements AvatarContextToken {
+    readonly imageLoadingStatus: i0.WritableSignal<RdxImageLoadingStatus>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarRootDirective, "span[rdxAvatarRoot]", ["rdxAvatarRoot"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * @group Components
+ */
+declare class RdxAvatarFallbackDirective {
+    private readonly config;
+    protected readonly rootContext: AvatarContextToken;
+    /**
+     * Useful for delaying rendering so it only appears for those with slower connections.
+     *
+     * @group Props
+     * @defaultValue 0
+     */
+    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>;
+}
+
+/**
+ * @group Components
+ */
+declare class RdxAvatarImageDirective implements OnInit, OnDestroy {
+    private readonly platformId;
+    protected readonly rootContext: AvatarContextToken;
+    /**
+     * @group Props
+     */
+    readonly src: i0.InputSignal<string | undefined>;
+    readonly referrerPolicy: i0.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.
+     *
+     * @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>;
+}
+
+interface RdxAvatarConfig {
+    /**
+     * Define a delay before the fallback is shown.
+     * This is useful to only show the fallback for those with slower connections.
+     * @default 0
+     */
+    delayMs: number;
+}
+declare const defaultAvatarConfig: RdxAvatarConfig;
+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 i1.RdxAvatarRootDirective, typeof i2.RdxAvatarFallbackDirective, typeof i3.RdxAvatarImageDirective], [typeof i1.RdxAvatarRootDirective, typeof i2.RdxAvatarFallbackDirective, typeof i3.RdxAvatarImageDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective], [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxCheckboxModule>;
 }
+
+export { RdxAvatarConfigToken, RdxAvatarFallbackDirective, RdxAvatarImageDirective, RdxAvatarRootDirective, RdxCheckboxModule, defaultAvatarConfig, injectAvatarConfig, provideRdxAvatarConfig };
+export type { RdxAvatarConfig, RdxImageLoadingStatus };