@radix-ng/primitives 0.51.0 → 1.0.0-beta.0

package/types/radix-ng-primitives-select.d.ts

@@ -1,214 +1,512 @@
-import * as i0 from '@angular/core';
-import { AfterViewInit, OnDestroy, NgZone, OnInit, AfterContentInit, ElementRef, ChangeDetectorRef, EventEmitter, DestroyRef, QueryList } from '@angular/core';
-import { ActiveDescendantKeyManager, Highlightable } from '@angular/cdk/a11y';
-import { Directionality } from '@angular/cdk/bidi';
-import { Observable, Subject } from 'rxjs';
-import { SelectionModel } from '@angular/cdk/collections';
-import { Overlay, CdkConnectedOverlay, ConnectedPosition } from '@angular/cdk/overlay';
-
-declare class RdxSelectValueDirective {
-    select: RdxSelectComponent;
-    placeholder: string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectValueDirective, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RdxSelectValueDirective, "[rdxSelectValue]", ["rdxSelectValue"], { "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-declare class RdxSelectTriggerDirective implements AfterViewInit, OnDestroy {
-    readonly ngZone: NgZone;
-    protected nativeElement: any;
-    protected select: RdxSelectComponent;
-    protected readonly value: i0.Signal<RdxSelectValueDirective>;
-    private resizeObserver;
-    ngAfterViewInit(): void;
-    ngOnDestroy(): void;
-    focus(): void;
-    private observeTriggerResize;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectTriggerDirective, "[rdxSelectTrigger]", never, {}, {}, ["value"], never, true, never>;
-}
-
-declare class RdxSelectComponent implements OnInit, AfterContentInit {
-    protected overlay: Overlay;
-    protected elementRef: ElementRef<any>;
-    protected changeDetectorRef: ChangeDetectorRef;
-    private readonly destroyRef;
-    private readonly ngZone;
-    protected readonly trigger: i0.Signal<RdxSelectTriggerDirective>;
-    protected readonly content: i0.Signal<RdxSelectContentDirective>;
-    readonly items: i0.Signal<readonly RdxSelectItemDirective[]>;
-    readonly overlayDir: i0.Signal<CdkConnectedOverlay>;
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OutputRef, ElementRef } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { AcceptableValue, Direction } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_select from '@radix-ng/primitives/select';
+import * as i1 from '@radix-ng/primitives/focus-scope';
+import * as i2 from '@radix-ng/primitives/dismissable-layer';
+import * as i3 from '@radix-ng/primitives/collection';
+import * as _radix_ng_primitives_types_radix_ng_primitives_core from '@radix-ng/primitives/types/radix-ng-primitives-core';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import * as i1$2 from '@radix-ng/primitives/portal';
+import { RdxPortalContainer } from '@radix-ng/primitives/portal';
+import * as i1$3 from '@radix-ng/primitives/presence';
+
+declare class RdxSelectLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectLabel, "[rdxSelectLabel]", never, {}, {}, never, never, true, never>;
+}
+
+declare const context$2: () => {
+    content: _angular_core.WritableSignal<HTMLElement | null>;
+    viewport: _angular_core.WritableSignal<HTMLElement | undefined>;
+    isPositioned: _angular_core.WritableSignal<boolean>;
+    selectedItem: _angular_core.WritableSignal<HTMLElement | undefined>;
+    selectedItemText: _angular_core.WritableSignal<HTMLElement | undefined>;
+    onViewportChange: (node: any) => void;
+    onItemLeave: () => void;
+    itemRefCallback: (node: any, value: any, disabled: boolean) => void;
+    itemTextRefCallback: (node: any, value: any, disabled: any) => void;
+};
+type RdxSelectContentContext = ReturnType<typeof context$2>;
+declare const injectSelectContentContext: (optional?: boolean) => {
+    content: _angular_core.WritableSignal<HTMLElement | null>;
+    viewport: _angular_core.WritableSignal<HTMLElement | undefined>;
+    isPositioned: _angular_core.WritableSignal<boolean>;
+    selectedItem: _angular_core.WritableSignal<HTMLElement | undefined>;
+    selectedItemText: _angular_core.WritableSignal<HTMLElement | undefined>;
+    onViewportChange: (node: any) => void;
+    onItemLeave: () => void;
+    itemRefCallback: (node: any, value: any, disabled: boolean) => void;
+    itemTextRefCallback: (node: any, value: any, disabled: any) => void;
+} | null;
+declare const provideSelectContentContext: (useFactory: () => {
+    content: _angular_core.WritableSignal<HTMLElement | null>;
+    viewport: _angular_core.WritableSignal<HTMLElement | undefined>;
+    isPositioned: _angular_core.WritableSignal<boolean>;
+    selectedItem: _angular_core.WritableSignal<HTMLElement | undefined>;
+    selectedItemText: _angular_core.WritableSignal<HTMLElement | undefined>;
+    onViewportChange: (node: any) => void;
+    onItemLeave: () => void;
+    itemRefCallback: (node: any, value: any, disabled: boolean) => void;
+    itemTextRefCallback: (node: any, value: any, disabled: any) => void;
+}) => _angular_core.Provider;
+interface RdxPositionerImpl {
+    placed: OutputRef<any>;
+}
+declare const RDX_SELECT_POSITIONER_TOKEN: InjectionToken<RdxPositionerImpl>;
+declare class RdxSelectContent {
+    private readonly dismissableLayer;
+    private readonly currentElement;
+    private readonly collection;
+    readonly rootContext: {
+        triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+        valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+        triggerPointerDownPosRef: _angular_core.WritableSignal<{
+            x: number;
+            y: number;
+        } | null>;
+        contentId: string;
+        dir: _angular_core.InputSignal<_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<_radix_ng_primitives_core.AcceptableValue | _radix_ng_primitives_core.AcceptableValue[] | undefined>;
+        multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        by: _angular_core.InputSignal<string | ((a: _radix_ng_primitives_core.AcceptableValue, b: _radix_ng_primitives_core.AcceptableValue) => boolean) | undefined>;
+        open: _angular_core.ModelSignal<boolean>;
+        disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        optionsSet: _angular_core.WritableSignal<Set<_radix_ng_primitives_select.SelectOption>>;
+        onOptionAdd: (option: any) => void;
+        onOptionRemove: (option: any) => void;
+        onValueChange: (value: _radix_ng_primitives_core.AcceptableValue) => void;
+        onTriggerChange: (node: any) => void;
+        onValueElementChange: (node: any) => void;
+        onOpenChange: (value: any) => void;
+    };
+    readonly selectedItem: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly selectedItemText: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly firstValidItemFoundRef: _angular_core.WritableSignal<boolean>;
+    readonly viewport: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly isPositioned: _angular_core.WritableSignal<boolean>;
+    /**
+     * Event handler called when the escape key is down.
+     * Can be prevented.
+     */
+    readonly escapeKeyDown: OutputRef<KeyboardEvent>;
+    /**
+     * Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    readonly pointerDownOutside: OutputRef<PointerEvent>;
+    readonly content: _angular_core.WritableSignal<HTMLElement | null>;
+    set positioner(port: RdxPositionerImpl | undefined);
+    constructor();
+    focusSelectedItem(): void;
+    handleKeyDown(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectContent, "[rdxSelectContent]", never, {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; }, ["positioner"], never, true, [{ directive: typeof i1.RdxFocusScope; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxCollectionProvider; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxSelectGroup {
+    readonly id: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectGroup, "[rdxSelectGroup]", ["rdxSelectGroup"], {}, {}, never, never, true, never>;
+}
+
+declare const context$1: () => {
+    value: _angular_core.InputSignal<any>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isSelected: _angular_core.Signal<boolean>;
+    textId: string;
+    onItemTextChange: (node: any) => void;
+};
+type RdxSelectItemContext = ReturnType<typeof context$1>;
+declare const injectSelectItemContext: (optional?: boolean) => {
+    value: _angular_core.InputSignal<any>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isSelected: _angular_core.Signal<boolean>;
+    textId: string;
+    onItemTextChange: (node: any) => void;
+} | null;
+declare const provideSelectItemContext: (useFactory: () => {
+    value: _angular_core.InputSignal<any>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    isSelected: _angular_core.Signal<boolean>;
+    textId: string;
+    onItemTextChange: (node: any) => void;
+}) => _angular_core.Provider;
+type SelectEvent = CustomEvent<{
+    originalEvent: PointerEvent | KeyboardEvent;
+    value?: any;
+}>;
+declare class RdxSelectItem {
+    private readonly rootContext;
+    private readonly contentContext;
+    private readonly currentElement;
+    readonly value: _angular_core.InputSignal<any>;
+    readonly textValue: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly textValue$: _angular_core.WritableSignal<string>;
+    readonly isSelected: _angular_core.Signal<boolean>;
+    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly textId: string;
+    private readonly afterNextRender;
+    private SELECT_SELECT;
+    onPointerDown(event: Event): void;
+    onPointerUp(event: PointerEvent | KeyboardEvent): void;
+    onPointerLeave(event: Event): void;
+    onPointerMove(event: Event): void;
+    handleKeyDown(event: Event): void;
+    handleSelectCustomEvent(event: PointerEvent | KeyboardEvent): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectItem, "[rdxSelectItem]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "textValue": { "alias": "textValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i3.RdxCollectionItem; inputs: { "value": "value"; }; outputs: {}; }]>;
+}
+
+declare class RdxSelectItemIndicator {
+    readonly itemContext: {
+        value: _angular_core.InputSignal<any>;
+        disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        isSelected: _angular_core.Signal<boolean>;
+        textId: string;
+        onItemTextChange: (node: any) => void;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectItemIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectItemIndicator, "[rdxSelectItemIndicator]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxSelectItemText {
+    private readonly elementRef;
+    readonly rootContext: {
+        triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+        valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+        triggerPointerDownPosRef: _angular_core.WritableSignal<{
+            x: number;
+            y: number;
+        } | null>;
+        contentId: string;
+        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<_radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue | _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue[] | undefined>;
+        multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        by: _angular_core.InputSignal<string | ((a: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue, b: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => boolean) | undefined>;
+        open: _angular_core.ModelSignal<boolean>;
+        disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        optionsSet: _angular_core.WritableSignal<Set<_radix_ng_primitives_select.SelectOption>>;
+        onOptionAdd: (option: any) => void;
+        onOptionRemove: (option: any) => void;
+        onValueChange: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => void;
+        onTriggerChange: (node: any) => void;
+        onValueElementChange: (node: any) => void;
+        onOpenChange: (value: any) => void;
+    };
+    readonly contentContext: {
+        content: _angular_core.WritableSignal<HTMLElement | null>;
+        viewport: _angular_core.WritableSignal<HTMLElement | undefined>;
+        isPositioned: _angular_core.WritableSignal<boolean>;
+        selectedItem: _angular_core.WritableSignal<HTMLElement | undefined>;
+        selectedItemText: _angular_core.WritableSignal<HTMLElement | undefined>;
+        onViewportChange: (node: any) => void;
+        onItemLeave: () => void;
+        itemRefCallback: (node: any, value: any, disabled: boolean) => void;
+        itemTextRefCallback: (node: any, value: any, disabled: any) => void;
+    };
+    readonly itemContext: {
+        value: _angular_core.InputSignal<any>;
+        disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        isSelected: _angular_core.Signal<boolean>;
+        textId: string;
+        onItemTextChange: (node: any) => void;
+    };
+    readonly optionProps: _angular_core.Signal<{
+        value: any;
+        disabled: boolean;
+        textContent: any;
+    }>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectItemText, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectItemText, "[rdxSelectItemText]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxSelectPopperPositionContent {
+    protected rootContext: {
+        triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+        valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+        triggerPointerDownPosRef: _angular_core.WritableSignal<{
+            x: number;
+            y: number;
+        } | null>;
+        contentId: string;
+        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<_radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue | _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue[] | undefined>;
+        multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        by: _angular_core.InputSignal<string | ((a: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue, b: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => boolean) | undefined>;
+        open: _angular_core.ModelSignal<boolean>;
+        disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        optionsSet: _angular_core.WritableSignal<Set<_radix_ng_primitives_select.SelectOption>>;
+        onOptionAdd: (option: any) => void;
+        onOptionRemove: (option: any) => void;
+        onValueChange: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => void;
+        onTriggerChange: (node: any) => void;
+        onValueElementChange: (node: any) => void;
+        onOpenChange: (value: any) => void;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectPopperPositionContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectPopperPositionContent, "[rdxSelectPopperPositionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxSelectPopperPositionWrapper implements RdxPositionerImpl {
     /**
-     * Tuple type for the trigger element size. Set by the trigger element itself.
-     * The first element is the width and the second element is the height.
-     * @returns The size of the trigger element.
+     * The preferred side of the anchor to render against when open.
+     * Will be reversed when collisions occur and avoidCollisions is enabled.
      */
-    readonly triggerSize: i0.WritableSignal<[number, number]>;
+    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
     /**
-     * The width of the trigger element.
-     * @returns The width of the trigger element.
+     * The distance in pixels from the anchor.
      */
-    readonly triggerWidth: i0.Signal<number>;
-    /** Deals with the selection logic. */
-    selectionModel: SelectionModel<RdxSelectItemDirective>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, unknown>;
     /**
-     * This position config ensures that the top "start" corner of the overlay
-     * is aligned with the top "start" of the origin by default (overlapping
-     * the trigger completely). If the panel cannot fit below the trigger, it
-     * will fall back to a position above the trigger.
+     * The preferred alignment against the anchor. May change when collisions occur.
      */
-    positions: ConnectedPosition[];
-    private closeSubscription;
+    readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
     /**
-     * @ignore
+     * An offset in pixels from the `start` or `end` alignment options.
      */
-    readonly dir: Directionality | null;
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, unknown>;
     /**
-     * @ignore
+     * The padding between the arrow and the edges of the content.
+     * If your content has border-radius, this will prevent it from overflowing the corners.
      */
-    protected keyManager: ActiveDescendantKeyManager<RdxSelectItemDirective>;
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, unknown>;
     /**
-     * @ignore
+     * When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges.
      */
-    readonly id: string;
-    defaultValue: string;
-    name: string;
-    defaultOpen: boolean;
-    open: boolean;
-    /** Whether the Select is disabled. */
-    disabled: boolean;
-    required: boolean;
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * The overlay width will be set to the trigger width if this is true.
-     * Otherwise, the overlay width will be set to the width of the content.
+     * The element used as the collision boundary.
+     * By default this is the viewport, though you can provide additional element(s) to be included in this check.
      */
-    matchTriggerWidth: boolean;
+    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
     /**
-     * The controlled value of the item to expand
+     * The distance in pixels from the boundary edges where collision detection should occur.
+     * Accepts a number (same for all sides), or a partial padding object, for example: `{ top: 20, left: 20 }`.
      */
-    set value(value: string);
-    get value(): string | null;
-    private _value?;
-    readonly onValueChange: EventEmitter<string>;
-    readonly onOpenChange: EventEmitter<boolean>;
-    readonly optionSelectionChanges: Observable<RdxSelectItemChange>;
-    get selected(): string | null;
-    ngOnInit(): void;
-    ngAfterContentInit(): void;
+    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
     /**
-     * Callback that is invoked when the overlay panel has been attached.
+     * The sticky behavior on the `align` axis.
+     * - `partial` will keep the content in the boundary as long as the trigger is at least partially in the boundary
+     * - `always` will keep the content in the boundary regardless.
      */
-    onAttached(): void;
-    onDetach(): void;
-    /** Toggles the overlay panel open or closed. */
-    toggle(): void;
-    openPanel(): void;
-    close(): void;
-    updateActiveItem(item: RdxSelectItemDirective): void;
-    private selectDefaultValue;
-    private selectValue;
-    private closingActions;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RdxSelectComponent, "[rdxSelect]", never, { "defaultValue": { "alias": "defaultValue"; "required": false; }; "name": { "alias": "name"; "required": false; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; }; "open": { "alias": "open"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "matchTriggerWidth": { "alias": "matchTriggerWidth"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "onValueChange": "onValueChange"; "onOpenChange": "onOpenChange"; }, ["trigger", "content", "items"], ["[rdxSelectTrigger]", "[rdxSelectContent]"], true, never>;
-    static ngAcceptInputType_defaultOpen: unknown;
-    static ngAcceptInputType_open: unknown;
-    static ngAcceptInputType_disabled: unknown;
-    static ngAcceptInputType_required: unknown;
-    static ngAcceptInputType_matchTriggerWidth: unknown;
-}
-
-declare class RdxSelectItemChange<T = RdxSelectItemDirective> {
-    source: T;
-    constructor(source: T);
-}
-declare class RdxSelectItemDirective implements Highlightable {
-    protected readonly select: RdxSelectComponent;
-    protected readonly content: RdxSelectContentDirective;
-    readonly onSelectionChange: EventEmitter<RdxSelectItemChange<RdxSelectItemDirective>>;
-    protected readonly nativeElement: any;
-    highlighted: boolean;
-    selected: boolean;
-    get dataState(): string;
+    readonly sticky: _angular_core.InputSignal<"partial" | "always">;
     /**
-     * The unique SelectItem id.
-     * @ignore
+     * Whether to hide the content when the trigger becomes fully occluded.
      */
-    readonly id: string;
-    set value(value: string);
-    get value(): string;
-    private _value?;
-    textValue: string | null;
-    /** Whether the SelectItem is disabled. */
-    set disabled(value: boolean);
-    get disabled(): boolean;
-    private _disabled;
-    get viewValue(): string;
-    constructor();
-    /** Gets the label to be used when determining whether the option should be focused.
-     * @ignore
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to update the position of the floating element on every animation frame if required.
      */
-    getLabel(): string;
+    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
     /**
-     * `Selects the option while indicating the selection came from the user. Used to
-     * determine if the select's view -> model callback should be invoked.`
-     * @ignore
+     * Emits when the element is placed.
      */
-    selectViaInteraction(): void;
-    /** @ignore */
-    handleKeydown(event: KeyboardEvent): void;
-    /** @ignore */
-    setActiveStyles(): void;
-    /** @ignore */
-    setInactiveStyles(): void;
-    protected onPointerMove(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectItemDirective, "[rdxSelectItem]", ["rdxSelectItem"], { "value": { "alias": "value"; "required": false; }; "textValue": { "alias": "textValue"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
-    static ngAcceptInputType_disabled: unknown;
-}
-
-declare class RdxSelectContentDirective implements AfterContentInit {
-    protected readonly destroyRef: DestroyRef;
-    protected readonly dir: Directionality | null;
-    protected select: RdxSelectComponent;
-    readonly highlighted: Subject<RdxSelectItemDirective>;
-    keyManager: ActiveDescendantKeyManager<RdxSelectItemDirective>;
-    options: QueryList<RdxSelectItemDirective>;
-    constructor();
-    initKeyManager(): ActiveDescendantKeyManager<RdxSelectItemDirective>;
-    ngAfterContentInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectContentDirective, "[rdxSelectContent]", ["rdxSelectContent"], {}, {}, ["options"], never, true, never>;
+    readonly placed: _angular_core.OutputRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectPopperPositionWrapper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectPopperPositionWrapper, "[rdxSelectPopperPositionWrapper]", 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; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, never, never, true, [{ directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
 }
 
-declare class RdxSelectGroupDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectGroupDirective, "[rdxSelectGroup]", ["rdxSelectGroup"], {}, {}, never, never, true, never>;
+declare class RdxSelectPortal {
+    /**
+     * Optional container to portal the content into. Defaults to `document.body` when not set.
+     */
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectPortal, "[rdxSelectPortal]", never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
 }
 
-declare class RdxSelectItemIndicatorDirective {
-    protected item: RdxSelectItemDirective;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectItemIndicatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectItemIndicatorDirective, "[rdxSelectItemIndicator]", ["rdxSelectItemIndicator"], {}, {}, never, never, true, never>;
+declare class RdxSelectPortalPresence {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectPortalPresence, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectPortalPresence, "ng-template[rdxSelectPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1$3.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxSelectLabelDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectLabelDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectLabelDirective, "[rdxSelectLabel]", ["rdxSelectLabel"], {}, {}, never, never, true, never>;
+interface SelectOption {
+    value: any;
+    disabled?: boolean;
+    textContent: string;
+}
+declare const context: () => {
+    triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+    valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+    triggerPointerDownPosRef: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    contentId: string;
+    dir: _angular_core.InputSignal<Direction>;
+    value: _angular_core.ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    by: _angular_core.InputSignal<string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined>;
+    open: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    optionsSet: _angular_core.WritableSignal<Set<SelectOption>>;
+    onOptionAdd: (option: any) => void;
+    onOptionRemove: (option: any) => void;
+    onValueChange: (value: AcceptableValue) => void;
+    onTriggerChange: (node: any) => void;
+    onValueElementChange: (node: any) => void;
+    onOpenChange: (value: any) => void;
+};
+type RdxSelectRootContext = ReturnType<typeof context>;
+declare const injectSelectRootContext: (optional?: boolean) => {
+    triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+    valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+    triggerPointerDownPosRef: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    contentId: string;
+    dir: _angular_core.InputSignal<Direction>;
+    value: _angular_core.ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    by: _angular_core.InputSignal<string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined>;
+    open: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    optionsSet: _angular_core.WritableSignal<Set<SelectOption>>;
+    onOptionAdd: (option: any) => void;
+    onOptionRemove: (option: any) => void;
+    onValueChange: (value: AcceptableValue) => void;
+    onTriggerChange: (node: any) => void;
+    onValueElementChange: (node: any) => void;
+    onOpenChange: (value: any) => void;
+} | null;
+declare const provideSelectRootContext: (useFactory: () => {
+    triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+    valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+    triggerPointerDownPosRef: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    contentId: string;
+    dir: _angular_core.InputSignal<Direction>;
+    value: _angular_core.ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+    multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    by: _angular_core.InputSignal<string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined>;
+    open: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    optionsSet: _angular_core.WritableSignal<Set<SelectOption>>;
+    onOptionAdd: (option: any) => void;
+    onOptionRemove: (option: any) => void;
+    onValueChange: (value: AcceptableValue) => void;
+    onTriggerChange: (node: any) => void;
+    onValueElementChange: (node: any) => void;
+    onOpenChange: (value: any) => void;
+}) => _angular_core.Provider;
+declare class RdxSelectRoot {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dir: _angular_core.InputSignal<Direction>;
+    /** Use this to compare objects by a particular field, or pass your own comparison function for complete control over how objects are compared. */
+    readonly by: _angular_core.InputSignal<string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined>;
+    readonly isEmptyModelValue: _angular_core.Signal<boolean>;
+    readonly optionsSet: _angular_core.WritableSignal<Set<SelectOption>>;
+    readonly nativeSelectKey: _angular_core.Signal<string>;
+    readonly triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly triggerPointerDownPosRef: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    getOption(value: SelectOption['value']): SelectOption | undefined;
+    handleValueChange(value: AcceptableValue): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectRoot, "[rdxSelectRoot]", ["rdxSelectRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "by": { "alias": "by"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "value": "valueChange"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxSelectSeparatorDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectSeparatorDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectSeparatorDirective, "[rdxSelectSeparator]", ["rdxSelectSeparator"], {}, {}, never, never, true, never>;
+declare class RdxSelectTrigger {
+    readonly rootContext: {
+        triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+        valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+        triggerPointerDownPosRef: _angular_core.WritableSignal<{
+            x: number;
+            y: number;
+        } | null>;
+        contentId: string;
+        dir: _angular_core.InputSignal<_radix_ng_primitives_types_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<_radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue | _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue[] | undefined>;
+        multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        by: _angular_core.InputSignal<string | ((a: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue, b: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => boolean) | undefined>;
+        open: _angular_core.ModelSignal<boolean>;
+        disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        optionsSet: _angular_core.WritableSignal<Set<_radix_ng_primitives_select.SelectOption>>;
+        onOptionAdd: (option: any) => void;
+        onOptionRemove: (option: any) => void;
+        onValueChange: (value: _radix_ng_primitives_types_radix_ng_primitives_core.AcceptableValue) => void;
+        onTriggerChange: (node: any) => void;
+        onValueElementChange: (node: any) => void;
+        onOpenChange: (value: any) => void;
+    };
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    handleOpen(): void;
+    handlePointerOpen(event: Event): void;
+    onClickHandler(event: Event): void;
+    onPointerDown(event: Event): void;
+    onPointerUp(event: Event): void;
+    onKeydown(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectTrigger, "button[rdxSelectTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
 }
 
-declare class RdxSelectIconDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectIconDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSelectIconDirective, "[rdxSelectIcon]", ["rdxSelectIcon"], {}, {}, never, never, true, never>;
+declare class RdxSelectValue {
+    readonly rootContext: {
+        triggerElement: _angular_core.WritableSignal<HTMLElement | null>;
+        valueElement: _angular_core.WritableSignal<HTMLElement | null>;
+        triggerPointerDownPosRef: _angular_core.WritableSignal<{
+            x: number;
+            y: number;
+        } | null>;
+        contentId: string;
+        dir: _angular_core.InputSignal<_radix_ng_primitives_core.Direction>;
+        value: _angular_core.ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
+        multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        by: _angular_core.InputSignal<string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined>;
+        open: _angular_core.ModelSignal<boolean>;
+        disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        optionsSet: _angular_core.WritableSignal<Set<_radix_ng_primitives_select.SelectOption>>;
+        onOptionAdd: (option: any) => void;
+        onOptionRemove: (option: any) => void;
+        onValueChange: (value: AcceptableValue) => void;
+        onTriggerChange: (node: any) => void;
+        onValueElementChange: (node: any) => void;
+        onOpenChange: (value: any) => void;
+    };
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly slotText: _angular_core.Signal<string | undefined>;
+    readonly selectedLabel: _angular_core.Signal<string[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectValue, "span[rdxSelectValue]", ["rdxSelectedValue"], { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class RdxSelectModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxSelectModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxSelectModule, never, [typeof RdxSelectContentDirective, typeof RdxSelectGroupDirective, typeof RdxSelectItemDirective, typeof RdxSelectItemIndicatorDirective, typeof RdxSelectLabelDirective, typeof RdxSelectComponent, typeof RdxSelectSeparatorDirective, typeof RdxSelectTriggerDirective, typeof RdxSelectValueDirective, typeof RdxSelectIconDirective], [typeof RdxSelectContentDirective, typeof RdxSelectGroupDirective, typeof RdxSelectItemDirective, typeof RdxSelectItemIndicatorDirective, typeof RdxSelectLabelDirective, typeof RdxSelectComponent, typeof RdxSelectSeparatorDirective, typeof RdxSelectTriggerDirective, typeof RdxSelectValueDirective, typeof RdxSelectIconDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxSelectModule>;
+declare class RdxSelectViewport {
+    private readonly contentContext;
+    private readonly elementRef;
+    private readonly prevScrollTopRef;
+    constructor();
+    handleScroll(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectViewport, "[rdxSelectViewport]", never, {}, {}, never, never, true, never>;
 }
 
-export { RdxSelectComponent, RdxSelectContentDirective, RdxSelectGroupDirective, RdxSelectIconDirective, RdxSelectItemChange, RdxSelectItemDirective, RdxSelectItemIndicatorDirective, RdxSelectLabelDirective, RdxSelectModule, RdxSelectSeparatorDirective, RdxSelectTriggerDirective, RdxSelectValueDirective };
+declare const OPEN_KEYS: string[];
+declare const SELECTION_KEYS: string[];
+declare const CONTENT_MARGIN = 10;
+declare function valueComparator<T>(value: T | T[] | undefined, currentValue: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;
+declare function compare<T>(value?: T, currentValue?: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;
+declare function shouldShowPlaceholder(value?: AcceptableValue | AcceptableValue[]): boolean;
+declare function focusFirst(candidates: HTMLElement[]): void;
+
+declare const _importsSelect: (typeof RdxSelectLabel)[];
+
+export { CONTENT_MARGIN, OPEN_KEYS, RDX_SELECT_POSITIONER_TOKEN, RdxSelectContent, RdxSelectGroup, RdxSelectItem, RdxSelectItemIndicator, RdxSelectItemText, RdxSelectLabel, RdxSelectPopperPositionContent, RdxSelectPopperPositionWrapper, RdxSelectPortal, RdxSelectPortalPresence, RdxSelectRoot, RdxSelectTrigger, RdxSelectValue, RdxSelectViewport, SELECTION_KEYS, _importsSelect, compare, focusFirst, injectSelectContentContext, injectSelectItemContext, injectSelectRootContext, provideSelectContentContext, provideSelectItemContext, provideSelectRootContext, shouldShowPlaceholder, valueComparator };
+export type { RdxPositionerImpl, RdxSelectContentContext, RdxSelectItemContext, RdxSelectRootContext, SelectEvent, SelectOption };