@radix-ng/primitives 0.26.0 → 0.27.0

package/hover-card/src/hover-card-content-attributes.component.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+export declare class RdxHoverCardContentAttributesComponent {
+    /** @ignore */
+    protected readonly rootDirective: import("@radix-ng/primitives/hover-card").RdxHoverCardRootDirective;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /** @ignore */
+    readonly disableAnimation: import("@angular/core").Signal<boolean>;
+    /** @ignore */
+    protected onAnimationStart(_: AnimationEvent): void;
+    /** @ignore */
+    protected onAnimationEnd(_: AnimationEvent): void;
+    /** @ignore */
+    protected pointerenter(): void;
+    /** @ignore */
+    protected pointerleave(): void;
+    /** @ignore */
+    protected focus(): void;
+    /** @ignore */
+    protected blur(): void;
+    /** @ignore */
+    private canAnimate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardContentAttributesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxHoverCardContentAttributesComponent, "[rdxHoverCardContentAttributes]", never, {}, {}, never, ["*"], true, never>;
+}

package/hover-card/src/hover-card-content-attributes.token.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { RdxHoverCardContentAttributesComponent } from './hover-card-content-attributes.component';
+export declare const RdxHoverCardContentAttributesToken: InjectionToken<RdxHoverCardContentAttributesComponent>;

package/hover-card/src/hover-card-content.directive.d.ts

@@ -0,0 +1,104 @@
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { OnInit } from '@angular/core';
+import { RdxPositionAlign, RdxPositionSide } from '@radix-ng/primitives/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export declare class RdxHoverCardContentDirective implements OnInit {
+    /** @ignore */
+    private readonly rootDirective;
+    /** @ignore */
+    private readonly templateRef;
+    /** @ignore */
+    private readonly overlay;
+    /** @ignore */
+    private readonly destroyRef;
+    /** @ignore */
+    private readonly connectedOverlay;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /**
+     * @description The preferred side of the trigger to render against when open. Will be reversed when collisions occur and avoidCollisions is enabled.
+     * @default top
+     */
+    readonly side: import("@angular/core").InputSignal<RdxPositionSide>;
+    /**
+     * @description The distance in pixels from the trigger.
+     * @default undefined
+     */
+    readonly sideOffset: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description The preferred alignment against the trigger. May change when collisions occur.
+     * @default center
+     */
+    readonly align: import("@angular/core").InputSignal<RdxPositionAlign>;
+    /**
+     * @description An offset in pixels from the "start" or "end" alignment options.
+     * @default undefined
+     */
+    readonly alignOffset: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description Whether to add some alternate positions of the content.
+     * @default false
+     */
+    readonly alternatePositionsDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @description Whether to prevent `onOverlayEscapeKeyDown` handler from calling. */
+    readonly onOverlayEscapeKeyDownDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @description Whether to prevent `onOverlayOutsideClick` handler from calling. */
+    readonly onOverlayOutsideClickDisabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @description Event handler called when the escape key is down.
+     * It can be prevented by setting `onOverlayEscapeKeyDownDisabled` input to `true`.
+     */
+    readonly onOverlayEscapeKeyDown: import("@angular/core").OutputEmitterRef<KeyboardEvent>;
+    /**
+     * @description Event handler called when a pointer event occurs outside the bounds of the component.
+     * It can be prevented by setting `onOverlayOutsideClickDisabled` input to `true`.
+     */
+    readonly onOverlayOutsideClick: import("@angular/core").OutputEmitterRef<MouseEvent>;
+    /**
+     * @description Event handler called after the overlay is open
+     */
+    readonly onOpen: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * @description Event handler called after the overlay is closed
+     */
+    readonly onClosed: import("@angular/core").OutputEmitterRef<void>;
+    /** @ingore */
+    readonly positions: import("@angular/core").Signal<import("@angular/cdk/overlay").ConnectedPosition[]>;
+    constructor();
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    open(): void;
+    /** @ignore */
+    close(): void;
+    /** @ignore */
+    positionChange(): import("rxjs").Observable<import("@angular/cdk/overlay").ConnectedOverlayPositionChange>;
+    /** @ignore */
+    private connectKeydownEscape;
+    /** @ignore */
+    private connectOutsideClick;
+    /** @ignore */
+    private onAttach;
+    /** @ignore */
+    private onDetach;
+    /** @ignore */
+    private setScrollStrategy;
+    /** @ignore */
+    private setHasBackdrop;
+    /** @ignore */
+    private setDisableClose;
+    /** @ignore */
+    private setOrigin;
+    /** @ignore */
+    private setPositions;
+    /** @ignore */
+    private computePositions;
+    private onOriginChangeEffect;
+    /** @ignore */
+    private onPositionChangeEffect;
+    /** @ignore */
+    private fireOverlayNgOnChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardContentDirective, "[rdxHoverCardContent]", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "alternatePositionsDisabled": { "alias": "alternatePositionsDisabled"; "required": false; "isSignal": true; }; "onOverlayEscapeKeyDownDisabled": { "alias": "onOverlayEscapeKeyDownDisabled"; "required": false; "isSignal": true; }; "onOverlayOutsideClickDisabled": { "alias": "onOverlayOutsideClickDisabled"; "required": false; "isSignal": true; }; }, { "onOverlayEscapeKeyDown": "onOverlayEscapeKeyDown"; "onOverlayOutsideClick": "onOverlayOutsideClick"; "onOpen": "onOpen"; "onClosed": "onClosed"; }, never, never, true, [{ directive: typeof i1.CdkConnectedOverlay; inputs: {}; outputs: {}; }]>;
+}

