ng-primitives 0.88.0 → 0.90.0

package/a11y/index.d.ts

@@ -1,3 +1,106 @@
-export * from './active-descendant/active-descendant';
-export * from './visually-hidden/visually-hidden';
-export { injectVisuallyHiddenState, provideVisuallyHiddenState, } from './visually-hidden/visually-hidden-state';
+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> {
+    /**
+     * The disabled state of the active descendant group.
+     * @default false
+     */
+    disabled?: Signal<boolean>;
+    /**
+     * The items in the active descendant group.
+     */
+    items: Signal<T[]>;
+    /**
+     * Whether active descendant should wrap around.
+     * @default false
+     */
+    wrap?: Signal<boolean>;
+}
+interface NgpActivatable {
+    /**
+     * The id of the item.
+     */
+    id: Signal<string>;
+    /**
+     * Whether the item is disabled.
+     */
+    disabled?: Signal<boolean>;
+    /**
+     * The element that represents the item.
+     */
+    elementRef: ElementRef<HTMLElement>;
+}
+declare function activeDescendantManager<T extends NgpActivatable>(options: ActiveDescendantManagerOptions<T>): {
+    activeDescendant: Signal<string | undefined>;
+    activeItem: Signal<T | undefined>;
+    activate: (item: T | undefined) => void;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    previous: () => void;
+    reset: () => void;
+};
+
+/**
+ * Hide an element visually while keeping it present in the DOM.
+ */
+declare class NgpVisuallyHidden {
+    private readonly changeDetector;
+    /**
+     * 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>;
+    /**
+     * 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.
+ */
+declare const provideVisuallyHiddenState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the VisuallyHidden state.
+ */
+declare const injectVisuallyHiddenState: <U = NgpVisuallyHidden>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpVisuallyHidden, activeDescendantManager, injectVisuallyHiddenState, provideVisuallyHiddenState };
+export type { NgpActivatable };

package/accordion/index.d.ts

