ng-primitives 0.89.0 → 0.91.0

package/slider/index.d.ts

@@ -1,10 +1,471 @@
-export { NgpSliderRange } from './slider-range/slider-range';
-export { NgpSliderThumb } from './slider-thumb/slider-thumb';
-export { NgpSliderTrack } from './slider-track/slider-track';
-export { NgpSlider } from './slider/slider';
-export { injectSliderState, provideSliderState } from './slider/slider-state';
-export { NgpRangeSliderRange } from './range-slider/range-slider-range/range-slider-range';
-export { NgpRangeSliderThumb } from './range-slider/range-slider-thumb/range-slider-thumb';
-export { NgpRangeSliderTrack } from './range-slider/range-slider-track/range-slider-track';
-export { NgpRangeSlider } from './range-slider/range-slider/range-slider';
-export { injectRangeSliderState, provideRangeSliderState, } from './range-slider/range-slider/range-slider-state';
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, ElementRef, OnDestroy } from '@angular/core';
+import { NgpOrientation } from 'ng-primitives/common';
+import { Subject } from 'rxjs';
+import { NumberInput, BooleanInput } from '@angular/cdk/coercion';
+import * as ng_primitives_state from 'ng-primitives/state';
+import * as ng_primitives_slider from 'ng-primitives/slider';
+
+/**
+ * Apply the `ngpSliderRange` directive to an element that represents the range of the slider.
+ */
+declare class NgpSliderRange {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSliderRange, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSliderRange, "[ngpSliderRange]", ["ngpSliderRange"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Public state surface for the Slider Range primitive.
+ */
+interface NgpSliderRangeState {
+}
+/**
+ * Inputs for configuring the Slider Range primitive.
+ */
+interface NgpSliderRangeProps {
+}
+declare const ngpSliderRange: ({}: NgpSliderRangeProps) => NgpSliderRangeState;
+declare const injectSliderRangeState: {
+    (): _angular_core.Signal<NgpSliderRangeState>;
+    (options: {
+        hoisted: true;
+    }): _angular_core.Signal<NgpSliderRangeState | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): _angular_core.Signal<NgpSliderRangeState | null>;
+};
+declare const provideSliderRangeState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+/**
+ * Apply the `ngpSliderThumb` directive to an element that represents the thumb of the slider.
+ */
+declare class NgpSliderThumb {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSliderThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSliderThumb, "[ngpSliderThumb]", ["ngpSliderThumb"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Public state surface for the Slider Thumb primitive.
+ */
+interface NgpSliderThumbState {
+    /**
+     * Whether the thumb is currently dragging.
+     */
+    readonly dragging: Signal<boolean>;
+    /**
+     * Focus the thumb element.
+     */
+    focus(): void;
+}
+/**
+ * Inputs for configuring the Slider Thumb primitive.
+ */
+interface NgpSliderThumbProps {
+}
+declare const ngpSliderThumb: ({}: NgpSliderThumbProps) => NgpSliderThumbState;
+declare const injectSliderThumbState: {
+    (): Signal<NgpSliderThumbState>;
+    (options: {
+        hoisted: true;
+    }): Signal<NgpSliderThumbState | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<NgpSliderThumbState | null>;
+};
+declare const provideSliderThumbState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+/**
+ * Apply the `ngpSliderTrack` directive to an element that represents the track of the slider.
+ */
+declare class NgpSliderTrack {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSliderTrack, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSliderTrack, "[ngpSliderTrack]", ["ngpSliderTrack"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Public state surface for the Slider Track primitive.
+ */
+interface NgpSliderTrackState {
+}
+/**
+ * Inputs for configuring the Slider Track primitive.
+ */
+interface NgpSliderTrackProps {
+}
+declare const ngpSliderTrack: ({}: NgpSliderTrackProps) => NgpSliderTrackState;
+declare const injectSliderTrackState: {
+    (): _angular_core.Signal<NgpSliderTrackState>;
+    (options: {
+        hoisted: true;
+    }): _angular_core.Signal<NgpSliderTrackState | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): _angular_core.Signal<NgpSliderTrackState | null>;
+};
+declare const provideSliderTrackState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+/**
+ * Public state surface for the Slider primitive.
+ */
+interface NgpSliderState {
+    /**
+     * The id of the slider.
+     */
+    readonly id: Signal<string>;
+    /**
+     * The slider value.
+     */
+    readonly value: WritableSignal<number>;
+    /**
+     * The slider orientation.
+     */
+    readonly orientation: WritableSignal<NgpOrientation>;
+    /**
+     * Whether the slider is disabled (includes form control state).
+     */
+    readonly disabled: WritableSignal<boolean>;
+    /**
+     * The percentage position of the thumb.
+     */
+    readonly percentage: Signal<number>;
+    /**
+     * The minimum value of the slider.
+     */
+    readonly min: Signal<number>;
+    /**
+     * The maximum value of the slider.
+     */
+    readonly max: Signal<number>;
+    /**
+     * The step value of the slider.
+     */
+    readonly step: Signal<number>;
+    /**
+     * @internal The track element reference.
+     */
+    readonly track: Signal<ElementRef<HTMLElement> | undefined>;
+    /**
+     * Emit when the value changes.
+     */
+    readonly valueChange: Subject<number>;
+    /**
+     * Set the current value (clamped).
+     */
+    setValue(value: number): void;
+    /**
+     * Register the track element.
+     */
+    setTrack(track: ElementRef<HTMLElement> | undefined): void;
+    /**
+     * Set the disabled state.
+     */
+    setDisabled(disabled: boolean): void;
+    /**
+     * Set the orientation.
+     */
+    setOrientation(orientation: NgpOrientation): void;
+}
+/**
+ * Inputs for configuring the Slider primitive.
+ */
+interface NgpSliderProps {
+    /**
+     * The id of the slider.
+     */
+    readonly id?: Signal<string>;
+    /**
+     * The slider value.
+     */
+    readonly value?: Signal<number>;
+    /**
+     * The minimum value.
+     */
+    readonly min?: Signal<number>;
+    /**
+     * The maximum value.
+     */
+    readonly max?: Signal<number>;
+    /**
+     * The step value.
+     */
+    readonly step?: Signal<number>;
+    /**
+     * The slider orientation.
+     */
+    readonly orientation?: Signal<NgpOrientation>;
+    /**
+     * Whether the slider is disabled.
+     */
+    readonly disabled?: Signal<boolean>;
+    /**
+     * Callback fired when the value changes.
+     */
+    readonly onValueChange?: (value: number) => void;
+}
+declare const ngpSlider: ({ id, value: _value, min, max, step, orientation: _orientation, disabled: _disabled, onValueChange, }: NgpSliderProps) => NgpSliderState;
+declare const injectSliderState: {
+    (): Signal<NgpSliderState>;
+    (options: {
+        hoisted: true;
+    }): Signal<NgpSliderState | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<NgpSliderState | null>;
+};
+declare const provideSliderState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+/**
+ * Apply the `ngpSlider` directive to an element that represents the slider and contains the track, range, and thumb.
+ */
+declare class NgpSlider {
+    /**
+     * The id of the slider. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * The value of the slider.
+     */
+    readonly value: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Emits when the value changes.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<number>;
+    /**
+     * The minimum value of the slider.
+     */
+    readonly min: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The maximum value of the slider.
+     */
+    readonly max: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The step value of the slider.
+     */
+    readonly step: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The orientation of the slider.
+     */
+    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
+    /**
+     * The disabled state of the slider.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The state of the slider. We use this for the slider state rather than relying on the inputs.
+     * @internal
+     */
+    protected readonly state: NgpSliderState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSlider, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSlider, "[ngpSlider]", ["ngpSlider"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "ngpSliderValue"; "required": false; "isSignal": true; }; "min": { "alias": "ngpSliderMin"; "required": false; "isSignal": true; }; "max": { "alias": "ngpSliderMax"; "required": false; "isSignal": true; }; "step": { "alias": "ngpSliderStep"; "required": false; "isSignal": true; }; "orientation": { "alias": "ngpSliderOrientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpSliderDisabled"; "required": false; "isSignal": true; }; }, { "valueChange": "ngpSliderValueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Apply the `ngpRangeSliderRange` directive to an element that represents the range between the low and high values.
+ */
+declare class NgpRangeSliderRange {
+    /**
+     * Access the range slider state.
+     */
+    protected readonly rangeSliderState: _angular_core.Signal<ng_primitives_state.State<ng_primitives_slider.NgpRangeSlider>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpRangeSliderRange, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpRangeSliderRange, "[ngpRangeSliderRange]", ["ngpRangeSliderRange"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Apply the `ngpRangeSliderThumb` directive to an element that represents a thumb of the range slider.
+ * Each thumb can be configured to control either the 'low' or 'high' value.
+ */
+declare class NgpRangeSliderThumb implements OnDestroy {
+    /**
+     * Access the range slider state.
+     */
+    protected readonly state: _angular_core.Signal<ng_primitives_state.State<ng_primitives_slider.NgpRangeSlider>>;
+    /**
+     * Access the thumb element.
+     */
+    private readonly elementRef;
+    /**
+     * Determines which value this thumb controls ('low' or 'high').
+     */
+    protected readonly thumb: _angular_core.Signal<"low" | "high">;
+    /**
+     * Store the dragging state.
+     */
+    protected dragging: boolean;
+    /**
+     * Get the current value for this thumb.
+     */
+    protected readonly value: _angular_core.Signal<number>;
+    /**
+     * Get the current percentage for this thumb.
+     */
+    protected readonly percentage: _angular_core.Signal<number>;
+    constructor();
+    ngOnDestroy(): void;
+    protected handlePointerDown(event: PointerEvent): void;
+    protected handlePointerUp(): void;
+    protected handlePointerMove(event: PointerEvent): void;
+    /**
+     * Handle keyboard events.
+     * @param event
+     */
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpRangeSliderThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpRangeSliderThumb, "[ngpRangeSliderThumb]", ["ngpRangeSliderThumb"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Apply the `ngpRangeSliderTrack` directive to an element that represents the track of the range slider.
+ */
+declare class NgpRangeSliderTrack {
+    /**
+     * Access the range slider state.
+     */
+    protected readonly rangeSliderState: _angular_core.Signal<ng_primitives_state.State<ng_primitives_slider.NgpRangeSlider>>;
+    /**
+     * The element that represents the slider track.
+     */
+    readonly element: _angular_core.ElementRef<HTMLElement>;
+    constructor();
+    /**
+     * When the slider track is clicked, update the closest thumb value.
+     * @param event The click event.
+     */
+    protected handlePointerDown(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpRangeSliderTrack, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpRangeSliderTrack, "[ngpRangeSliderTrack]", ["ngpRangeSliderTrack"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Apply the `ngpRangeSlider` directive to an element that represents the range slider and contains the track, range, and thumbs.
+ */
+declare class NgpRangeSlider {
+    /**
+     * The id of the range slider. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * The low value of the range slider.
+     */
+    readonly low: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Emits when the low value changes.
+     */
+    readonly lowChange: _angular_core.OutputEmitterRef<number>;
+    /**
+     * The high value of the range slider.
+     */
+    readonly high: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Emits when the high value changes.
+     */
+    readonly highChange: _angular_core.OutputEmitterRef<number>;
+    /**
+     * The minimum value of the range slider.
+     */
+    readonly min: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The maximum value of the range slider.
+     */
+    readonly max: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The step value of the range slider.
+     */
+    readonly step: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The orientation of the range slider.
+     */
+    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
+    /**
+     * The disabled state of the range slider.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Access the slider track.
+     * @internal
+     */
+    readonly track: _angular_core.WritableSignal<NgpRangeSliderTrack | undefined>;
+    /**
+     * The thumbs of the range slider.
+     * @internal
+     */
+    readonly thumbs: _angular_core.WritableSignal<NgpRangeSliderThumb[]>;
+    /**
+     * The low value as a percentage based on the min and max values.
+     * @internal
+     */
+    readonly lowPercentage: _angular_core.Signal<number>;
+    /**
+     * The high value as a percentage based on the min and max values.
+     * @internal
+     */
+    readonly highPercentage: _angular_core.Signal<number>;
+    /**
+     * The range between low and high values as a percentage.
+     * @internal
+     */
+    readonly rangePercentage: _angular_core.Signal<number>;
+    /**
+     * The state of the range slider. We use this for the range slider state rather than relying on the inputs.
+     * @internal
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpRangeSlider>;
+    constructor();
+    /**
+     * Updates the low value, ensuring it doesn't exceed the high value.
+     * @param value The new low value
+     * @internal
+     */
+    setLowValue(value: number): void;
+    /**
+     * Updates the high value, ensuring it doesn't go below the low value.
+     * @param value The new high value
+     * @internal
+     */
+    setHighValue(value: number): void;
+    /**
+     * Determines which thumb should be moved based on the position clicked.
+     * @param percentage The percentage position of the click
+     * @returns 'low' or 'high' indicating which thumb should move
+     *
+     * @internal
+     */
+    getClosestThumb(percentage: number): 'low' | 'high';
+    /**
+     * Updates the thumbs array when a new thumb is added.
+     * @param thumb The new thumb to add
+     * @internal
+     */
+    addThumb(thumb: NgpRangeSliderThumb): void;
+    /**
+     * Removes a thumb from the thumbs array.
+     * @param thumb The thumb to remove
+     * @internal
+     */
+    removeThumb(thumb: NgpRangeSliderThumb): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpRangeSlider, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpRangeSlider, "[ngpRangeSlider]", ["ngpRangeSlider"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "low": { "alias": "ngpRangeSliderLow"; "required": false; "isSignal": true; }; "high": { "alias": "ngpRangeSliderHigh"; "required": false; "isSignal": true; }; "min": { "alias": "ngpRangeSliderMin"; "required": false; "isSignal": true; }; "max": { "alias": "ngpRangeSliderMax"; "required": false; "isSignal": true; }; "step": { "alias": "ngpRangeSliderStep"; "required": false; "isSignal": true; }; "orientation": { "alias": "ngpRangeSliderOrientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpRangeSliderDisabled"; "required": false; "isSignal": true; }; }, { "lowChange": "ngpRangeSliderLowChange"; "highChange": "ngpRangeSliderHighChange"; }, never, never, true, never>;
+}
+
+/**
+ * Provides the Range Slider state.
+ */
+declare const provideRangeSliderState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the Range Slider state.
+ */
+declare const injectRangeSliderState: <U = NgpRangeSlider>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpRangeSlider, NgpRangeSliderRange, NgpRangeSliderThumb, NgpRangeSliderTrack, NgpSlider, NgpSliderRange, NgpSliderThumb, NgpSliderTrack, injectRangeSliderState, injectSliderRangeState, injectSliderState, injectSliderThumbState, injectSliderTrackState, ngpSlider, ngpSliderRange, ngpSliderThumb, ngpSliderTrack, provideRangeSliderState, provideSliderRangeState, provideSliderState, provideSliderThumbState, provideSliderTrackState };
+export type { NgpSliderProps, NgpSliderRangeProps, NgpSliderRangeState, NgpSliderState, NgpSliderThumbProps, NgpSliderThumbState, NgpSliderTrackProps, NgpSliderTrackState };

package/state/index.d.ts

@@ -1,25 +1,26 @@
-import { FactoryProvider, InjectionToken, InjectOptions, InputSignal, InputSignalWithTransform, ProviderToken, Signal, WritableSignal } from '@angular/core';
+import { InputSignalWithTransform, WritableSignal, InputSignal, Signal, InjectionToken, ProviderToken, FactoryProvider, InjectOptions, Injector, ElementRef } from '@angular/core';
+
 /**
  * This converts the state object to a writable state object.
  * This means that inputs become signals which are writable.
  */
-export type State<T> = {
+type State<T> = {
     [K in keyof T]: T[K] extends InputSignalWithTransform<infer U, any> ? WritableSignal<U> : T[K] extends InputSignal<infer R> ? WritableSignal<R> : T[K];
 };
 /**
  * This is similar to the state object, but we don't expose properties that are not
  * inputs.
  */
-export type CreatedState<T> = {
+type CreatedState<T> = {
     [K in keyof T]: T[K] extends InputSignalWithTransform<infer U, any> ? WritableSignal<U> : T[K] extends InputSignal<infer R> ? WritableSignal<R> : never;
 };
-export type InjectedState<T> = Signal<State<T>>;
+type InjectedState<T> = Signal<State<T>>;
 /**
  * Create a new injection token for the state.
  * @param description The description of the token
  */
-export declare function createStateToken<T>(description: string): InjectionToken<T>;
-export interface CreateStateProviderOptions {
+declare function createStateToken<T>(description: string): InjectionToken<T>;
+interface CreateStateProviderOptions {
     /**
      * Whether we should check for the state in the parent injector.
      */
@@ -31,7 +32,7 @@ export interface CreateStateProviderOptions {
  * be useful to avoid issues where the injector can't be shared in some cases when ng-content is used.
  * @param token The token for the state
  */
-export declare function createStateProvider<T>(token: ProviderToken<T>): (options?: CreateStateProviderOptions) => FactoryProvider;
+declare function createStateProvider<T>(token: ProviderToken<T>): (options?: CreateStateProviderOptions) => FactoryProvider;
 type CreateStateInjectorOptions = {
     /**
      * Whether the state may not be immediately available. This can happen when the child is instantiated before the parent.
@@ -42,13 +43,69 @@ type CreateStateInjectorOptions = {
  * Create a new state injector for the state.
  * @param token The token for the state
  */
-export declare function createStateInjector<T>(token: ProviderToken<State<T>>, options: {
+declare function createStateInjector<T>(token: ProviderToken<State<T>>, options: {
     deferred: true;
 }): <U = T>(injectOptions?: InjectOptions) => Signal<State<U> | undefined>;
-export declare function createStateInjector<T>(token: ProviderToken<State<T>>, options?: CreateStateInjectorOptions): <U = T>(injectOptions?: InjectOptions) => Signal<State<U>>;
+declare function createStateInjector<T>(token: ProviderToken<State<T>>, options?: CreateStateInjectorOptions): <U = T>(injectOptions?: InjectOptions) => Signal<State<U>>;
 /**
  * Convert the original state object into a writable state object.
  * @param token The token for the state
  */
-export declare function createState(token: ProviderToken<WritableSignal<State<unknown>>>): <U>(state: U) => CreatedState<U>;
-export {};
+declare function createState(token: ProviderToken<WritableSignal<State<unknown>>>): <U>(state: U) => CreatedState<U>;
+interface CreatePrimitiveOptions {
+    injector?: Injector;
+    elementRef?: ElementRef<HTMLElement>;
+}
+type PrimitiveState<TFactory extends (...args: any[]) => unknown> = TFactory extends (props: unknown) => infer R ? R : TFactory extends (...args: any[]) => infer R ? R : never;
+type BasePrimitiveInjectionFn<TState> = {
+    (): Signal<TState>;
+    (options: {
+        hoisted: true;
+    }): Signal<TState | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<TState | null>;
+};
+type PrimitiveInjectionFn<TFactory extends (...args: any[]) => unknown> = TFactory extends (props: unknown) => infer R ? {
+    (): Signal<R>;
+    (options: {
+        hoisted: true;
+    }): Signal<R | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<R | null>;
+} : BasePrimitiveInjectionFn<PrimitiveState<TFactory>>;
+declare function createPrimitive<TFactory extends (...args: any[]) => unknown>(name: string, fn: TFactory, options?: CreatePrimitiveOptions): [
+    InjectionToken<WritableSignal<PrimitiveState<TFactory>>>,
+    TFactory,
+    PrimitiveInjectionFn<TFactory>,
+    (opts?: {
+        inherit?: boolean;
+    }) => FactoryProvider
+];
+declare function controlled<T>(value: Signal<T>): WritableSignal<T>;
+declare function attrBinding(element: ElementRef<HTMLElement>, attr: string, value: (() => string | number | boolean | null | undefined) | string | number | boolean | null | undefined): void;
+declare function styleBinding(element: ElementRef<HTMLElement>, style: string, value: (() => string | number | null) | string | number | null): void;
+declare function dataBinding(element: ElementRef<HTMLElement>, attr: string, value: (() => string | boolean | null) | string | boolean | null): void;
+declare function listener<K extends keyof HTMLElementEventMap>(element: HTMLElement | ElementRef<HTMLElement>, event: K, handler: (event: HTMLElementEventMap[K]) => void, options?: {
+    injector?: Injector;
+}): void;
+declare function listener(element: HTMLElement | ElementRef<HTMLElement>, event: string, handler: (event: Event) => void, options?: {
+    injector?: Injector;
+}): void;
+declare function onDestroy(callback: () => void): void;
+/**
+ * Previously, with our state approach, we allowed signals to be written directly using their setters.
+ * However, with our new approach, we want people to use the appropriate set method instead. This function takes in a writable
+ * signal and returns a proxy that warns the user when set is called directly.
+ */
+declare function deprecatedSetter<T>(signal: WritableSignal<T>, methodName: string): WritableSignal<T>;
+/**
+ * A utility function to inject an inherited state from a parent injector. This is useful for cases
+ * where a primitive needs to inherit state from a parent primitive, such as in roving focus groups.
+ * We could use inject with a forwardRef, but forwardRef returns an any - no thanks...
+ */
+declare function injectInheritedState<T>(token: () => InjectionToken<T>, injectOptions?: InjectOptions): T | null;
+
+export { attrBinding, controlled, createPrimitive, createState, createStateInjector, createStateProvider, createStateToken, dataBinding, deprecatedSetter, injectInheritedState, listener, onDestroy, styleBinding };
+export type { CreatePrimitiveOptions, CreateStateProviderOptions, CreatedState, InjectedState, State };