ng-primitives 0.120.4 → 0.121.0

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

@@ -0,0 +1,687 @@
+import * as _angular_core from '@angular/core';
+import { Signal, ElementRef, WritableSignal, OnDestroy, Provider } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as ng_primitives_state from 'ng-primitives/state';
+import { StateInjectionOptions, SetterOptions } from 'ng-primitives/state';
+import { Placement } from '@floating-ui/dom';
+import * as ng_primitives_a11y from 'ng-primitives/a11y';
+import { activeDescendantManager } from 'ng-primitives/a11y';
+import * as ng_primitives_portal from 'ng-primitives/portal';
+import { NgpOverlay, NgpFlip, NgpOffset, NgpFlipInput, NgpOffsetInput } from 'ng-primitives/portal';
+import { Observable } from 'rxjs';
+import * as ng_primitives_select from 'ng-primitives/select';
+
+/**
+ * Apply the `ngpNativeSelect` directive to a select element that you want to enhance.
+ */
+declare class NgpNativeSelect {
+    /**
+     * The id of the select. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Whether the select is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpNativeSelect, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpNativeSelect, "select[ngpNativeSelect]", ["ngpNativeSelect"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpNativeSelectDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const injectNativeSelectState: {
+    (): Signal<{
+        disabled: _angular_core.WritableSignal<boolean>;
+        setDisabled: (value: boolean) => void;
+    }>;
+    (options: ng_primitives_state.StateInjectionOptions): Signal<{
+        disabled: _angular_core.WritableSignal<boolean>;
+        setDisabled: (value: boolean) => void;
+    } | null>;
+    (options?: ng_primitives_state.StateInjectionOptions): Signal<{
+        disabled: _angular_core.WritableSignal<boolean>;
+        setDisabled: (value: boolean) => void;
+    }> | Signal<{
+        disabled: _angular_core.WritableSignal<boolean>;
+        setDisabled: (value: boolean) => void;
+    } | null>;
+};
+declare const provideNativeSelectState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+declare class NgpSelectDropdown {
+    /** The id of the dropdown. */
+    readonly id: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSelectDropdown, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSelectDropdown, "[ngpSelectDropdown]", ["ngpSelectDropdown"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NgpSelectDropdownState {
+    /**
+     * @internal Access the element reference.
+     */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** The id of the dropdown. */
+    readonly id: Signal<string>;
+}
+interface NgpSelectDropdownProps {
+    /** The id of the dropdown. */
+    readonly id?: Signal<string>;
+}
+declare const NgpSelectDropdownStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{
+    elementRef: ElementRef<HTMLElement>;
+    id: Signal<string>;
+}>>;
+declare const ngpSelectDropdown: ({ id: _id }: NgpSelectDropdownProps) => {
+    elementRef: ElementRef<HTMLElement>;
+    id: Signal<string>;
+};
+declare const provideSelectDropdownState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+declare function injectSelectDropdownState(options?: StateInjectionOptions): Signal<NgpSelectDropdownState>;
+
+interface NgpSelectOptionState {
+    /**
+     * @internal Access the element reference.
+     */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** The id of the option. */
+    readonly id: Signal<string>;
+    /** The value of the option. */
+    readonly value: Signal<any>;
+    /** The disabled state of the option. */
+    readonly disabled: Signal<boolean>;
+    /** The index of the option in the list. */
+    readonly index: Signal<number | undefined>;
+    /**
+     * Whether this option is the active descendant.
+     * @internal
+     */
+    readonly active: Signal<boolean>;
+    /**
+     * Whether this option is selected.
+     * @internal
+     */
+    readonly selected: Signal<boolean>;
+    /**
+     * Select the option.
+     * @internal
+     */
+    select(): void;
+    /**
+     * Scroll the option into view.
+     * @internal
+     */
+    scrollIntoView(): void;
+    /**
+     * Activate on pointer enter.
+     * @internal
+     */
+    activateOnPointerEnter(): void;
+    /**
+     * Deactivate on pointer leave.
+     * @internal
+     */
+    deactivateOnPointerLeave(): void;
+    /**
+     * Emit activated event.
+     * @internal
+     */
+    emitActivated(): void;
+}
+interface NgpSelectOptionProps {
+    /** The id of the option. */
+    readonly id?: Signal<string>;
+    /** The value of the option. */
+    readonly value?: Signal<any>;
+    /** The disabled state of the option. */
+    readonly disabled?: Signal<boolean>;
+    /** The index of the option in the list. */
+    readonly index?: Signal<number | undefined>;
+    /** Callback when option is activated. */
+    readonly onActivated?: () => void;
+}
+declare const NgpSelectOptionStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{
+    elementRef: ElementRef<HTMLElement>;
+    id: Signal<string>;
+    value: Signal<any>;
+    disabled: Signal<boolean>;
+    index: Signal<number | undefined>;
+    active: Signal<boolean>;
+    selected: Signal<boolean>;
+    select: () => void;
+    scrollIntoView: () => void;
+    activateOnPointerEnter: () => void;
+    deactivateOnPointerLeave: () => void;
+    emitActivated: () => void | undefined;
+}>>;
+declare const ngpSelectOption: ({ id, value, disabled, index, onActivated, }: NgpSelectOptionProps) => {
+    elementRef: ElementRef<HTMLElement>;
+    id: Signal<string>;
+    value: Signal<any>;
+    disabled: Signal<boolean>;
+    index: Signal<number | undefined>;
+    active: Signal<boolean>;
+    selected: Signal<boolean>;
+    select: () => void;
+    scrollIntoView: () => void;
+    activateOnPointerEnter: () => void;
+    deactivateOnPointerLeave: () => void;
+    emitActivated: () => void | undefined;
+};
+declare const provideSelectOptionState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+declare function injectSelectOptionState(options?: StateInjectionOptions): Signal<NgpSelectOptionState>;
+
+interface NgpSelectPortalState {
+    /**
+     * The overlay that manages the dropdown.
+     * @internal
+     */
+    readonly overlay: Signal<NgpOverlay<void> | null>;
+    /**
+     * Show the portal.
+     * @internal
+     */
+    show(): Promise<void>;
+    /**
+     * Hide the portal.
+     * @internal
+     */
+    hide(): void;
+    /**
+     * Destroy the overlay. The directive class calls this from ngOnDestroy so
+     * the overlay's onClose callback fires while the parent NgpSelect's output
+     * bindings are still attached — destroyRef.onDestroy callbacks fire after
+     * Angular has already torn those bindings down, which would prevent
+     * openChange(false) from reaching the consumer on fixture.destroy().
+     * @internal
+     */
+    destroy(): void;
+}
+interface NgpSelectPortalProps {
+}
+declare const NgpSelectPortalStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<NgpSelectPortalState>>;
+declare const ngpSelectPortal: ({}: NgpSelectPortalProps) => NgpSelectPortalState;
+declare const provideSelectPortalState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+declare function injectSelectPortalState(options?: StateInjectionOptions): Signal<NgpSelectPortalState>;
+
+interface NgpSelectState<T> {
+    /**
+     * @internal Access the select element.
+     */
+    readonly elementRef: ElementRef<HTMLElement>;
+    /** The unique id of the select. */
+    readonly id: Signal<string>;
+    /** The value of the select. */
+    readonly value: WritableSignal<T | undefined>;
+    /** Whether the select is multiple selection. */
+    readonly multiple: Signal<boolean>;
+    /** Whether the select is disabled. */
+    readonly disabled: WritableSignal<boolean>;
+    /** The comparator function used to compare options. */
+    readonly compareWith: Signal<(a: T | undefined, b: T | undefined) => boolean>;
+    /** The position of the dropdown. */
+    readonly placement: Signal<Placement>;
+    /** The container for the dropdown. */
+    readonly container: Signal<HTMLElement | string | null>;
+    /** Whether the dropdown should flip when there is not enough space. Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options. */
+    readonly flip: Signal<NgpFlip>;
+    /**
+     * Define the offset of the select dropdown relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     */
+    readonly offset: Signal<NgpOffset>;
+    /**
+     * A function that will scroll the active option into view. This can be overridden
+     * for cases such as virtual scrolling where we cannot scroll the option directly because
+     * it may not be rendered.
+     */
+    readonly scrollToOption: Signal<((index: number) => void) | undefined>;
+    /**
+     * Provide all the option values to the select. This is useful for virtual scrolling scenarios
+     * where not all options are rendered in the DOM. This is not an alternative to adding the options
+     * in the DOM, it is only to provide the select with the full list of options. This list should match
+     * the order of the options as they would appear in the DOM.
+     */
+    readonly allOptions: Signal<T[] | undefined>;
+    /**
+     * Store the select portal.
+     * @internal
+     */
+    readonly portal: WritableSignal<NgpSelectPortalState | undefined>;
+    /**
+     * Store the select dropdown.
+     * @internal
+     */
+    readonly dropdown: WritableSignal<NgpSelectDropdownState | undefined>;
+    /**
+     * Store the select options.
+     * @internal
+     */
+    readonly options: WritableSignal<NgpSelectOptionState[]>;
+    /**
+     * Access the overlay
+     * @internal
+     */
+    readonly overlay: Signal<NgpOverlay<void> | null | undefined>;
+    /**
+     * The open state of the select.
+     * @internal
+     */
+    readonly open: Signal<boolean>;
+    /**
+     * The options sorted by their index or DOM position.
+     * @internal
+     */
+    readonly sortedOptions: Signal<NgpSelectOptionState[]>;
+    /**
+     * The active key descendant manager.
+     * @internal
+     */
+    readonly activeDescendantManager: ReturnType<typeof activeDescendantManager>;
+    /**
+     * Open the dropdown.
+     * @internal
+     */
+    openDropdown(): Promise<void>;
+    /**
+     * Close the dropdown.
+     * @internal
+     */
+    closeDropdown(): void;
+    /**
+     * Handle the overlay being closed (e.g. via outside click or Escape).
+     * Emits the openChange event and resets the active descendant.
+     * @internal
+     */
+    onOverlayClose(): void;
+    /**
+     * Toggle the dropdown.
+     * @internal
+     */
+    toggleDropdown(): Promise<void>;
+    /**
+     * Select an option.
+     * @param index The index of the option to select.
+     * @internal
+     */
+    selectOption(id: string): void;
+    /**
+     * Deselect an option.
+     * @param option The option to deselect.
+     * @internal
+     */
+    deselectOption(option: NgpSelectOptionState): void;
+    /**
+     * Toggle the selection of an option.
+     * @param id The id of the option to toggle.
+     * @internal
+     */
+    toggleOption(id: string): void;
+    /**
+     * Determine if an option is selected.
+     * @param option The option to check.
+     * @internal
+     */
+    isOptionSelected(option: T): boolean;
+    /**
+     * Activate the next option in the list if there is one.
+     * If there is no option currently active, activate the selected option or the first option.
+     * @internal
+     */
+    activateNextOption(): void;
+    /**
+     * Activate the previous option in the list if there is one.
+     * @internal
+     */
+    activatePreviousOption(): void;
+    /**
+     * Register the dropdown portal with the select.
+     * @param portal The dropdown portal.
+     * @internal
+     */
+    registerPortal(portal: NgpSelectPortalState): void;
+    /**
+     * Register the dropdown with the select.
+     * @param dropdown The dropdown to register.
+     * @internal
+     */
+    registerDropdown(dropdown: NgpSelectDropdownState): void;
+    /**
+     * Register an option with the select.
+     * @param option The option to register.
+     * @internal
+     */
+    registerOption(option: NgpSelectOptionState): void;
+    /**
+     * Unregister an option from the select.
+     * @param option The option to unregister.
+     * @internal
+     */
+    unregisterOption(option: NgpSelectOptionState): void;
+    /**
+     * Focus the select.
+     * @internal
+     */
+    focus(): void;
+    /**
+     * Programmatically set the value of the select. Fires `onValueChange` and
+     * emits on `valueChange` by default. Pass `{ emit: false }` for cases like
+     * form `writeValue` where the internal state should sync without notifying.
+     */
+    setValue(value: T | undefined, options?: SetterOptions): void;
+    /**
+     * Programmatically set the disabled state of the select. Used by the form
+     * `setDisabledState` integration.
+     */
+    setDisabled(disabled: boolean): void;
+    /**
+     * Observable that emits whenever the value changes.
+     */
+    readonly valueChange: Observable<T | undefined>;
+}
+interface NgpSelectProps<T> {
+    /** The unique id of the select. */
+    readonly id?: Signal<string>;
+    /** The value of the select. */
+    readonly value?: Signal<T | undefined>;
+    /** Event emitted when the value changes. */
+    readonly onValueChange?: (value: T) => void;
+    /** Whether the select is multiple selection. */
+    readonly multiple?: Signal<boolean>;
+    /** Whether the select is disabled. */
+    readonly disabled?: Signal<boolean>;
+    /** Emit when the dropdown open state changes. */
+    readonly onOpenChange?: (open: boolean) => void;
+    /** The comparator function used to compare options. */
+    readonly compareWith?: Signal<(a: T | undefined, b: T | undefined) => boolean>;
+    /** The position of the dropdown. */
+    readonly placement?: Signal<Placement>;
+    /** The container for the dropdown. */
+    readonly container?: Signal<HTMLElement | string | null>;
+    /** Whether the dropdown should flip when there is not enough space. Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options. */
+    readonly flip?: Signal<NgpFlip>;
+    /**
+     * Define the offset of the select dropdown relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     */
+    readonly offset?: Signal<NgpOffset>;
+    /**
+     * A function that will scroll the active option into view. This can be overridden
+     * for cases such as virtual scrolling where we cannot scroll the option directly because
+     * it may not be rendered.
+     */
+    readonly scrollToOption?: Signal<((index: number) => void) | undefined>;
+    /**
+     * Provide all the option values to the select. This is useful for virtual scrolling scenarios
+     * where not all options are rendered in the DOM. This is not an alternative to adding the options
+     * in the DOM, it is only to provide the select with the full list of options. This list should match
+     * the order of the options as they would appear in the DOM.
+     */
+    readonly allOptions?: Signal<T[] | undefined>;
+}
+declare const NgpSelectStateToken: _angular_core.InjectionToken<WritableSignal<NgpSelectState<unknown>>>;
+declare const ngpSelect: <T>({ id, value: _value, multiple, disabled: _disabled, compareWith, placement, container, flip, offset, scrollToOption, allOptions, onValueChange, onOpenChange, }: NgpSelectProps<T>) => NgpSelectState<T>;
+declare const provideSelectState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+declare function injectSelectState<T>(options?: StateInjectionOptions): Signal<NgpSelectState<T>>;
+
+declare class NgpSelectOption {
+    /** Access the select state. */
+    protected readonly selectState: _angular_core.Signal<NgpSelectState<unknown>>;
+    /** The id of the option. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** @required The value of the option. */
+    readonly value: _angular_core.InputSignal<any>;
+    /** The disabled state of the option. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The index of the option in the list. */
+    readonly index: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Event emitted when the option is activated via click or keyboard.
+     * This is useful for options without values that need custom behavior.
+     */
+    readonly activated: _angular_core.OutputEmitterRef<void>;
+    /** Access the select option state */
+    protected readonly state: {
+        elementRef: _angular_core.ElementRef<HTMLElement>;
+        id: _angular_core.Signal<string>;
+        value: _angular_core.Signal<any>;
+        disabled: _angular_core.Signal<boolean>;
+        index: _angular_core.Signal<number | undefined>;
+        active: _angular_core.Signal<boolean>;
+        selected: _angular_core.Signal<boolean>;
+        select: () => void;
+        scrollIntoView: () => void;
+        activateOnPointerEnter: () => void;
+        deactivateOnPointerLeave: () => void;
+        emitActivated: () => void | undefined;
+    };
+    /**
+     * Select the option.
+     * @internal
+     */
+    select(): void;
+    /**
+     * Scroll the option into view.
+     * @internal
+     */
+    scrollIntoView(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSelectOption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSelectOption, "[ngpSelectOption]", ["ngpSelectOption"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "ngpSelectOptionValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpSelectOptionDisabled"; "required": false; "isSignal": true; }; "index": { "alias": "ngpSelectOptionIndex"; "required": false; "isSignal": true; }; }, { "activated": "ngpSelectOptionActivated"; }, never, never, true, never>;
+}
+
+declare class NgpSelectPortal implements OnDestroy {
+    protected readonly state: NgpSelectPortalState;
+    /**
+     * Attach the portal.
+     * @internal
+     */
+    show(): Promise<void>;
+    /**
+     * Detach the portal.
+     * @internal
+     */
+    detach(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSelectPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSelectPortal, "[ngpSelectPortal]", ["ngpSelectPortal"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Ideally we would use a generic type here, unfortunately, unlike in React,
+ * we cannot infer the type based on another input. For example, if multiple
+ * is true, we cannot infer that the value is an array of T. Using a union
+ * type is not ideal either because it requires the user to handle multiple cases.
+ * Using a generic also isn't ideal because we need to use T as both an array and
+ * a single value.
+ *
+ * Any seems to be used by Angular Material, ng-select, and other libraries
+ * so we will use it here as well.
+ */
+type T = any;
+declare class NgpSelect {
+    /** Access the select configuration. */
+    protected readonly config: ng_primitives_select.NgpSelectConfig;
+    /** The unique id of the select. */
+    readonly id: _angular_core.InputSignal<string>;
+    /** The value of the select. */
+    readonly value: _angular_core.InputSignal<any>;
+    /** Event emitted when the value changes. */
+    readonly valueChange: _angular_core.OutputEmitterRef<any>;
+    /** Whether the select is multiple selection. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the select is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Emit when the dropdown open state changes. */
+    readonly openChange: _angular_core.OutputEmitterRef<boolean>;
+    /** The comparator function used to compare options. */
+    readonly compareWith: _angular_core.InputSignal<(a: T | undefined, b: T | undefined) => boolean>;
+    /** The position of the dropdown. */
+    readonly placement: _angular_core.InputSignal<Placement>;
+    /** The container for the dropdown. */
+    readonly container: _angular_core.InputSignal<string | HTMLElement | null>;
+    /** Whether the dropdown should flip when there is not enough space. Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options. */
+    readonly flip: _angular_core.InputSignalWithTransform<NgpFlip, NgpFlipInput>;
+    /**
+     * Define the offset of the select dropdown relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 0
+     */
+    readonly offset: _angular_core.InputSignalWithTransform<NgpOffset, NgpOffsetInput>;
+    /**
+     * A function that will scroll the active option into view. This can be overridden
+     * for cases such as virtual scrolling where we cannot scroll the option directly because
+     * it may not be rendered.
+     */
+    readonly scrollToOption: _angular_core.InputSignal<((index: number) => void) | undefined>;
+    /**
+     * Provide all the option values to the select. This is useful for virtual scrolling scenarios
+     * where not all options are rendered in the DOM. This is not an alternative to adding the options
+     * in the DOM, it is only to provide the select with the full list of options. This list should match
+     * the order of the options as they would appear in the DOM.
+     */
+    readonly allOptions: _angular_core.InputSignal<any[] | undefined>;
+    /** The state of the select. */
+    protected readonly state: NgpSelectState<any>;
+    /** @internal Access the select element. */
+    readonly elementRef: _angular_core.ElementRef<HTMLElement>;
+    /**
+     * Store the select portal.
+     * @internal
+     */
+    readonly portal: _angular_core.WritableSignal<NgpSelectPortalState | undefined>;
+    /**
+     * Store the select dropdown.
+     * @internal
+     */
+    readonly dropdown: _angular_core.WritableSignal<NgpSelectDropdownState | undefined>;
+    /**
+     * Store the select options.
+     * @internal
+     */
+    readonly options: _angular_core.WritableSignal<NgpSelectOptionState[]>;
+    /**
+     * Access the overlay
+     * @internal
+     */
+    readonly overlay: _angular_core.Signal<ng_primitives_portal.NgpOverlay<void> | null | undefined>;
+    /**
+     * The open state of the select.
+     * @internal
+     */
+    readonly open: _angular_core.Signal<boolean>;
+    /**
+     * The options sorted by their index or DOM position.
+     * @internal
+     */
+    readonly sortedOptions: _angular_core.Signal<NgpSelectOptionState[]>;
+    /**
+     * The active key descendant manager.
+     * @internal
+     */
+    readonly activeDescendantManager: {
+        id: _angular_core.Signal<string | undefined>;
+        index: _angular_core.WritableSignal<number>;
+        activateByIndex: (index: number, { scroll, origin }?: ng_primitives_a11y.ActivationOptions) => void;
+        activateById: (id: string, options?: ng_primitives_a11y.ActivationOptions) => void;
+        first: (options?: ng_primitives_a11y.ActivationOptions) => void;
+        last: (options?: ng_primitives_a11y.ActivationOptions) => void;
+        next: (options?: ng_primitives_a11y.ActivationOptions) => void;
+        previous: (options?: ng_primitives_a11y.ActivationOptions) => void;
+        reset: ({ scroll, origin }?: ng_primitives_a11y.ActivationOptions) => void;
+        validate: () => void;
+    };
+    /**
+     * Open the dropdown.
+     * @internal
+     */
+    openDropdown(): Promise<void>;
+    /**
+     * Close the dropdown.
+     * @internal
+     */
+    closeDropdown(): void;
+    /**
+     * Toggle the dropdown.
+     * @internal
+     */
+    toggleDropdown(): Promise<void>;
+    /**
+     * Select an option.
+     * @param id The id of the option to select.
+     * @internal
+     */
+    selectOption(id: string): void;
+    /**
+     * Determine if an option is selected.
+     * @param option The option to check.
+     * @internal
+     */
+    isOptionSelected(option: T): boolean;
+    /**
+     * Activate the next option in the list if there is one.
+     * If there is no option currently active, activate the selected option or the first option.
+     * @internal
+     */
+    activateNextOption(): void;
+    /**
+     * Activate the previous option in the list if there is one.
+     * @internal
+     */
+    activatePreviousOption(): void;
+    /**
+     * Focus the select.
+     * @internal
+     */
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSelect, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSelect, "[ngpSelect]", ["ngpSelect"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "ngpSelectValue"; "required": false; "isSignal": true; }; "multiple": { "alias": "ngpSelectMultiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpSelectDisabled"; "required": false; "isSignal": true; }; "compareWith": { "alias": "ngpSelectCompareWith"; "required": false; "isSignal": true; }; "placement": { "alias": "ngpSelectDropdownPlacement"; "required": false; "isSignal": true; }; "container": { "alias": "ngpSelectDropdownContainer"; "required": false; "isSignal": true; }; "flip": { "alias": "ngpSelectDropdownFlip"; "required": false; "isSignal": true; }; "offset": { "alias": "ngpSelectDropdownOffset"; "required": false; "isSignal": true; }; "scrollToOption": { "alias": "ngpSelectScrollToOption"; "required": false; "isSignal": true; }; "allOptions": { "alias": "ngpSelectOptions"; "required": false; "isSignal": true; }; }, { "valueChange": "ngpSelectValueChange"; "openChange": "ngpSelectOpenChange"; }, never, never, true, never>;
+}
+
+interface NgpSelectConfig {
+    /**
+     * The default placement for the select dropdown.
+     * @default 'bottom'
+     */
+    placement: Placement;
+    /**
+     * The container element or selector for the select dropdown.
+     * This can be used to control where the dropdown is rendered in the DOM.
+     * @default 'body'
+     */
+    container: HTMLElement | string | null;
+    /**
+     * Whether the select dropdown should flip when there is not enough space.
+     * Can be a boolean to enable/disable, or an object with padding and fallbackPlacements options.
+     * @default true
+     */
+    flip: NgpFlip;
+    /**
+     * Define the offset of the select dropdown relative to the trigger.
+     * Can be a number (applies to mainAxis) or an object with mainAxis, crossAxis, and alignmentAxis.
+     * @default 0
+     */
+    offset: NgpOffset;
+}
+/**
+ * Provide the default Select configuration
+ * @param config The Select configuration
+ * @returns The provider
+ */
+declare function provideSelectConfig(config: Partial<NgpSelectConfig>): Provider[];
+/**
+ * Inject the Select configuration
+ * @returns The global Select configuration
+ */
+declare function injectSelectConfig(): NgpSelectConfig;
+
+export { NgpNativeSelect, NgpSelect, NgpSelectDropdown, NgpSelectDropdownStateToken, NgpSelectOption, NgpSelectOptionStateToken, NgpSelectPortal, NgpSelectPortalStateToken, NgpSelectStateToken, injectNativeSelectState, injectSelectConfig, injectSelectDropdownState, injectSelectOptionState, injectSelectPortalState, injectSelectState, ngpSelect, ngpSelectDropdown, ngpSelectOption, ngpSelectPortal, provideNativeSelectState, provideSelectConfig, provideSelectDropdownState, provideSelectOptionState, provideSelectPortalState, provideSelectState };
+export type { NgpSelectConfig };