package/hover-card/src/hover-card-root.directive.d.ts

@@ -0,0 +1,168 @@
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { DestroyRef, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { RdxHoverCardAnchorDirective } from './hover-card-anchor.directive';
+import { RdxHoverCardContentDirective } from './hover-card-content.directive';
+import { RdxHoverCardTriggerDirective } from './hover-card-trigger.directive';
+import { RdxHoverCardAction, RdxHoverCardAnimationStatus, RdxHoverCardAttachDetachEvent, RdxHoverCardState } from './hover-card.types';
+import * as i0 from "@angular/core";
+export declare class RdxHoverCardRootDirective {
+    /** @ignore */
+    readonly uniqueId: import("@angular/core").WritableSignal<number>;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /**
+     * @description The anchor directive that comes form outside the hover-card rootDirective
+     * @default undefined
+     */
+    readonly anchor: import("@angular/core").InputSignal<RdxHoverCardAnchorDirective | undefined>;
+    /**
+     * @description The open state of the hover-card when it is initially rendered. Use when you do not need to control its open state.
+     * @default false
+     */
+    readonly defaultOpen: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @description The controlled state of the hover-card. `open` input take precedence of `defaultOpen` input.
+     * @default undefined
+     */
+    readonly open: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * To customise the open delay for a specific hover-card.
+     */
+    readonly openDelay: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * To customise the close delay for a specific hover-card.
+     */
+    readonly closeDelay: import("@angular/core").InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description Whether to control the state of the hover-card from external. Use in conjunction with `open` input.
+     * @default undefined
+     */
+    readonly externalControl: import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * @description Whether to take into account CSS opening/closing animations.
+     * @default false
+     */
+    readonly cssAnimation: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @description Whether to take into account CSS opening animations. `cssAnimation` input must be set to 'true'
+     * @default false
+     */
+    readonly cssOpeningAnimation: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @description Whether to take into account CSS closing animations. `cssAnimation` input must be set to 'true'
+     * @default false
+     */
+    readonly cssClosingAnimation: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore */
+    readonly cssAnimationStatus: import("@angular/core").WritableSignal<RdxHoverCardAnimationStatus | null>;
+    /** @ignore */
+    readonly contentDirective: import("@angular/core").Signal<RdxHoverCardContentDirective>;
+    /** @ignore */
+    readonly triggerDirective: import("@angular/core").Signal<RdxHoverCardTriggerDirective>;
+    /** @ignore */
+    readonly arrowDirective: import("@angular/core").Signal<import("@radix-ng/primitives/hover-card").RdxHoverCardArrowDirective | undefined>;
+    /** @ignore */
+    readonly closeDirective: import("@angular/core").Signal<import("@radix-ng/primitives/hover-card").RdxHoverCardCloseDirective | undefined>;
+    /** @ignore */
+    readonly contentAttributesComponent: import("@angular/core").Signal<import("@radix-ng/primitives/hover-card").RdxHoverCardContentAttributesComponent | undefined>;
+    /** @ignore */
+    private readonly internalAnchorDirective;
+    /** @ignore */
+    readonly viewContainerRef: ViewContainerRef;
+    /** @ignore */
+    readonly rdxCdkEventService: {
+        document: Document;
+        destroyRef: DestroyRef;
+        ngZone: import("@angular/core").NgZone;
+        renderer2: import("@angular/core").Renderer2;
+        window: Window & typeof globalThis;
+        primitiveConfigs?: import("./utils/types").PrimitiveConfigs;
+        onDestroyCallbacks: Set<() => void>;
+        "__#5800@#clickDomRootEventCallbacks": Set<(event: MouseEvent) => void>;
+        registerPrimitive<T extends object>(primitiveInstance: T): void;
+        deregisterPrimitive<T extends object>(primitiveInstance: T): void;
+        preventPrimitiveFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): void;
+        allowPrimitiveForCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): void;
+        preventPrimitiveFromCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: import("./utils/types").EventType[]): void;
+        allowPrimitiveForCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: import("./utils/types").EventType[]): void;
+        setPreventPrimitiveFromCdkMixEvents<T extends object>(primitiveInstance: T, eventTypes: import("./utils/types").PrimitiveConfig): void;
+        primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): boolean | undefined;
+        addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
+        removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
+        "__#5800@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
+        "__#5800@#registerOnDestroyCallbacks"(): void;
+        "__#5800@#listenToClickDomRootEvent"(): void;
+    } | null;
+    /** @ignore */
+    readonly destroyRef: DestroyRef;
+    /** @ignore */
+    readonly state: import("@angular/core").WritableSignal<RdxHoverCardState>;
+    /** @ignore */
+    readonly attachDetachEvent: import("@angular/core").WritableSignal<RdxHoverCardAttachDetachEvent>;
+    /** @ignore */
+    private readonly isFirstDefaultOpen;
+    /** @ignore */
+    readonly anchorDirective: import("@angular/core").Signal<RdxHoverCardAnchorDirective | undefined>;
+    /** @ignore */
+    readonly actionSubject$: Subject<RdxHoverCardAction>;
+    constructor();
+    /** @ignore */
+    getAnimationParamsSnapshot(): {
+        cssAnimation: boolean;
+        cssOpeningAnimation: boolean;
+        cssClosingAnimation: boolean;
+        cssAnimationStatus: RdxHoverCardAnimationStatus | null;
+        attachDetachEvent: RdxHoverCardAttachDetachEvent;
+        state: RdxHoverCardState;
+        canEmitOnOpenOrOnClosed: boolean;
+    };
+    /** @ignore */
+    controlledExternally(): import("@angular/core").InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /** @ignore */
+    firstDefaultOpen(): boolean;
+    /** @ignore */
+    handleOpen(): void;
+    /** @ignore */
+    handleClose(closeButton?: boolean): void;
+    /** @ignore */
+    handleToggle(): void;
+    /** @ignore */
+    isOpen(state?: RdxHoverCardState): boolean;
+    /** @ignore */
+    private setState;
+    /** @ignore */
+    private openContent;
+    /** @ignore */
+    private closeContent;
+    /** @ignore */
+    private emitOnOpen;
+    /** @ignore */
+    private emitOnClosed;
+    /** @ignore */
+    private ifOpenOrCloseWithoutAnimations;
+    /** @ignore */
+    private ifOpenOrCloseWithAnimations;
+    /** @ignore */
+    private openOrClose;
+    /** @ignore */
+    private emitOnOpenOrOnClosed;
+    /** @ignore */
+    private canEmitOnOpenOrOnClosed;
+    /** @ignore */
+    private onStateChangeEffect;
+    /** @ignore */
+    private onCssAnimationStatusChangeChangeEffect;
+    /** @ignore */
+    private emitOpenOrClosedEventEffect;
+    /** @ignore */
+    private onOpenChangeEffect;
+    /** @ignore */
+    private onIsFirstDefaultOpenChangeEffect;
+    /** @ignore */
+    private onAnchorChangeEffect;
+    /** @ignore */
+    private actionSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardRootDirective, "[rdxHoverCardRoot]", ["rdxHoverCardRoot"], { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "externalControl": { "alias": "externalControl"; "required": false; "isSignal": true; }; "cssAnimation": { "alias": "cssAnimation"; "required": false; "isSignal": true; }; "cssOpeningAnimation": { "alias": "cssOpeningAnimation"; "required": false; "isSignal": true; }; "cssClosingAnimation": { "alias": "cssClosingAnimation"; "required": false; "isSignal": true; }; }, {}, ["contentDirective", "triggerDirective", "arrowDirective", "closeDirective", "contentAttributesComponent", "internalAnchorDirective"], never, true, never>;
+}

