@radix-ng/primitives 0.42.0 → 0.44.0

package/toolbar/index.d.ts

@@ -1,19 +1,55 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/toolbar-root.directive";
-import * as i2 from "./src/toolbar-button.directive";
-import * as i3 from "./src/toolbar-link.directive";
-import * as i4 from "./src/toolbar-toggle-group.directive";
-import * as i5 from "./src/toolbar-toggle-item.directive";
-import * as i6 from "./src/toolbar-separator.directive";
-export * from './src/toolbar-button.directive';
-export * from './src/toolbar-link.directive';
-export * from './src/toolbar-root.directive';
-export * from './src/toolbar-root.token';
-export * from './src/toolbar-separator.directive';
-export * from './src/toolbar-toggle-group.directive';
-export * from './src/toolbar-toggle-item.directive';
-export declare class RdxToolbarModule {
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/roving-focus';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1$1 from '@radix-ng/primitives/toggle-group';
+import * as i1$2 from '@radix-ng/primitives/separator';
+
+declare class RdxToolbarRootDirective {
+    readonly orientation: i0.InputSignal<"horizontal" | "vertical">;
+    readonly dir: i0.InputSignal<"ltr" | "rtl">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarRootDirective, "[rdxToolbarRoot]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: { "dir": "dir"; "orientation": "orientation"; "loop": "loop"; }; outputs: {}; }]>;
+}
+
+declare class RdxToolbarButtonDirective {
+    #private;
+    private readonly rdxRovingFocusItemDirective;
+    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    private readonly isDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarButtonDirective, "[rdxToolbarButton]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; }; outputs: {}; }]>;
+}
+
+declare class RdxToolbarLinkDirective {
+    onKeyDown($event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarLinkDirective, "[rdxToolbarLink]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; }; outputs: {}; }]>;
+}
+
+declare class RdxToolbarToggleGroupDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarToggleGroupDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarToggleGroupDirective, "[rdxToolbarToggleGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxToggleGroupWithoutFocusDirective; inputs: { "value": "value"; "type": "type"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class RdxToolbarToggleItemDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarToggleItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarToggleItemDirective, "[rdxToolbarToggleItem]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxToggleGroupItemDirective; inputs: { "value": "value"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class RdxToolbarSeparatorDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarSeparatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxToolbarSeparatorDirective, "[rdxToolbarSeparator]", never, {}, {}, never, never, true, [{ directive: typeof i1$2.RdxSeparatorRootDirective; inputs: { "orientation": "orientation"; "decorative": "decorative"; }; outputs: {}; }]>;
+}
+
+declare const RDX_TOOLBAR_ROOT_TOKEN: InjectionToken<RdxToolbarRootDirective>;
+declare function injectRootContext(): RdxToolbarRootDirective;
+declare function provideRootContext(): Provider;
+
+declare class RdxToolbarModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxToolbarModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxToolbarModule, never, [typeof i1.RdxToolbarRootDirective, typeof i2.RdxToolbarButtonDirective, typeof i3.RdxToolbarLinkDirective, typeof i4.RdxToolbarToggleGroupDirective, typeof i5.RdxToolbarToggleItemDirective, typeof i6.RdxToolbarSeparatorDirective], [typeof i1.RdxToolbarRootDirective, typeof i2.RdxToolbarButtonDirective, typeof i3.RdxToolbarLinkDirective, typeof i4.RdxToolbarToggleGroupDirective, typeof i5.RdxToolbarToggleItemDirective, typeof i6.RdxToolbarSeparatorDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxToolbarModule, never, [typeof RdxToolbarRootDirective, typeof RdxToolbarButtonDirective, typeof RdxToolbarLinkDirective, typeof RdxToolbarToggleGroupDirective, typeof RdxToolbarToggleItemDirective, typeof RdxToolbarSeparatorDirective], [typeof RdxToolbarRootDirective, typeof RdxToolbarButtonDirective, typeof RdxToolbarLinkDirective, typeof RdxToolbarToggleGroupDirective, typeof RdxToolbarToggleItemDirective, typeof RdxToolbarSeparatorDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxToolbarModule>;
 }
+
+export { RDX_TOOLBAR_ROOT_TOKEN, RdxToolbarButtonDirective, RdxToolbarLinkDirective, RdxToolbarModule, RdxToolbarRootDirective, RdxToolbarSeparatorDirective, RdxToolbarToggleGroupDirective, RdxToolbarToggleItemDirective, injectRootContext, provideRootContext };

package/tooltip/index.d.ts

@@ -1,20 +1,433 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/tooltip-arrow.directive";
-import * as i2 from "./src/tooltip-close.directive";
-import * as i3 from "./src/tooltip-content.directive";
-import * as i4 from "./src/tooltip-trigger.directive";
-import * as i5 from "./src/tooltip-root.directive";
-import * as i6 from "./src/tooltip-anchor.directive";
-import * as i7 from "./src/tooltip-content-attributes.component";
-export * from './src/tooltip-anchor.directive';
-export * from './src/tooltip-arrow.directive';
-export * from './src/tooltip-close.directive';
-export * from './src/tooltip-content-attributes.component';
-export * from './src/tooltip-content.directive';
-export * from './src/tooltip-root.directive';
-export * from './src/tooltip-trigger.directive';
-export declare class RdxTooltipModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxTooltipModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxTooltipModule, never, [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipCloseDirective, typeof i3.RdxTooltipContentDirective, typeof i4.RdxTooltipTriggerDirective, typeof i5.RdxTooltipRootDirective, typeof i6.RdxTooltipAnchorDirective, typeof i7.RdxTooltipContentAttributesComponent], [typeof i1.RdxTooltipArrowDirective, typeof i2.RdxTooltipCloseDirective, typeof i3.RdxTooltipContentDirective, typeof i4.RdxTooltipTriggerDirective, typeof i5.RdxTooltipRootDirective, typeof i6.RdxTooltipAnchorDirective, typeof i7.RdxTooltipContentAttributesComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxTooltipModule>;
+import * as _angular_core from '@angular/core';
+import { ElementRef, OnInit, ViewContainerRef, DestroyRef } from '@angular/core';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import * as _radix_ng_primitives_tooltip from '@radix-ng/primitives/tooltip';
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import * as _angular_cdk_overlay_module_d from '@angular/cdk/overlay-module.d';
+import { RdxPositionSide, RdxPositionAlign } from '@radix-ng/primitives/core';
+import * as i1 from '@angular/cdk/overlay';
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+
+declare class RdxTooltipArrowDirective {
+    /** @ignore */
+    private readonly renderer;
+    /** @ignore */
+    private readonly rootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<any>;
+    /**
+     * @description The width of the arrow in pixels.
+     * @default 10
+     */
+    readonly width: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description The height of the arrow in pixels.
+     * @default 5
+     */
+    readonly height: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /** @ignore */
+    readonly arrowSvgElement: _angular_core.Signal<HTMLElement>;
+    /** @ignore */
+    private readonly currentArrowSvgElement;
+    /** @ignore */
+    private readonly position;
+    /** @ignore */
+    private anchorOrTriggerRect;
+    constructor();
+    /** @ignore */
+    private setAnchorOrTriggerRect;
+    /** @ignore */
+    private setPosition;
+    /** @ignore */
+    private onArrowSvgElementChangeEffect;
+    /** @ignore */
+    private onContentPositionAndArrowDimensionsChangeEffect;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipArrowDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipArrowDirective, "[rdxTooltipArrow]", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
+
+/**
+ * TODO: to be removed? But it seems to be useful when controlled from outside
+ */
+declare class RdxTooltipCloseDirective {
+    /** @ignore */
+    protected readonly rootDirective: _radix_ng_primitives_tooltip.RdxTooltipRootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<any>;
+    /** @ignore */
+    private readonly renderer;
+    constructor();
+    /** @ignore */
+    private onIsControlledExternallyEffect;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipCloseDirective, "[rdxTooltipClose]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxTooltipContentDirective 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: _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: _angular_core.InputSignal<RdxPositionSide>;
+    /**
+     * @description The distance in pixels from the trigger.
+     * @default undefined
+     */
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description The preferred alignment against the trigger. May change when collisions occur.
+     * @default center
+     */
+    readonly align: _angular_core.InputSignal<RdxPositionAlign>;
+    /**
+     * @description An offset in pixels from the "start" or "end" alignment options.
+     * @default undefined
+     */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description Whether to add some alternate positions of the content.
+     * @default false
+     */
+    readonly alternatePositionsDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @description Whether to prevent `onOverlayEscapeKeyDown` handler from calling. */
+    readonly onOverlayEscapeKeyDownDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @description Whether to prevent `onOverlayOutsideClick` handler from calling. */
+    readonly onOverlayOutsideClickDisabled: _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: _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: _angular_core.OutputEmitterRef<MouseEvent>;
+    /**
+     * @description Event handler called after the overlay is open
+     */
+    readonly onOpen: _angular_core.OutputEmitterRef<void>;
+    /**
+     * @description Event handler called after the overlay is closed
+     */
+    readonly onClosed: _angular_core.OutputEmitterRef<void>;
+    /** @ingore */
+    readonly positions: _angular_core.Signal<_angular_cdk_overlay_module_d.ConnectedPosition[]>;
+    constructor();
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    open(): void;
+    /** @ignore */
+    close(): void;
+    /** @ignore */
+    positionChange(): rxjs.Observable<_angular_cdk_overlay_module_d.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: _angular_core.ɵɵFactoryDeclaration<RdxTooltipContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipContentDirective, "[rdxTooltipContent]", 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: {}; }]>;
+}
+
+declare class RdxTooltipTriggerDirective {
+    /** @ignore */
+    protected readonly rootDirective: _radix_ng_primitives_tooltip.RdxTooltipRootDirective;
+    /** @ignore */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** @ignore */
+    readonly overlayOrigin: CdkOverlayOrigin;
+    /** @ignore */
+    readonly name: _angular_core.Signal<string>;
+    /** @ignore */
+    pointerenter(): void;
+    /** @ignore */
+    pointerleave(): void;
+    /** @ignore */
+    focus(): void;
+    /** @ignore */
+    blur(): void;
+    /** @ignore */
+    click(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipTriggerDirective, "[rdxTooltipTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}
+
+type EventType = 'cdkOverlayOutsideClick' | 'cdkOverlayEscapeKeyDown';
+type EventTypeCapitalized<R extends EventType = EventType> = Capitalize<R>;
+type EventTypeAsPrimitiveConfigKey<R extends EventType = EventType> = `prevent${EventTypeCapitalized<R>}`;
+type PrimitiveConfig = {
+    [value in EventTypeAsPrimitiveConfigKey]?: boolean;
+};
+type PrimitiveConfigs = Map<object, PrimitiveConfig>;
+
+declare class RdxTooltipAnchorDirective {
+    /**
+     * @ignore
+     * If outside the rootDirective then null, otherwise the rootDirective directive - with optional `true` passed in as the first param.
+     * If outside the rootDirective and non-null value that means the html structure is wrong - tooltip inside tooltip.
+     * */
+    protected rootDirective: RdxTooltipRootDirective | null;
+    /** @ignore */
+    readonly elementRef: ElementRef<any>;
+    /** @ignore */
+    readonly overlayOrigin: CdkOverlayOrigin;
+    /** @ignore */
+    readonly document: Document;
+    /** @ignore */
+    readonly name: _angular_core.Signal<string>;
+    /** @ignore */
+    click(): void;
+    /** @ignore */
+    setRoot(root: RdxTooltipRootDirective): void;
+    private emitOutsideClick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipAnchorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipAnchorDirective, "[rdxTooltipAnchor]", ["rdxTooltipAnchor"], {}, {}, never, never, true, [{ directive: typeof i1.CdkOverlayOrigin; inputs: {}; outputs: {}; }]>;
+}
+
+declare enum RdxTooltipState {
+    OPEN = "open",
+    CLOSED = "closed"
+}
+declare enum RdxTooltipAction {
+    OPEN = "open",
+    CLOSE = "close"
+}
+declare enum RdxTooltipAttachDetachEvent {
+    ATTACH = "attach",
+    DETACH = "detach"
+}
+declare enum RdxTooltipAnimationStatus {
+    OPEN_STARTED = "open_started",
+    OPEN_ENDED = "open_ended",
+    CLOSED_STARTED = "closed_started",
+    CLOSED_ENDED = "closed_ended"
+}
+
+declare class RdxTooltipRootDirective {
+    /** @ignore */
+    readonly uniqueId: _angular_core.WritableSignal<number>;
+    /** @ignore */
+    readonly name: _angular_core.Signal<string>;
+    /**
+     * @description The anchor directive that comes form outside the tooltip rootDirective
+     * @default undefined
+     */
+    readonly anchor: _angular_core.InputSignal<RdxTooltipAnchorDirective | undefined>;
+    /**
+     * @description The open state of the tooltip when it is initially rendered. Use when you do not need to control its open state.
+     * @default false
+     */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @description The controlled state of the tooltip. `open` input take precedence of `defaultOpen` input.
+     * @default undefined
+     */
+    readonly open: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * To customise the open delay for a specific tooltip.
+     */
+    readonly openDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * To customise the close delay for a specific tooltip.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * @description Whether to control the state of the tooltip from external. Use in conjunction with `open` input.
+     * @default undefined
+     */
+    readonly externalControl: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /**
+     * @description Whether to take into account CSS opening/closing animations.
+     * @default false
+     */
+    readonly cssAnimation: _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: _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: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore */
+    readonly cssAnimationStatus: _angular_core.WritableSignal<RdxTooltipAnimationStatus | null>;
+    /** @ignore */
+    readonly contentDirective: _angular_core.Signal<RdxTooltipContentDirective>;
+    /** @ignore */
+    readonly triggerDirective: _angular_core.Signal<RdxTooltipTriggerDirective>;
+    /** @ignore */
+    readonly arrowDirective: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipArrowDirective | undefined>;
+    /** @ignore */
+    readonly closeDirective: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipCloseDirective | undefined>;
+    /** @ignore */
+    readonly contentAttributesComponent: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipContentAttributesComponent | undefined>;
+    /** @ignore */
+    private readonly internalAnchorDirective;
+    /** @ignore */
+    readonly viewContainerRef: ViewContainerRef;
+    /** @ignore */
+    readonly rdxCdkEventService: {
+        document: Document;
+        destroyRef: DestroyRef;
+        ngZone: _angular_core.NgZone;
+        renderer2: _angular_core.Renderer2;
+        window: Window & typeof globalThis;
+        primitiveConfigs?: PrimitiveConfigs;
+        onDestroyCallbacks: Set<() => void>;
+        #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: 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;
+        #setPreventPrimitiveFromCdkEvent<T extends object, R extends EventType, K extends PrimitiveConfig[`prevent${Capitalize<R>}`]>(primitiveInstance: T, eventType: R, value: K): void;
+        #registerOnDestroyCallbacks(): void;
+        #listenToClickDomRootEvent(): void;
+    } | null;
+    /** @ignore */
+    readonly destroyRef: DestroyRef;
+    /** @ignore */
+    readonly state: _angular_core.WritableSignal<RdxTooltipState>;
+    /** @ignore */
+    readonly attachDetachEvent: _angular_core.WritableSignal<RdxTooltipAttachDetachEvent>;
+    /** @ignore */
+    private readonly isFirstDefaultOpen;
+    /** @ignore */
+    readonly anchorDirective: _angular_core.Signal<RdxTooltipAnchorDirective | undefined>;
+    /** @ignore */
+    readonly actionSubject$: Subject<RdxTooltipAction>;
+    constructor();
+    /** @ignore */
+    getAnimationParamsSnapshot(): {
+        cssAnimation: boolean;
+        cssOpeningAnimation: boolean;
+        cssClosingAnimation: boolean;
+        cssAnimationStatus: RdxTooltipAnimationStatus | null;
+        attachDetachEvent: RdxTooltipAttachDetachEvent;
+        state: RdxTooltipState;
+        canEmitOnOpenOrOnClosed: boolean;
+    };
+    /** @ignore */
+    controlledExternally(): _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
+    /** @ignore */
+    firstDefaultOpen(): boolean;
+    /** @ignore */
+    handleOpen(): void;
+    /** @ignore */
+    handleClose(closeButton?: boolean): void;
+    /** @ignore */
+    handleToggle(): void;
+    /** @ignore */
+    isOpen(state?: RdxTooltipState): 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: _angular_core.ɵɵFactoryDeclaration<RdxTooltipRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipRootDirective, "[rdxTooltipRoot]", ["rdxTooltipRoot"], { "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>;
+}
+
+declare class RdxTooltipContentAttributesComponent {
+    /** @ignore */
+    protected readonly rootDirective: _radix_ng_primitives_tooltip.RdxTooltipRootDirective;
+    /** @ignore */
+    readonly name: _angular_core.Signal<string>;
+    /** @ignore */
+    readonly disableAnimation: _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: _angular_core.ɵɵFactoryDeclaration<RdxTooltipContentAttributesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxTooltipContentAttributesComponent, "[rdxTooltipContentAttributes]", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RdxTooltipModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxTooltipModule, never, [typeof RdxTooltipArrowDirective, typeof RdxTooltipCloseDirective, typeof RdxTooltipContentDirective, typeof RdxTooltipTriggerDirective, typeof RdxTooltipRootDirective, typeof RdxTooltipAnchorDirective, typeof RdxTooltipContentAttributesComponent], [typeof RdxTooltipArrowDirective, typeof RdxTooltipCloseDirective, typeof RdxTooltipContentDirective, typeof RdxTooltipTriggerDirective, typeof RdxTooltipRootDirective, typeof RdxTooltipAnchorDirective, typeof RdxTooltipContentAttributesComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxTooltipModule>;
+}
+
+export { RdxTooltipAnchorDirective, RdxTooltipArrowDirective, RdxTooltipCloseDirective, RdxTooltipContentAttributesComponent, RdxTooltipContentDirective, RdxTooltipModule, RdxTooltipRootDirective, RdxTooltipTriggerDirective };

package/tooltip2/README.md

@@ -0,0 +1,3 @@
+# @radix-ng/primitives/tooltip2
+
+Secondary entry point of `@radix-ng/primitives`. It can be used by importing from `@radix-ng/primitives/tooltip2`.