@radix-ng/primitives 0.43.0 → 0.44.0

package/cropper/index.d.ts

@@ -1,15 +1,135 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/cropper-root.directive";
-import * as i2 from "./src/cropper-image.component";
-import * as i3 from "./src/cropper-crop-area.directive";
-import * as i4 from "./src/cropper-description.directive";
-export * from './src/cropper-context.token';
-export * from './src/cropper-crop-area.directive';
-export * from './src/cropper-description.directive';
-export * from './src/cropper-image.component';
-export * from './src/cropper-root.directive';
-export declare class RdxCropperModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCropperModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCropperModule, never, [typeof i1.RdxCropperRootDirective, typeof i2.RdxCropperImageComponent, typeof i3.RdxCropperCropAreaDirective, typeof i4.RdxCropperDescriptionDirective], [typeof i1.RdxCropperRootDirective, typeof i2.RdxCropperImageComponent, typeof i3.RdxCropperCropAreaDirective, typeof i4.RdxCropperDescriptionDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCropperModule>;
+import * as _angular_core from '@angular/core';
+import { InputSignal, WritableSignal, InjectionToken } from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+
+interface CropperContextToken {
+    image: InputSignal<string>;
+    getImageProps: () => {
+        [key: string]: any;
+    };
+    getImageWrapperStyle: () => Record<string, string>;
+    getCropAreaStyle: () => Record<string, string>;
+    descriptionId: WritableSignal<string>;
 }
+declare const CROPPER_ROOT_CONTEXT: InjectionToken<CropperContextToken>;
+declare function injectCropperRootContext(): CropperContextToken;
+
+type Area = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+declare class RdxCropperRootDirective implements CropperContextToken {
+    private readonly elementRef;
+    private readonly CROPPER_DESC_WARN_MESSAGE;
+    readonly image: _angular_core.InputSignal<string>;
+    readonly cropPadding: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly aspectRatio: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly minZoom: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly maxZoom: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly zoomSensitivity: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly keyboardStep: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly zoom: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    readonly onCropChange: _angular_core.OutputEmitterRef<Area | null>;
+    readonly onZoomChange: _angular_core.OutputEmitterRef<number>;
+    private readonly imgWidth;
+    private readonly imgHeight;
+    private readonly cropAreaWidth;
+    private readonly cropAreaHeight;
+    private readonly imageWrapperWidth;
+    private readonly imageWrapperHeight;
+    private readonly offsetX;
+    private readonly offsetY;
+    private readonly internalZoom;
+    private readonly isDragging;
+    readonly descriptionId: _angular_core.WritableSignal<string>;
+    private readonly isZoomControlled;
+    protected readonly effectiveZoom: _angular_core.Signal<number>;
+    protected readonly zoomValueText: _angular_core.Signal<string>;
+    private readonly dragStartPoint;
+    private readonly dragStartOffset;
+    private readonly latestRestrictedOffset;
+    private readonly latestZoom;
+    private readonly isInitialSetupDone;
+    private readonly initialPinchDistance;
+    private readonly initialPinchZoom;
+    private readonly isPinching;
+    private readonly hasWarned;
+    constructor();
+    private updateZoom;
+    private initializeContainerDimensions;
+    private setupImageLoadEffect;
+    private setupDimensionsEffects;
+    private restrictOffset;
+    private calculateCropData;
+    private setupCropCalculationEffect;
+    private setupAccessibilityWarningEffect;
+    private setupEventListenersEffect;
+    private handleInteractionEnd;
+    /**
+     * @ignore
+     */
+    onMouseDown(e: MouseEvent): void;
+    private handleWheel;
+    private getPinchDistance;
+    private getPinchCenter;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    /**
+     * @ignore
+     */
+    onKeyDown(e: KeyboardEvent): void;
+    /**
+     * @ignore
+     */
+    onKeyUp(e: KeyboardEvent): void;
+    /**
+     * @ignore
+     */
+    getImageProps(): {
+        [key: string]: any;
+    };
+    /**
+     * @ignore
+     */
+    getImageWrapperStyle(): Record<string, string>;
+    /**
+     * @ignore
+     */
+    getCropAreaStyle(): Record<string, string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCropperRootDirective, "[rdxCropperRoot]", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "cropPadding": { "alias": "cropPadding"; "required": false; "isSignal": true; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "zoomSensitivity": { "alias": "zoomSensitivity"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; }, { "onCropChange": "onCropChange"; "onZoomChange": "onZoomChange"; }, never, never, true, never>;
+}
+
+declare class RdxCropperImageComponent {
+    protected readonly rootContext: CropperContextToken;
+    readonly imgClass: _angular_core.InputSignal<string | undefined>;
+    readonly imgStyles: _angular_core.InputSignal<string | undefined>;
+    protected readonly imgClasses: _angular_core.Signal<string | undefined>;
+    protected readonly imgStyless: _angular_core.Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperImageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxCropperImageComponent, "[rdxCropperImage]", never, { "imgClass": { "alias": "imgClass"; "required": false; "isSignal": true; }; "imgStyles": { "alias": "imgStyles"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxCropperCropAreaDirective {
+    readonly rootContext: CropperContextToken;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperCropAreaDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCropperCropAreaDirective, "[rdxCropperCropArea]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCropperDescriptionDirective {
+    readonly rootContext: CropperContextToken;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCropperDescriptionDirective, "[rdxCropperDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxCropperModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxCropperModule, never, [typeof RdxCropperRootDirective, typeof RdxCropperImageComponent, typeof RdxCropperCropAreaDirective, typeof RdxCropperDescriptionDirective], [typeof RdxCropperRootDirective, typeof RdxCropperImageComponent, typeof RdxCropperCropAreaDirective, typeof RdxCropperDescriptionDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxCropperModule>;
+}
+
+export { CROPPER_ROOT_CONTEXT, RdxCropperCropAreaDirective, RdxCropperDescriptionDirective, RdxCropperImageComponent, RdxCropperModule, RdxCropperRootDirective, injectCropperRootContext };
+export type { Area, CropperContextToken };

package/date-field/index.d.ts

@@ -1,11 +1,210 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/date-field-root.directive";
-import * as i2 from "./src/date-field-input.directive";
-export * from './src/date-field-context.token';
-export * from './src/date-field-input.directive';
-export * from './src/date-field-root.directive';
-export declare class RdxDateFieldModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDateFieldModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxDateFieldModule, never, [typeof i1.RdxDateFieldRootDirective, typeof i2.RdxDateFieldInputDirective], [typeof i1.RdxDateFieldRootDirective, typeof i2.RdxDateFieldInputDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxDateFieldModule>;
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, InputSignal, ModelSignal, Signal, WritableSignal, InjectionToken } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { DateMatcher, HourCycle, Granularity, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
+import { Direction } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { DateValue } from '@internationalized/date';
+
+declare class RdxDateFieldRootDirective implements OnInit, AfterViewInit {
+    private readonly elementRef;
+    /**
+     * The controlled checked state of the calendar.
+     */
+    readonly value: _angular_core.ModelSignal<DateValue | undefined>;
+    /**
+     * A callback fired when the date field's value is invalid.
+     */
+    readonly isDateUnavailable: _angular_core.InputSignal<DateMatcher | undefined>;
+    /**
+     * The hour cycle to use for formatting times. Defaults to the locale preference
+     */
+    readonly hourCycle: _angular_core.InputSignal<HourCycle>;
+    /**
+     * The granularity to use for formatting the field. Defaults to 'day' if a CalendarDate is provided, otherwise defaults to 'minute'.
+     * The field will render segments for each part of the date up to and including the specified granularity.
+     */
+    readonly granularity: _angular_core.InputSignal<Granularity | undefined>;
+    /**
+     * The locale to use for formatting dates.
+     */
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly dir: _angular_core.InputSignal<Direction>;
+    /**
+     * The minimum valid date that can be entered.
+     */
+    readonly minValue: _angular_core.InputSignal<DateValue | undefined>;
+    /**
+     * The maximum valid date that can be entered.
+     */
+    readonly maxValue: _angular_core.InputSignal<DateValue | undefined>;
+    /**
+     * Whether or not to hide the time zone segment of the field.
+     */
+    readonly hideTimeZone: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether or not the field is readonly.
+     */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The stepping interval for the time fields. Defaults to 1
+     */
+    readonly step: _angular_core.InputSignal<DateStep | undefined>;
+    readonly step$: _angular_core.Signal<DateStep>;
+    /**
+     * @ignore
+     */
+    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
+     */
+    readonly placeholder: _angular_core.ModelSignal<DateValue | undefined>;
+    /**
+     * @ignore
+     */
+    readonly segmentElements: _angular_core.WritableSignal<Set<HTMLElement>>;
+    /**
+     * @ignore
+     */
+    readonly currentFocusedElement: _angular_core.WritableSignal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    formatter: Formatter;
+    /**
+     * @ignore
+     */
+    readonly segmentValues: _angular_core.WritableSignal<SegmentValueObj>;
+    /**
+     * @ignore
+     */
+    readonly inferredGranularity: _angular_core.Signal<Granularity | undefined>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly allSegmentContent: _angular_core.Signal<{
+        obj: _radix_ng_primitives_core.SegmentContentObj;
+        arr: {
+            part: _radix_ng_primitives_core.SegmentPart;
+            value: string;
+        }[];
+    }>;
+    /**
+     * An array of segments that should be readonly, which prevent user input on them.
+     */
+    readonly segmentContents: _angular_core.Signal<{
+        part: _radix_ng_primitives_core.SegmentPart;
+        value: string;
+    }[]>;
+    /**
+     * @ignore
+     */
+    readonly currentSegmentIndex: _angular_core.Signal<number>;
+    /**
+     * @ignore
+     */
+    readonly prevFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly nextFocusableSegment: _angular_core.Signal<HTMLElement | null>;
+    /**
+     * @ignore
+     */
+    readonly focusNext: () => void;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * @ignore
+     */
+    setFocusedElement(el: HTMLElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDateFieldRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDateFieldRootDirective, "[rdxDateFieldRoot]", ["rdxDateFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "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>;
 }
+
+declare class RdxDateFieldInputDirective {
+    private readonly elementRef;
+    private readonly rootContext;
+    /**
+     * The part of the date to render
+     * `'day' | 'month' | 'year' | 'hour' | 'minute' | 'second' | 'dayPeriod' | 'literal' | 'timeZoneName'`
+     */
+    readonly part: _angular_core.InputSignal<SegmentPart | undefined>;
+    /**
+     * @ignore
+     */
+    readonly disabled: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly readonly: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly isInvalid: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly hasLeftFocus: _angular_core.WritableSignal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly lastKeyZero: _angular_core.WritableSignal<boolean>;
+    private readonly fieldData;
+    private readonly attributes;
+    /**
+     * @ignore
+     */
+    handleSegmentClick: (e: MouseEvent) => void;
+    /**
+     * @ignore
+     */
+    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    constructor();
+    /**
+     * @ignore
+     */
+    onFocus(e: FocusEvent): void;
+    /**
+     * @ignore
+     */
+    onFocusOut(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDateFieldInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDateFieldInputDirective, "[rdxDateFieldInput]", never, { "part": { "alias": "part"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DateFieldContextToken {
+    locale: InputSignal<string>;
+    value: ModelSignal<DateValue | undefined>;
+    disabled: InputSignal<boolean>;
+    readonly: InputSignal<boolean>;
+    isInvalid: Signal<boolean>;
+    placeholder: ModelSignal<DateValue>;
+    hourCycle: InputSignal<HourCycle>;
+    step$: Signal<DateStep>;
+    formatter: Formatter;
+    segmentValues: WritableSignal<SegmentValueObj>;
+    focusNext: () => void;
+    setFocusedElement: (el: HTMLElement) => void;
+}
+declare const DATE_FIELDS_ROOT_CONTEXT: InjectionToken<DateFieldContextToken>;
+declare function injectDateFieldsRootContext(): DateFieldContextToken;
+
+declare class RdxDateFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDateFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxDateFieldModule, never, [typeof RdxDateFieldRootDirective, typeof RdxDateFieldInputDirective], [typeof RdxDateFieldRootDirective, typeof RdxDateFieldInputDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxDateFieldModule>;
+}
+
+export { DATE_FIELDS_ROOT_CONTEXT, RdxDateFieldInputDirective, RdxDateFieldModule, RdxDateFieldRootDirective, injectDateFieldsRootContext };
+export type { DateFieldContextToken };

package/dialog/index.d.ts

@@ -1,23 +1,205 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/dialog-trigger.directive";
-import * as i2 from "./src/dialog-content.directive";
-import * as i3 from "./src/dialog-title.directive";
-import * as i4 from "./src/dialog-close.directive";
-import * as i5 from "./src/dialog-description.directive";
-import * as i6 from "./src/dialog-dismiss.directive";
-export * from './src/dialog-close.directive';
-export * from './src/dialog-content.directive';
-export * from './src/dialog-description.directive';
-export * from './src/dialog-dismiss.directive';
-export * from './src/dialog-ref';
-export * from './src/dialog-title.directive';
-export * from './src/dialog-trigger.directive';
-export * from './src/dialog.config';
-export * from './src/dialog.injectors';
-export * from './src/dialog.providers';
-export * from './src/dialog.service';
-export declare class RdxDialogModule {
+import * as i0 from '@angular/core';
+import { TemplateRef, EnvironmentProviders, Provider } from '@angular/core';
+import { AutoFocusTarget, DialogConfig, DialogRef } from '@angular/cdk/dialog';
+import { ComponentType } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+
+declare const ɵdialogData: unique symbol;
+declare const ɵdialogResult: unique symbol;
+type ɵDialogDataFlag = {
+    [ɵdialogData]: unknown;
+};
+type ɵDialogResultFlag<R> = {
+    [ɵdialogResult]: R;
+};
+type RdxDialogData<T> = {
+    [K in keyof T]: T[K] extends ɵDialogDataFlag ? Omit<T[K], typeof ɵdialogData> : never;
+}[keyof T];
+type DialogRefProps<C> = {
+    [K in keyof C]: C[K] extends ɵDialogResultFlag<unknown> ? K : never;
+}[keyof C] & keyof C;
+type RdxDialogResult<C> = DialogRefProps<C> extends never ? void : C[DialogRefProps<C>] extends ɵDialogResultFlag<infer T> ? T : void;
+type RdxDialogMode = 'default' | 'sheet' | 'sheet-bottom' | 'sheet-top' | 'sheet-left' | 'sheet-right';
+type RdxBaseDialogConfig<C> = {
+    content: ComponentType<C> | TemplateRef<C>;
+    data: RdxDialogData<C>;
+    modal?: boolean;
+    ariaLabel?: string;
+    autoFocus?: AutoFocusTarget | 'first-input' | string;
+    canClose?: (comp: C) => boolean | Observable<boolean>;
+    canCloseWithBackdrop?: boolean;
+    closeDelay?: number;
+    cdkConfigOverride?: Partial<DialogConfig<C>>;
+    mode?: RdxDialogMode;
+    backdropClass?: string | string[];
+    panelClasses?: string[];
+    isAlert?: boolean;
+};
+type RdxDialogConfig<T> = RdxDialogData<T> extends never ? Omit<RdxBaseDialogConfig<T>, 'data'> : RdxBaseDialogConfig<T> & {
+    data: Required<RdxDialogData<T>>;
+};
+type RdxDialogState = 'open' | 'closed';
+declare function getState(open: boolean): RdxDialogState;
+
+/**
+ * @group Components
+ */
+declare class RdxDialogTriggerDirective {
+    private readonly dialogService;
+    /**
+     * @group Props
+     */
+    readonly id: i0.InputSignal<string>;
+    readonly dialogId: i0.Signal<string>;
+    /**
+     * @group Props
+     */
+    dialog: TemplateRef<void>;
+    /**
+     * @group Props
+     */
+    dialogConfig: RdxDialogConfig<unknown>;
+    readonly isOpen: i0.WritableSignal<boolean>;
+    readonly state: i0.Signal<RdxDialogState>;
+    private currentDialogRef;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogTriggerDirective, "[rdxDialogTrigger]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dialog": { "alias": "rdxDialogTrigger"; "required": true; }; "dialogConfig": { "alias": "rdxDialogConfig"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxDialogContentDirective<C = unknown> {
+    private readonly dialogRef;
+    private readonly destroyRef;
+    private readonly isOpen;
+    readonly state: i0.Signal<RdxDialogState>;
+    constructor();
+    /**
+     * Closes the dialog with a specified result.
+     *
+     * @param result The result to be passed back when closing the dialog
+     */
+    close(result: RdxDialogResult<C>): void;
+    /**
+     * Dismisses the dialog without a result.
+     */
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogContentDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogContentDirective<any>, "[rdxDialogContent]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxDialogTitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogTitleDirective, "[rdxDialogTitle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxDialogCloseDirective {
+    private readonly ref;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogCloseDirective, "[rdxDialogClose]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxDialogDescriptionDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogDescriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogDescriptionDirective, "[rdxDialogDescription]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxDialogDismissDirective {
+    private readonly ref;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogDismissDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxDialogDismissDirective, "button[rdxDialogDismiss]", never, {}, {}, never, never, true, never>;
+}
+
+declare const DISMISSED_VALUE: {};
+/**
+ * Represents a reference to an open dialog.
+ * Provides methods and observables to interact with and monitor the dialog's state.
+ * @template C - The type of the dialog's content component
+ */
+declare class RdxDialogRef<C = unknown> {
+    readonly cdkRef: DialogRef<RdxDialogResult<C> | typeof DISMISSED_VALUE, C>;
+    readonly config: RdxDialogConfig<C>;
+    private _previousTimeout;
+    private readonly _openSignal;
+    readonly state: i0.Signal<"open" | "closed">;
+    closed$: Observable<RdxDialogResult<C> | undefined>;
+    dismissed$: Observable<void>;
+    result$: Observable<RdxDialogResult<C>>;
+    /**
+     * @param cdkRef - Reference to the underlying CDK dialog
+     * @param config - Configuration options for the dialog
+     */
+    constructor(cdkRef: DialogRef<RdxDialogResult<C> | typeof DISMISSED_VALUE, C>, config: RdxDialogConfig<C>);
+    get instance(): C | null;
+    /**
+     * Attempts to dismiss the dialog
+     * Checks the canClose condition before dismissing
+     */
+    dismiss(): void;
+    close(result: RdxDialogResult<C>): void;
+}
+/**
+ * Represents a simplified interface for dialog interaction
+ * Typically used by dialog content components
+ * @template R - The type of the result when closing the dialog
+ */
+type RdxDialogSelfRef<R> = {
+    dismiss(): void;
+    close(res: R): void;
+};
+
+declare function injectDialogData<TData>(): TData & ɵDialogDataFlag;
+declare function injectDialogRef<R = void>(): RdxDialogSelfRef<R> & ɵDialogResultFlag<R>;
+
+/**
+ * Configures the RdxDialog module by providing necessary dependencies.
+ *
+ * This function sets up the environment providers required for the RdxDialog to function,
+ * specifically importing the Angular CDK's DialogModule.
+ *
+ * @returns {EnvironmentProviders} An EnvironmentProviders instance containing the DialogModule.
+ */
+declare function provideRdxDialogConfig(): EnvironmentProviders;
+/**
+ * Provides the RdxDialogService for dependency injection.
+ *
+ * This function is used to make the RdxDialogService available for injection
+ * in components, directives, or other services that require dialog functionality.
+ *
+ * @returns {Provider} A provider for the RdxDialogService.
+ */
+declare function provideRdxDialog(): Provider;
+
+/**
+ * Modality control: When `isModal` is set to `true`, the dialog will:
+ *
+ * - Have a backdrop that blocks interaction with the rest of the page
+ * - Disable closing by clicking outside or pressing Escape
+ * - Set `aria-modal="true"` for screen readers
+ * - Automatically focus the first tabbable element in the dialog
+ * - Restore focus to the element that opened the dialog when it's closed
+ *
+ *
+ * When `isModal` is `false`, the dialog will:
+ *
+ * - Not have a backdrop, allowing interaction with the rest of the page
+ * - Allow closing by clicking outside or pressing Escape
+ * - Not set `aria-modal` attribute
+ * - Not automatically manage focus
+ */
+declare class RdxDialogService {
+    #private;
+    open<C>(config: RdxDialogConfig<C>): RdxDialogRef<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdxDialogService>;
+}
+
+declare class RdxDialogModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxDialogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxDialogModule, never, [typeof i1.RdxDialogTriggerDirective, typeof i2.RdxDialogContentDirective, typeof i3.RdxDialogTitleDirective, typeof i4.RdxDialogCloseDirective, typeof i5.RdxDialogDescriptionDirective, typeof i6.RdxDialogDismissDirective], [typeof i1.RdxDialogTriggerDirective, typeof i2.RdxDialogContentDirective, typeof i3.RdxDialogTitleDirective, typeof i4.RdxDialogCloseDirective, typeof i5.RdxDialogDescriptionDirective, typeof i6.RdxDialogDismissDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxDialogModule, never, [typeof RdxDialogTriggerDirective, typeof RdxDialogContentDirective, typeof RdxDialogTitleDirective, typeof RdxDialogCloseDirective, typeof RdxDialogDescriptionDirective, typeof RdxDialogDismissDirective], [typeof RdxDialogTriggerDirective, typeof RdxDialogContentDirective, typeof RdxDialogTitleDirective, typeof RdxDialogCloseDirective, typeof RdxDialogDescriptionDirective, typeof RdxDialogDismissDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxDialogModule>;
 }
+
+export { DISMISSED_VALUE, RdxDialogCloseDirective, RdxDialogContentDirective, RdxDialogDescriptionDirective, RdxDialogDismissDirective, RdxDialogModule, RdxDialogRef, RdxDialogService, RdxDialogTitleDirective, RdxDialogTriggerDirective, getState, injectDialogData, injectDialogRef, provideRdxDialog, provideRdxDialogConfig };
+export type { RdxDialogConfig, RdxDialogData, RdxDialogResult, RdxDialogSelfRef, RdxDialogState, ɵDialogDataFlag, ɵDialogResultFlag };

package/dismissable-layer/README.md

@@ -0,0 +1 @@
+# @radix-ng/primitives/dismissable-layer