package/hover-card/src/hover-card-root.inject.d.ts

@@ -0,0 +1,3 @@
+import { RdxHoverCardRootDirective } from './hover-card-root.directive';
+export declare function injectHoverCardRoot(optional?: false): RdxHoverCardRootDirective;
+export declare function injectHoverCardRoot(optional: true): RdxHoverCardRootDirective | null;

package/hover-card/src/hover-card-trigger.directive.d.ts

@@ -0,0 +1,26 @@
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export declare class RdxHoverCardTriggerDirective {
+    /** @ignore */
+    protected readonly rootDirective: import("@radix-ng/primitives/hover-card").RdxHoverCardRootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** @ignore */
+    readonly overlayOrigin: CdkOverlayOrigin;
+    /** @ignore */
+    readonly name: import("@angular/core").Signal<string>;
+    /** @ignore */
+    protected pointerenter(): void;
+    /** @ignore */
+    protected pointerleave(): void;
+    /** @ignore */
+    protected focus(): void;
+    /** @ignore */
+    protected blur(): void;
+    /** @ignore */
+    protected click(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxHoverCardTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxHoverCardTriggerDirective, "[rdxHoverCardTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}

package/hover-card/src/hover-card.types.d.ts

@@ -0,0 +1,18 @@
+export declare enum RdxHoverCardState {
+    OPEN = "open",
+    CLOSED = "closed"
+}
+export declare enum RdxHoverCardAction {
+    OPEN = "open",
+    CLOSE = "close"
+}
+export declare enum RdxHoverCardAttachDetachEvent {
+    ATTACH = "attach",
+    DETACH = "detach"
+}
+export declare enum RdxHoverCardAnimationStatus {
+    OPEN_STARTED = "open_started",
+    OPEN_ENDED = "open_ended",
+    CLOSED_STARTED = "closed_started",
+    CLOSED_ENDED = "closed_ended"
+}

package/hover-card/src/utils/cdk-event.service.d.ts

@@ -0,0 +1,30 @@
+import { DestroyRef, EnvironmentProviders, NgZone, Provider, Renderer2 } from '@angular/core';
+import { EventType, PrimitiveConfig, PrimitiveConfigs } from './types';
+import * as i0 from "@angular/core";
+declare class RdxCdkEventService {
+    #private;
+    document: Document;
+    destroyRef: DestroyRef;
+    ngZone: NgZone;
+    renderer2: Renderer2;
+    window: Window & typeof globalThis;
+    primitiveConfigs?: PrimitiveConfigs;
+    onDestroyCallbacks: Set<() => void>;
+    constructor();
+    registerPrimitive<T extends object>(primitiveInstance: T): void;
+    deregisterPrimitive<T extends object>(primitiveInstance: T): void;
+    preventPrimitiveFromCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): void;
+    allowPrimitiveForCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): void;
+    preventPrimitiveFromCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: EventType[]): void;
+    allowPrimitiveForCdkMultiEvents<T extends object>(primitiveInstance: T, eventTypes: EventType[]): void;
+    setPreventPrimitiveFromCdkMixEvents<T extends object>(primitiveInstance: T, eventTypes: PrimitiveConfig): void;
+    primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: EventType): boolean | undefined;
+    addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
+    removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCdkEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RdxCdkEventService>;
+}
+export declare const provideRdxCdkEventServiceInRoot: () => EnvironmentProviders;
+export declare const provideRdxCdkEventService: () => Provider;
+export declare const injectRdxCdkEventService: () => RdxCdkEventService | null;
+export {};

