ng-primitives 0.90.0 → 0.91.1

package/a11y/index.d.ts

@@ -1,6 +1,5 @@
 import * as _angular_core from '@angular/core';
 import { Signal, ElementRef } from '@angular/core';
-import * as ng_primitives_state from 'ng-primitives/state';
 
 interface ActiveDescendantManagerOptions<T extends NgpActivatable> {
     /**
@@ -44,63 +43,56 @@ declare function activeDescendantManager<T extends NgpActivatable>(options: Acti
 };
 
 /**
- * Hide an element visually while keeping it present in the DOM.
+ * The state interface for the VisuallyHidden pattern.
  */
-declare class NgpVisuallyHidden {
-    private readonly changeDetector;
+interface NgpVisuallyHiddenState {
     /**
      * Whether the element is hidden.
      */
-    protected readonly hidden: _angular_core.WritableSignal<boolean>;
-    protected readonly style: _angular_core.Signal<{
-        position?: undefined;
-        width?: undefined;
-        height?: undefined;
-        margin?: undefined;
-        padding?: undefined;
-        overflow?: undefined;
-        clip?: undefined;
-        whiteSpace?: undefined;
-        border?: undefined;
-        wordWrap?: undefined;
-        outline?: undefined;
-        '-webkit-appearance'?: undefined;
-        '-moz-appearance'?: undefined;
-        'inset-inline-start'?: undefined;
-    } | {
-        position: string;
-        width: string;
-        height: string;
-        margin: string;
-        padding: string;
-        overflow: string;
-        clip: string;
-        whiteSpace: string;
-        border: string;
-        wordWrap: string;
-        outline: string;
-        '-webkit-appearance': string;
-        '-moz-appearance': string;
-        'inset-inline-start': string;
-    }>;
-    protected readonly state: ng_primitives_state.CreatedState<NgpVisuallyHidden>;
+    readonly hidden: Signal<boolean>;
     /**
      * Set the element visibility.
      * @param visible
      */
     setVisibility(visible: boolean): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpVisuallyHidden, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpVisuallyHidden, "[ngpVisuallyHidden]", ["ngpVisuallyHidden"], {}, {}, never, never, true, never>;
 }
-
 /**
- * Provides the VisuallyHidden state.
+ * The props interface for the VisuallyHidden pattern.
  */
-declare const provideVisuallyHiddenState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+interface NgpVisuallyHiddenProps {
+    /**
+     * Whether the element is hidden. Default is true.
+     */
+    readonly hidden?: Signal<boolean>;
+}
+declare const NgpVisuallyHiddenStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<NgpVisuallyHiddenState>>;
+declare const ngpVisuallyHidden: ({ hidden: _hidden }: NgpVisuallyHiddenProps) => NgpVisuallyHiddenState;
+declare const injectVisuallyHiddenState: {
+    (): Signal<NgpVisuallyHiddenState>;
+    (options: {
+        hoisted: true;
+    }): Signal<NgpVisuallyHiddenState | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<NgpVisuallyHiddenState | null>;
+};
+declare const provideVisuallyHiddenState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
 /**
- * Injects the VisuallyHidden state.
+ * Hide an element visually while keeping it present in the DOM.
  */
-declare const injectVisuallyHiddenState: <U = NgpVisuallyHidden>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+declare class NgpVisuallyHidden {
+    protected readonly state: NgpVisuallyHiddenState;
+    /**
+     * Set the element visibility.
+     * @param visible
+     */
+    setVisibility(visible: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpVisuallyHidden, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpVisuallyHidden, "[ngpVisuallyHidden]", ["ngpVisuallyHidden"], {}, {}, never, never, true, never>;
+}
 
-export { NgpVisuallyHidden, activeDescendantManager, injectVisuallyHiddenState, provideVisuallyHiddenState };
-export type { NgpActivatable };
+export { NgpVisuallyHidden, NgpVisuallyHiddenStateToken, activeDescendantManager, injectVisuallyHiddenState, ngpVisuallyHidden, provideVisuallyHiddenState };
+export type { NgpActivatable, NgpVisuallyHiddenProps, NgpVisuallyHiddenState };

package/accordion/index.d.ts

@@ -1,118 +1,237 @@
-import * as ng_primitives_accordion from 'ng-primitives/accordion';
 import * as _angular_core from '@angular/core';
-import { Provider } from '@angular/core';
-import * as ng_primitives_state from 'ng-primitives/state';
-import { BooleanInput } from '@angular/cdk/coercion';
+import { Signal, WritableSignal, Provider } from '@angular/core';
 import { NgpOrientation } from 'ng-primitives/common';
+import { BooleanInput } from '@angular/cdk/coercion';
 
 /**
- * Apply the `ngpAccordion` directive to an element that represents the group of accordion items.
+ * Apply the `ngpAccordionContent` directive to an element that represents the content of an accordion item.
  */
-declare class NgpAccordion<T> {
+declare class NgpAccordionContent<T> {
     /**
-     * Access the global accordion configuration.
+     * The id of the content region
      */
-    private readonly config;
+    readonly id: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAccordionContent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAccordionContent<any>, "[ngpAccordionContent]", ["ngpAccordionContent"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NgpAccordionContentState {
     /**
-     * The type of the accordion.
+     * The id of the content region
      */
-    readonly type: _angular_core.InputSignal<NgpAccordionType>;
+    readonly id: Signal<string>;
+}
+interface NgpAccordionContentProps {
     /**
-     * Whether the accordion is collapsible.
+     * The id of the content region
      */
-    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly id?: Signal<string>;
+}
+declare const NgpAccordionContentStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{}>>;
+declare const ngpAccordionContent: <T>({ id }: NgpAccordionContentProps) => {};
+declare const injectAccordionContentState: {
+    (): Signal<{}>;
+    (options: {
+        hoisted: true;
+    }): Signal<{} | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<{} | null>;
+};
+declare const provideAccordionContentState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+/**
+ * The state interface for the Accordion pattern.
+ */
+interface NgpAccordionState<T> {
     /**
      * The value of the accordion.
      */
-    readonly value: _angular_core.InputSignal<T | T[] | null>;
-    /**
-     * Event emitted when the accordion value changes.
-     */
-    readonly valueChange: _angular_core.OutputEmitterRef<T | T[] | null>;
+    readonly value: WritableSignal<T | T[] | null>;
     /**
      * Whether the accordion is disabled.
      */
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disabled: WritableSignal<boolean>;
     /**
      * The accordion orientation.
      */
-    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
+    readonly orientation: WritableSignal<NgpOrientation>;
     /**
-     * The accordion state.
+     * Set the value of the accordion.
      */
-    private readonly state;
+    setValue(value: T | T[] | null): void;
     /**
-     * @param value The value to check.
-     * @returns Whether the value is open.
-     * @internal
+     * Set the disabled state of the accordion.
+     */
+    setDisabled(value: boolean): void;
+    /**
+     * Set the orientation of the accordion.
+     */
+    setOrientation(value: NgpOrientation): void;
+    /**
+     * Whether the specified value is open.
      */
     isOpen(value: T): boolean;
+    /**
+     * Toggle the specified value.
+     */
     toggle(value: T): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAccordion<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAccordion<any>, "[ngpAccordion]", ["ngpAccordion"], { "type": { "alias": "ngpAccordionType"; "required": false; "isSignal": true; }; "collapsible": { "alias": "ngpAccordionCollapsible"; "required": false; "isSignal": true; }; "value": { "alias": "ngpAccordionValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpAccordionDisabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "ngpAccordionOrientation"; "required": false; "isSignal": true; }; }, { "valueChange": "ngpAccordionValueChange"; }, never, never, true, never>;
 }
-type NgpAccordionType = 'single' | 'multiple';
-
 /**
- * Apply the `ngpAccordionContent` directive to an element that represents the content of an accordion item.
+ * The props interface for the Accordion pattern.
  */
-declare class NgpAccordionContent<T> {
-    /**
-     * Access the accordion content element reference
-     */
-    private readonly elementRef;
+interface NgpAccordionProps<T> {
     /**
-     * Access the accordion
+     * The type of the accordion.
      */
-    protected readonly accordion: _angular_core.Signal<ng_primitives_state.State<NgpAccordion<T>>>;
+    readonly type: Signal<NgpAccordionType>;
     /**
-     * Access the accordion item
+     * Whether the accordion is collapsible.
      */
-    protected readonly accordionItem: _angular_core.Signal<ng_primitives_state.State<ng_primitives_accordion.NgpAccordionItem<unknown>>>;
+    readonly collapsible: Signal<boolean>;
     /**
-     * The id of the content region
+     * The value of the accordion.
      */
-    readonly id: _angular_core.InputSignal<string>;
+    readonly value: Signal<T | T[] | null>;
     /**
-     * The dimensions of the content
+     * Whether the accordion is disabled.
      */
-    private dimensions;
+    readonly disabled?: Signal<boolean>;
     /**
-     * The hidden until-found state of the content
+     * The accordion orientation.
      */
-    protected readonly hidden: _angular_core.Signal<"until-found" | null>;
-    constructor();
+    readonly orientation: Signal<NgpOrientation>;
     /**
-     * Handle the beforematch event to automatically open the accordion item
-     * when the browser's find-in-page functionality tries to reveal hidden content.
+     * Callback fired when valueChange is emitted.
      */
-    protected onBeforeMatch(): void;
-    private updateDimensions;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAccordionContent<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAccordionContent<any>, "[ngpAccordionContent]", ["ngpAccordionContent"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    readonly onValueChange?: (value: T | T[] | null) => void;
 }
+declare const NgpAccordionStateToken: _angular_core.InjectionToken<WritableSignal<NgpAccordionState<unknown>>>;
+declare const ngpAccordion: <T>({ type, collapsible, value: _value, disabled: _disabled, orientation: _orientation, onValueChange, }: NgpAccordionProps<T>) => NgpAccordionState<T>;
+declare const provideAccordionState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+type NgpAccordionType = 'single' | 'multiple';
+declare function injectAccordionState<T>(): Signal<NgpAccordionState<T>>;
 
 /**
- * Apply the `ngpAccordionTrigger` directive to an element that represents the trigger for an accordion item, such as a button.
+ * Apply the `ngpAccordionItem` directive to an element that represents an accordion item.
  */
-declare class NgpAccordionTrigger<T> {
+declare class NgpAccordionItem<T> {
+    /**
+     * Access the accordion.
+     */
+    protected readonly accordion: _angular_core.Signal<NgpAccordionState<T>>;
+    /**
+     * The value of the accordion item.
+     */
+    readonly value: _angular_core.InputSignal<T>;
+    /**
+     * Whether the accordion item is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The accordion item state.
+     */
+    protected readonly state: {
+        value: _angular_core.Signal<T>;
+        open: _angular_core.Signal<boolean>;
+        disabled: _angular_core.WritableSignal<boolean>;
+        triggerId: _angular_core.WritableSignal<string | undefined>;
+        contentId: _angular_core.WritableSignal<string | undefined>;
+        setDisabled: (value: boolean) => void;
+        setTrigger: (id: string) => void;
+        setContent: (id: string) => void;
+    };
+    /**
+     * The open state of the accordion item.
+     */
+    readonly open: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAccordionItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAccordionItem<any>, "[ngpAccordionItem]", ["ngpAccordionItem"], { "value": { "alias": "ngpAccordionItemValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpAccordionItemDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NgpAccordionItemState<T> {
+    /**
+     * The value of the accordion item.
+     */
+    readonly value: Signal<T>;
+    /**
+     * Whether the accordion item is disabled.
+     */
+    readonly disabled: Signal<boolean>;
+    /**
+     * Whether the accordion item is expanded.
+     */
+    readonly open: Signal<boolean>;
+    /**
+     * The trigger id.
+     */
+    readonly triggerId: Signal<string | undefined>;
     /**
-     * The tag name of the element.
+     * The content id.
      */
-    protected readonly tagName: string;
+    readonly contentId: Signal<string | undefined>;
     /**
-     * Access the parent accordion.
+     * Set the disabled state of the accordion item.
      */
-    protected readonly accordion: _angular_core.Signal<ng_primitives_state.State<NgpAccordion<T>>>;
+    setDisabled(value: boolean): void;
     /**
-     * The item instance.
+     * Set the trigger of the accordion item.
      */
-    protected readonly accordionItem: _angular_core.Signal<ng_primitives_state.State<NgpAccordionItem<T>>>;
+    setTrigger(id: string): void;
+    /**
+     * Set the content of the accordion item.
+     */
+    setContent(id: string): void;
+}
+interface NgpAccordionItemProps<T> {
+    /**
+     * The value of the accordion item.
+     */
+    readonly value: Signal<T>;
+    /**
+     * Whether the accordion item is disabled.
+     */
+    readonly disabled?: Signal<boolean>;
+}
+declare const NgpAccordionItemStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{
+    value: Signal<unknown>;
+    open: Signal<boolean>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    triggerId: _angular_core.WritableSignal<string | undefined>;
+    contentId: _angular_core.WritableSignal<string | undefined>;
+    setDisabled: (value: boolean) => void;
+    setTrigger: (id: string) => void;
+    setContent: (id: string) => void;
+}>>;
+declare const ngpAccordionItem: <T>({ value, disabled: _disabled }: NgpAccordionItemProps<T>) => {
+    value: Signal<T>;
+    open: Signal<boolean>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    triggerId: _angular_core.WritableSignal<string | undefined>;
+    contentId: _angular_core.WritableSignal<string | undefined>;
+    setDisabled: (value: boolean) => void;
+    setTrigger: (id: string) => void;
+    setContent: (id: string) => void;
+};
+declare const provideAccordionItemState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+declare function injectAccordionItemState<T>(): Signal<NgpAccordionItemState<T>>;
+
+/**
+ * Apply the `ngpAccordionTrigger` directive to an element that represents the trigger for an accordion item, such as a button.
+ */
+declare class NgpAccordionTrigger<T> {
     /**
      * The id of the trigger.
      */
     readonly id: _angular_core.InputSignal<string>;
-    constructor();
+    private readonly state;
     /**
      * Toggle the accordion item.
      */
@@ -122,69 +241,52 @@ declare class NgpAccordionTrigger<T> {
 }
 
 /**
- * Apply the `ngpAccordionItem` directive to an element that represents an accordion item.
+ * Apply the `ngpAccordion` directive to an element that represents the group of accordion items.
  */
-declare class NgpAccordionItem<T> {
+declare class NgpAccordion<T> {
     /**
-     * Access the accordion.
+     * Access the global accordion configuration.
      */
-    protected readonly accordion: _angular_core.Signal<ng_primitives_state.State<NgpAccordion<T>>>;
+    private readonly config;
     /**
-     * The value of the accordion item.
+     * The type of the accordion.
      */
-    readonly value: _angular_core.InputSignal<T>;
+    readonly type: _angular_core.InputSignal<NgpAccordionType>;
     /**
-     * Whether the accordion item is disabled.
+     * Whether the accordion is collapsible.
      */
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Access the accordion trigger
-     * @internal
+     * The value of the accordion.
      */
-    readonly trigger: _angular_core.WritableSignal<NgpAccordionTrigger<T> | undefined>;
+    readonly value: _angular_core.InputSignal<T | T[] | null>;
     /**
-     * Access the accordion content
-     * @internal
+     * Event emitted when the accordion value changes.
      */
-    readonly content: _angular_core.WritableSignal<NgpAccordionContent<T> | undefined>;
+    readonly valueChange: _angular_core.OutputEmitterRef<T | T[] | null>;
     /**
-     * Whether the accordion item is expanded.
+     * Whether the accordion is disabled.
      */
-    readonly open: _angular_core.Signal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * The trigger id.
+     * The accordion orientation.
      */
-    readonly triggerId: _angular_core.Signal<string | undefined>;
+    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
     /**
-     * The content id.
+     * The accordion state.
      */
-    readonly contentId: _angular_core.Signal<string | undefined>;
+    protected readonly state: NgpAccordionState<T>;
     /**
-     * The accordion item state.
+     * @param value The value to check.
+     * @returns Whether the value is open.
+     * @internal
      */
-    private readonly state;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAccordionItem<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAccordionItem<any>, "[ngpAccordionItem]", ["ngpAccordionItem"], { "value": { "alias": "ngpAccordionItemValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpAccordionItemDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    isOpen(value: T): boolean;
+    toggle(value: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAccordion<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAccordion<any>, "[ngpAccordion]", ["ngpAccordion"], { "type": { "alias": "ngpAccordionType"; "required": false; "isSignal": true; }; "collapsible": { "alias": "ngpAccordionCollapsible"; "required": false; "isSignal": true; }; "value": { "alias": "ngpAccordionValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpAccordionDisabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "ngpAccordionOrientation"; "required": false; "isSignal": true; }; }, { "valueChange": "ngpAccordionValueChange"; }, never, never, true, never>;
 }
 
-/**
- * Provides the AccordionItem state.
- */
-declare const provideAccordionItemState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
-/**
- * Injects the AccordionItem state.
- */
-declare const injectAccordionItemState: <U = NgpAccordionItem<unknown>>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
-
-/**
- * Provides the Accordion state.
- */
-declare const provideAccordionState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
-/**
- * Injects the Accordion state.
- */
-declare const injectAccordionState: <U = NgpAccordion<unknown>>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
-
 interface NgpAccordionConfig {
     /**
      * The default type of the accordion
@@ -209,5 +311,51 @@ interface NgpAccordionConfig {
  */
 declare function provideAccordionConfig(config: Partial<NgpAccordionConfig>): Provider[];
 
-export { NgpAccordion, NgpAccordionContent, NgpAccordionItem, NgpAccordionTrigger, injectAccordionItemState, injectAccordionState, provideAccordionConfig, provideAccordionItemState, provideAccordionState };
-export type { NgpAccordionConfig };
+interface NgpAccordionTriggerState {
+    /**
+     * The id of the trigger button
+     */
+    readonly id: Signal<string>;
+    /**
+     * Toggle the accordion item.
+     */
+    toggle(): void;
+}
+interface NgpAccordionTriggerProps {
+    /**
+     * The id of the trigger button
+     */
+    readonly id?: Signal<string>;
+}
+declare const NgpAccordionTriggerStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{
+    id: Signal<string>;
+    toggle: () => void;
+}>>;
+declare const ngpAccordionTrigger: <T>({ id }: NgpAccordionTriggerProps) => {
+    id: Signal<string>;
+    toggle: () => void;
+};
+declare const injectAccordionTriggerState: {
+    (): Signal<{
+        id: Signal<string>;
+        toggle: () => void;
+    }>;
+    (options: {
+        hoisted: true;
+    }): Signal<{
+        id: Signal<string>;
+        toggle: () => void;
+    } | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<{
+        id: Signal<string>;
+        toggle: () => void;
+    } | null>;
+};
+declare const provideAccordionTriggerState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+export { NgpAccordion, NgpAccordionContent, NgpAccordionContentStateToken, NgpAccordionItem, NgpAccordionItemStateToken, NgpAccordionStateToken, NgpAccordionTrigger, NgpAccordionTriggerStateToken, injectAccordionContentState, injectAccordionItemState, injectAccordionState, injectAccordionTriggerState, ngpAccordion, ngpAccordionContent, ngpAccordionItem, ngpAccordionTrigger, provideAccordionConfig, provideAccordionContentState, provideAccordionItemState, provideAccordionState, provideAccordionTriggerState };
+export type { NgpAccordionConfig, NgpAccordionContentProps, NgpAccordionContentState, NgpAccordionItemProps, NgpAccordionItemState, NgpAccordionProps, NgpAccordionState, NgpAccordionTriggerProps, NgpAccordionTriggerState, NgpAccordionType };

package/ai/index.d.ts

@@ -16,7 +16,7 @@ declare class NgpPromptComposerInput {
      * If the user presses Enter, the form will be submitted, unless they are holding Shift.
      * This directive automatically handles that behavior.
      */
-    protected onEnterKey(event: KeyboardEvent): void;
+    protected onEnterKey(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpPromptComposerInput, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpPromptComposerInput, "input[ngpPromptComposerInput], textarea[ngpPromptComposerInput]", ["ngpPromptComposerInput"], {}, {}, never, never, true, never>;
 }

package/autofill/index.d.ts

@@ -1,22 +1,62 @@
 import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
 
+/**
+ * Apply the `ngpAutofill` directive to an element to detect browser autofill.
+ */
 declare class NgpAutofill {
     /**
-     * Access the style injector.
+     * Event emitted when the autofill state changes.
      */
-    private readonly styleInjector;
+    readonly autofillChange: _angular_core.OutputEmitterRef<boolean>;
     /**
-     * Store the autofill state.
+     * The autofill state.
      */
-    protected readonly autofilled: _angular_core.WritableSignal<boolean>;
+    private readonly state;
     /**
-     * Emit when the autofill state changes.
+     * Whether the element is autofilled.
      */
-    readonly autofillChange: _angular_core.OutputEmitterRef<boolean>;
-    constructor();
-    protected onAnimationStart(event: AnimationEvent): void;
+    readonly autofilled: _angular_core.WritableSignal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAutofill, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAutofill, "[ngpAutofill]", ["ngpAutofill"], {}, { "autofillChange": "ngpAutofill"; }, never, never, true, never>;
 }
 
-export { NgpAutofill };
+interface NgpAutofillState {
+    /**
+     * Whether the element is autofilled.
+     */
+    readonly autofilled: Signal<boolean>;
+}
+interface NgpAutofillProps {
+    /**
+     * Callback fired when the autofill state changes.
+     */
+    onAutofillChange?: (value: boolean) => void;
+}
+declare const NgpAutofillStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<{
+    autofilled: _angular_core.WritableSignal<boolean>;
+}>>;
+declare const ngpAutofill: ({ onAutofillChange }: NgpAutofillProps) => {
+    autofilled: _angular_core.WritableSignal<boolean>;
+};
+declare const injectAutofillState: {
+    (): Signal<{
+        autofilled: _angular_core.WritableSignal<boolean>;
+    }>;
+    (options: {
+        hoisted: true;
+    }): Signal<{
+        autofilled: _angular_core.WritableSignal<boolean>;
+    } | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<{
+        autofilled: _angular_core.WritableSignal<boolean>;
+    } | null>;
+};
+declare const provideAutofillState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+export { NgpAutofill, NgpAutofillStateToken, injectAutofillState, ngpAutofill, provideAutofillState };
+export type { NgpAutofillProps, NgpAutofillState };