@@ -1,7 +1,213 @@
-export { NgpAccordionContent } from './accordion-content/accordion-content';
-export { NgpAccordionItem } from './accordion-item/accordion-item';
-export { injectAccordionItemState, provideAccordionItemState, } from './accordion-item/accordion-item-state';
-export { NgpAccordionTrigger } from './accordion-trigger/accordion-trigger';
-export { NgpAccordion } from './accordion/accordion';
-export { injectAccordionState, provideAccordionState } from './accordion/accordion-state';
-export { NgpAccordionConfig, provideAccordionConfig } from './config/accordion-config';
+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 { NgpOrientation } from 'ng-primitives/common';
+
+/**
+ * Apply the `ngpAccordion` directive to an element that represents the group of accordion items.
+ */
+declare class NgpAccordion<T> {
+    /**
+     * Access the global accordion configuration.
+     */
+    private readonly config;
+    /**
+     * The type of the accordion.
+     */
+    readonly type: _angular_core.InputSignal<NgpAccordionType>;
+    /**
+     * Whether the accordion is collapsible.
+     */
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * 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>;
+    /**
+     * Whether the accordion is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The accordion orientation.
+     */
+    readonly orientation: _angular_core.InputSignal<NgpOrientation>;
+    /**
+     * The accordion state.
+     */
+    private readonly state;
+    /**
+     * @param value The value to check.
+     * @returns Whether the value is open.
+     * @internal
+     */
+    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>;
+}
+type NgpAccordionType = 'single' | 'multiple';
+
+/**
+ * Apply the `ngpAccordionContent` directive to an element that represents the content of an accordion item.
+ */
+declare class NgpAccordionContent<T> {
+    /**
+     * Access the accordion content element reference
+     */
+    private readonly elementRef;
+    /**
+     * Access the accordion
+     */
+    protected readonly accordion: _angular_core.Signal<ng_primitives_state.State<NgpAccordion<T>>>;
+    /**
+     * Access the accordion item
+     */
+    protected readonly accordionItem: _angular_core.Signal<ng_primitives_state.State<ng_primitives_accordion.NgpAccordionItem<unknown>>>;
+    /**
+     * The id of the content region
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * The dimensions of the content
+     */
+    private dimensions;
+    /**
+     * The hidden until-found state of the content
+     */
+    protected readonly hidden: _angular_core.Signal<"until-found" | null>;
+    constructor();
+    /**
+     * Handle the beforematch event to automatically open the accordion item
+     * when the browser's find-in-page functionality tries to reveal hidden content.
+     */
+    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>;
+}
+
+/**
+ * Apply the `ngpAccordionTrigger` directive to an element that represents the trigger for an accordion item, such as a button.
+ */
+declare class NgpAccordionTrigger<T> {
+    /**
+     * The tag name of the element.
+     */
+    protected readonly tagName: string;
+    /**
+     * Access the parent accordion.
+     */
+    protected readonly accordion: _angular_core.Signal<ng_primitives_state.State<NgpAccordion<T>>>;
+    /**
+     * The item instance.
+     */
+    protected readonly accordionItem: _angular_core.Signal<ng_primitives_state.State<NgpAccordionItem<T>>>;
+    /**
+     * The id of the trigger.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    constructor();
+    /**
+     * Toggle the accordion item.
+     */
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAccordionTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAccordionTrigger<any>, "[ngpAccordionTrigger]", ["ngpAccordionTrigger"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Apply the `ngpAccordionItem` directive to an element that represents an accordion item.
+ */
+declare class NgpAccordionItem<T> {
+    /**
+     * Access the accordion.
+     */
+    protected readonly accordion: _angular_core.Signal<ng_primitives_state.State<NgpAccordion<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>;
+    /**
+     * Access the accordion trigger
+     * @internal
+     */
+    readonly trigger: _angular_core.WritableSignal<NgpAccordionTrigger<T> | undefined>;
+    /**
+     * Access the accordion content
+     * @internal
+     */
+    readonly content: _angular_core.WritableSignal<NgpAccordionContent<T> | undefined>;
+    /**
+     * Whether the accordion item is expanded.
+     */
+    readonly open: _angular_core.Signal<boolean>;
+    /**
+     * The trigger id.
+     */
+    readonly triggerId: _angular_core.Signal<string | undefined>;
+    /**
+     * The content id.
+     */
+    readonly contentId: _angular_core.Signal<string | undefined>;
+    /**
+     * The accordion item state.
+     */
+    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>;
+}
+
+/**
+ * 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
+     * @default 'single'
+     */
+    type: NgpAccordionType;
+    /**
+     * Whether the accordion is collapsible
+     * @default false
+     */
+    collapsible: boolean;
+    /**
+     * The default orientation of the accordion
+     * @default 'vertical'
+     */
+    orientation: 'vertical' | 'horizontal';
+}
+/**
+ * Provide the default Accordion configuration
+ * @param config The Accordion configuration
+ * @returns The provider
+ */
+declare function provideAccordionConfig(config: Partial<NgpAccordionConfig>): Provider[];
+
+export { NgpAccordion, NgpAccordionContent, NgpAccordionItem, NgpAccordionTrigger, injectAccordionItemState, injectAccordionState, provideAccordionConfig, provideAccordionItemState, provideAccordionState };
+export type { NgpAccordionConfig };

package/ai/index.d.ts

@@ -1,16 +1,238 @@
-export { NgpPromptComposerInput } from './prompt-composer-input/prompt-composer-input';
-export { NgpPromptComposerSubmit } from './prompt-composer-submit/prompt-composer-submit';
-export { NgpPromptComposer } from './prompt-composer/prompt-composer';
-export { NgpThreadMessage } from './thread-message/thread-message';
-export { NgpThread } from './thread/thread';
-export { NgpPromptComposerDictation } from './prompt-composer-dictation/prompt-composer-dictation';
-export { NgpThreadViewport } from './thread-viewport/thread-viewport';
-export { NgpThreadSuggestion } from './thread-suggestion/thread-suggestion';
-export { providePromptComposerState, injectPromptComposerState, } from './prompt-composer/prompt-composer-state';
-export { providePromptComposerDictationState, injectPromptComposerDictationState, } from './prompt-composer-dictation/prompt-composer-dictation-state';
-export { providePromptComposerInputState, injectPromptComposerInputState, } from './prompt-composer-input/prompt-composer-input-state';
-export { providePromptComposerSubmitState, injectPromptComposerSubmitState, } from './prompt-composer-submit/prompt-composer-submit-state';
-export { provideThreadState, injectThreadState } from './thread/thread-state';
-export { provideThreadSuggestionState, injectThreadSuggestionState, } from './thread-suggestion/thread-suggestion-state';
-export { provideThreadViewportState, injectThreadViewportState, } from './thread-viewport/thread-viewport-state';
-export { provideThreadMessageState, injectThreadMessageState, } from './thread-message/thread-message-state';
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import * as ng_primitives_state from 'ng-primitives/state';
+import * as ng_primitives_ai from 'ng-primitives/ai';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { Subject } from 'rxjs';
+
+declare class NgpPromptComposerInput {
+    protected readonly thread: _angular_core.Signal<ng_primitives_state.State<ng_primitives_ai.NgpThread>>;
+    private readonly composer;
+    private readonly element;
+    /** The state of the prompt composer input. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpPromptComposerInput>;
+    constructor();
+    /**
+     * 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;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpPromptComposerInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpPromptComposerInput, "input[ngpPromptComposerInput], textarea[ngpPromptComposerInput]", ["ngpPromptComposerInput"], {}, {}, never, never, true, never>;
+}
+
+declare class NgpPromptComposerSubmit {
+    protected readonly composer: _angular_core.Signal<ng_primitives_state.State<ng_primitives_ai.NgpPromptComposer>>;
+    /** Whether the submit button should be disabled */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether dictation is currently active */
+    readonly isDictating: _angular_core.Signal<boolean>;
+    /** The state of the prompt composer submit. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpPromptComposerSubmit>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpPromptComposerSubmit, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpPromptComposerSubmit, "button[ngpPromptComposerSubmit]", ["ngpPromptComposerSubmit"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgpPromptComposer {
+    private readonly thread;
+    /** Emits whenever the user submits the prompt. */
+    readonly submit: _angular_core.OutputEmitterRef<string>;
+    /** @internal Store the current prompt text. */
+    readonly prompt: _angular_core.WritableSignal<string>;
+    /** @internal Track whether the prompt is currently being dictated */
+    readonly isDictating: _angular_core.WritableSignal<boolean>;
+    /** @internal Determine whether the prompt input has content */
+    readonly hasPrompt: _angular_core.Signal<boolean>;
+    /** Whether dictation is supported by the browser */
+    readonly dictationSupported: boolean;
+    /** The state of the prompt composer. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpPromptComposer>;
+    /**
+     * @internal
+     * Submits the current prompt if there is content, and clears the input.
+     */
+    submitPrompt(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpPromptComposer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpPromptComposer, "[ngpPromptComposer]", ["ngpPromptComposer"], {}, { "submit": "ngpPromptComposerSubmit"; }, never, never, true, never>;
+}
+
+declare class NgpThreadMessage {
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly thread;
+    /** The state of the thread message. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpThreadMessage>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpThreadMessage, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpThreadMessage, "[ngpThreadMessage]", ["ngpThreadMessage"], {}, {}, never, never, true, never>;
+}
+
+declare class NgpThread {
+    private messages;
+    /** @internal emit event to trigger scrolling to bottom */
+    readonly scrollRequest: Subject<ScrollBehavior>;
+    /** @internal emit event to trigger setting the prompt */
+    readonly requestPrompt: Subject<string>;
+    /** The state of the thread. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpThread>;
+    scrollToBottom(behavior: ScrollBehavior): void;
+    /** @internal Register a message with the thread */
+    registerMessage(message: NgpThreadMessage): void;
+    /** @internal Unregister a message from the thread */
+    unregisterMessage(message: NgpThreadMessage): void;
+    /** @internal Determine if the given message is the last message in the thread */
+    isLastMessage(message: NgpThreadMessage): boolean;
+    /** @internal Set the prompt text in the associated prompt composer */
+    setPrompt(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpThread, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpThread, "[ngpThread]", ["ngpThread"], {}, {}, never, never, true, never>;
+}
+
+declare global {
+    interface Window {
+        SpeechRecognition: any;
+        webkitSpeechRecognition: any;
+    }
+}
+declare class NgpPromptComposerDictation implements OnDestroy {
+    protected readonly composer: _angular_core.Signal<ng_primitives_state.State<ng_primitives_ai.NgpPromptComposer>>;
+    private recognition;
+    private basePrompt;
+    /** Whether the submit button should be disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether dictation is currently active */
+    readonly isDictating: _angular_core.Signal<boolean>;
+    /** The state of the prompt composer. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpPromptComposerDictation>;
+    constructor();
+    ngOnDestroy(): void;
+    protected onClick(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private initializeSpeechRecognition;
+    private startDictation;
+    private stopDictation;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpPromptComposerDictation, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpPromptComposerDictation, "button[ngpPromptComposerDictation]", ["ngpPromptComposerDictation"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgpThreadViewport {
+    private readonly thread;
+    private readonly elementRef;
+    /**
+     * The distance in pixels from the bottom of the scrollable container that is considered "at the bottom".
+     * When the user scrolls within this threshold, the thread is treated as being at the bottom.
+     * This value is used to determine whether automatic scrolling to the bottom should occur,
+     * for example when new content is added or the container is resized.
+     *
+     * @default 70
+     */
+    readonly threshold: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * Whether the thread should automatically scroll to the bottom when new content is added.
+     */
+    readonly autoScroll: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Store the last known scroll position */
+    private lastScrollTop;
+    /** Determine if we are at the bottom of the scrollable container (within the threshold) */
+    protected isAtBottom: boolean;
+    /** The state of the thread viewport. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpThreadViewport>;
+    constructor();
+    /**
+     * Scroll the container to the bottom.
+     * @internal
+     */
+    scrollToBottom(behavior: ScrollBehavior): void;
+    protected onScroll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpThreadViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpThreadViewport, "[ngpThreadViewport]", ["ngpThreadViewport"], { "threshold": { "alias": "ngpThreadViewportThreshold"; "required": false; "isSignal": true; }; "autoScroll": { "alias": "ngpThreadViewportAutoScroll"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgpThreadSuggestion {
+    private readonly thread;
+    /** The suggested text to display in the input field. */
+    readonly suggestion: _angular_core.InputSignal<string>;
+    /** Whether the suggestion should populate the prompt when clicked. */
+    readonly setPromptOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** The state of the thread suggestion. */
+    protected readonly state: ng_primitives_state.CreatedState<NgpThreadSuggestion>;
+    submitSuggestion(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpThreadSuggestion, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpThreadSuggestion, "button[ngpThreadSuggestion]", ["ngpThreadSuggestion"], { "suggestion": { "alias": "ngpThreadSuggestion"; "required": false; "isSignal": true; }; "setPromptOnClick": { "alias": "ngpThreadSuggestionSetPromptOnClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Provides the PromptComposer state.
+ */
+declare const providePromptComposerState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the PromptComposer state.
+ */
+declare const injectPromptComposerState: <U = NgpPromptComposer>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Provides the PromptComposerDictation state.
+ */
+declare const providePromptComposerDictationState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the PromptComposerDictation state.
+ */
+declare const injectPromptComposerDictationState: <U = NgpPromptComposerDictation>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Provides the PromptComposerInput state.
+ */
+declare const providePromptComposerInputState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the PromptComposerInput state.
+ */
+declare const injectPromptComposerInputState: <U = NgpPromptComposerInput>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Provides the PromptComposerSubmit state.
+ */
+declare const providePromptComposerSubmitState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the PromptComposerSubmit state.
+ */
+declare const injectPromptComposerSubmitState: <U = NgpPromptComposerSubmit>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Provides the Thread state.
+ */
+declare const provideThreadState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the Thread state.
+ */
+declare const injectThreadState: <U = NgpThread>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Provides the ThreadSuggestion state.
+ */
+declare const provideThreadSuggestionState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the ThreadSuggestion state.
+ */
+declare const injectThreadSuggestionState: <U = NgpThreadSuggestion>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Provides the ThreadViewport state.
+ */
+declare const provideThreadViewportState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the ThreadViewport state.
+ */
+declare const injectThreadViewportState: <U = NgpThreadViewport>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * Provides the ThreadMessage state.
+ */
+declare const provideThreadMessageState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the ThreadMessage state.
+ */
+declare const injectThreadMessageState: <U = NgpThreadMessage>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpPromptComposer, NgpPromptComposerDictation, NgpPromptComposerInput, NgpPromptComposerSubmit, NgpThread, NgpThreadMessage, NgpThreadSuggestion, NgpThreadViewport, injectPromptComposerDictationState, injectPromptComposerInputState, injectPromptComposerState, injectPromptComposerSubmitState, injectThreadMessageState, injectThreadState, injectThreadSuggestionState, injectThreadViewportState, providePromptComposerDictationState, providePromptComposerInputState, providePromptComposerState, providePromptComposerSubmitState, provideThreadMessageState, provideThreadState, provideThreadSuggestionState, provideThreadViewportState };

package/autofill/index.d.ts

@@ -1 +1,22 @@
-export { NgpAutofill } from './autofill/autofill';
+import * as _angular_core from '@angular/core';
+
+declare class NgpAutofill {
+    /**
+     * Access the style injector.
+     */
+    private readonly styleInjector;
+    /**
+     * Store the autofill state.
+     */
+    protected readonly autofilled: _angular_core.WritableSignal<boolean>;
+    /**
+     * Emit when the autofill state changes.
+     */
+    readonly autofillChange: _angular_core.OutputEmitterRef<boolean>;
+    constructor();
+    protected onAnimationStart(event: AnimationEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpAutofill, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpAutofill, "[ngpAutofill]", ["ngpAutofill"], {}, { "autofillChange": "ngpAutofill"; }, never, never, true, never>;
+}
+
+export { NgpAutofill };