package/hover-card/src/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const RdxCdkEventServiceWindowKey: unique symbol;

package/hover-card/src/utils/types.d.ts

@@ -0,0 +1,7 @@
+export type EventType = 'cdkOverlayOutsideClick' | 'cdkOverlayEscapeKeyDown';
+export type EventTypeCapitalized<R extends EventType = EventType> = Capitalize<R>;
+export type EventTypeAsPrimitiveConfigKey<R extends EventType = EventType> = `prevent${EventTypeCapitalized<R>}`;
+export type PrimitiveConfig = {
+    [value in EventTypeAsPrimitiveConfigKey]?: boolean;
+};
+export type PrimitiveConfigs = Map<object, PrimitiveConfig>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radix-ng/primitives",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -75,6 +75,10 @@
       "types": "./dropdown-menu/index.d.ts",
       "default": "./fesm2022/radix-ng-primitives-dropdown-menu.mjs"
     },
+    "./hover-card": {
+      "types": "./hover-card/index.d.ts",
+      "default": "./fesm2022/radix-ng-primitives-hover-card.mjs"
+    },
     "./label": {
       "types": "./label/index.d.ts",
       "default": "./fesm2022/radix-ng-primitives-label.mjs"

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

@@ -70,7 +70,7 @@ export declare class RdxPopoverRootDirective {
         window: Window & typeof globalThis;
         primitiveConfigs?: import("./utils/types").PrimitiveConfigs;
         onDestroyCallbacks: Set<() => void>;
-        "__#6181@#clickDomRootEventCallbacks": Set<(event: MouseEvent) => void>;
+        "__#7449@#clickDomRootEventCallbacks": Set<(event: MouseEvent) => void>;
         registerPrimitive<T extends object>(primitiveInstance: T): void;
         deregisterPrimitive<T extends object>(primitiveInstance: T): void;
         preventPrimitiveFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): void;
@@ -81,9 +81,9 @@ export declare class RdxPopoverRootDirective {
         primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): boolean | undefined;
         addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
         removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
-        "__#6181@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
-        "__#6181@#registerOnDestroyCallbacks"(): void;
-        "__#6181@#listenToClickDomRootEvent"(): void;
+        "__#7449@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
+        "__#7449@#registerOnDestroyCallbacks"(): void;
+        "__#7449@#listenToClickDomRootEvent"(): void;
     } | null;
     /** @ignore */
     readonly destroyRef: DestroyRef;

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

@@ -12,7 +12,7 @@ export declare class RdxPopoverTriggerDirective {
     /** @ignore */
     readonly name: import("@angular/core").Signal<string>;
     /** @ignore */
-    click(): void;
+    protected click(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxPopoverTriggerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPopoverTriggerDirective, "[rdxPopoverTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
 }

package/tooltip/src/tooltip-content-attributes.component.d.ts

@@ -11,6 +11,14 @@ export declare class RdxTooltipContentAttributesComponent {
     /** @ignore */
     protected onAnimationEnd(_: AnimationEvent): void;
     /** @ignore */
+    protected pointerenter(): void;
+    /** @ignore */
+    protected pointerleave(): void;
+    /** @ignore */
+    protected focus(): void;
+    /** @ignore */
+    protected blur(): void;
+    /** @ignore */
     private canAnimate;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipContentAttributesComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<RdxTooltipContentAttributesComponent, "[rdxTooltipContentAttributes]", never, {}, {}, never, ["*"], true, never>;

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

@@ -79,7 +79,7 @@ export declare class RdxTooltipRootDirective {
         window: Window & typeof globalThis;
         primitiveConfigs?: import("./utils/types").PrimitiveConfigs;
         onDestroyCallbacks: Set<() => void>;
-        "__#10376@#clickDomRootEventCallbacks": Set<(event: MouseEvent) => void>;
+        "__#11143@#clickDomRootEventCallbacks": Set<(event: MouseEvent) => void>;
         registerPrimitive<T extends object>(primitiveInstance: T): void;
         deregisterPrimitive<T extends object>(primitiveInstance: T): void;
         preventPrimitiveFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): void;
@@ -90,9 +90,9 @@ export declare class RdxTooltipRootDirective {
         primitivePreventedFromCdkEvent<T extends object>(primitiveInstance: T, eventType: import("./utils/types").EventType): boolean | undefined;
         addClickDomRootEventCallback(callback: (event: MouseEvent) => void): void;
         removeClickDomRootEventCallback(callback: (event: MouseEvent) => void): boolean;
-        "__#10376@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
-        "__#10376@#registerOnDestroyCallbacks"(): void;
-        "__#10376@#listenToClickDomRootEvent"(): void;
+        "__#11143@#setPreventPrimitiveFromCdkEvent"<T extends object, R extends import("./utils/types").EventType, K extends import("./utils/types").PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
+        "__#11143@#registerOnDestroyCallbacks"(): void;
+        "__#11143@#listenToClickDomRootEvent"(): void;
     } | null;
     /** @ignore */
     readonly destroyRef: DestroyRef;