ng-primitives 0.89.0 → 0.91.0

package/utils/index.d.ts

@@ -1,9 +1,170 @@
-export { provideValueAccessor } from './forms/providers';
-export { controlStatus, NgpControlStatus } from './forms/status';
-export { ChangeFn, TouchedFn } from './forms/types';
-export { booleanAttributeBinding } from './helpers/attributes';
-export { injectDisposables } from './helpers/disposables';
-export { uniqueId } from './helpers/unique-id';
-export { isBoolean, isFunction, isNumber, isObject, isString, isUndefined, isNil, notNil, } from './helpers/validators';
-export { safeTakeUntilDestroyed } from './observables/take-until-destroyed';
-export { onBooleanChange, onChange } from './signals';
+import { Type, ExistingProvider, Signal, DestroyRef, Injector } from '@angular/core';
+import { MonoTypeOperatorFunction } from 'rxjs';
+
+/**
+ * A simple helper function to provide a value accessor for a given type.
+ * @param type The type to provide the value accessor for
+ */
+declare function provideValueAccessor<T>(type: Type<T>): ExistingProvider;
+
+interface NgpControlStatus {
+    valid: boolean | null;
+    invalid: boolean | null;
+    pristine: boolean | null;
+    dirty: boolean | null;
+    touched: boolean | null;
+    pending: boolean | null;
+    disabled: boolean | null;
+}
+/**
+ * A utility function to get the status of an Angular form control as a reactive signal.
+ * This function injects the NgControl and returns a signal that reflects the control's status.
+ * It supports both classic reactive forms controls and signal-forms interop controls.
+ * @internal
+ */
+declare function controlStatus(): Signal<NgpControlStatus>;
+
+/**
+ * A utility type for Angular's onChange function.
+ */
+type ChangeFn<T> = (value: T) => void;
+/**
+ * A utility type for Angular's onTouched function.
+ */
+type TouchedFn = () => void;
+
+declare function booleanAttributeBinding(element: HTMLElement, attribute: string, value: Signal<boolean> | undefined): void;
+
+/**
+ * Disposable functions are a way to manage timers, intervals, and event listeners
+ * that should be cleared when a component is destroyed.
+ *
+ * This is heavily inspired by Headless UI disposables:
+ * https://github.com/tailwindlabs/headlessui/blob/main/packages/%40headlessui-react/src/utils/disposables.ts
+ */
+declare function injectDisposables(): {
+    /**
+     * Set a timeout that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @param delay The delay before the callback is executed
+     * @returns A function to clear the timeout
+     */
+    setTimeout: (callback: () => void, delay: number) => () => void;
+    /**
+     * Set an interval that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @param delay The delay before the callback is executed
+     * @param target
+     * @param type
+     * @param listener
+     * @param options
+     * @returns A function to clear the interval
+     */
+    addEventListener: <K extends keyof HTMLElementEventMap>(target: EventTarget, type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions) => () => void;
+    /**
+     * Set an interval that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @param delay The delay before the callback is executed
+     * @returns A function to clear the interval
+     */
+    setInterval: (callback: () => void, delay: number) => () => void;
+    /**
+     * Set a requestAnimationFrame that will be cleared when the component is destroyed.
+     * @param callback The callback to execute
+     * @returns A function to clear the requestAnimationFrame
+     */
+    requestAnimationFrame: (callback: FrameRequestCallback) => () => void;
+};
+
+/**
+ * Generate a unique id for an element
+ * @param prefix - The prefix to use for the id
+ * @returns The generated id
+ */
+declare function uniqueId(prefix: string): string;
+
+/**
+ * Type validation utilities
+ */
+/**
+ * Checks if a value is a string
+ * @param value - The value to check
+ * @returns true if the value is a string, false otherwise
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * Checks if a value is a number
+ * @param value - The value to check
+ * @returns true if the value is a number, false otherwise
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a value is a boolean
+ * @param value - The value to check
+ * @returns true if the value is a boolean, false otherwise
+ */
+declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if a value is a function
+ * @param value - The value to check
+ * @returns true if the value is a function, false otherwise
+ */
+declare function isFunction(value: unknown): value is CallableFunction;
+/**
+ * Checks if a value is a plain object (but not null or array)
+ * @param value - The value to check
+ * @returns true if the value is a plain object, false otherwise
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a value is undefined
+ * @param value - The value to check
+ * @returns true if the value is undefined, false otherwise
+ */
+declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Checks if a value is null or undefined
+ * @param value - The value to check
+ * @returns true if the value is null or undefined, false otherwise
+ */
+declare function isNil(value: unknown): value is null | undefined;
+/**
+ * Checks if a value is not null and not undefined
+ * @param value - The value to check
+ * @returns true if the value is not null and not undefined, false otherwise
+ */
+declare function notNil<T>(value: T | null | undefined): value is T;
+
+/**
+ * The built-in `takeUntilDestroyed` operator does not handle the case when the component is destroyed before the source observable emits.
+ * This operator ensures that the source observable completes gracefully without throwing an error.
+ * https://github.com/angular/angular/issues/54527#issuecomment-2098254508
+ *
+ * @internal
+ */
+declare function safeTakeUntilDestroyed<T>(destroyRef?: DestroyRef): MonoTypeOperatorFunction<T>;
+
+/**
+ * Listen for changes to a signal and call a function when the signal changes.
+ * @param source
+ * @param fn
+ * @param options
+ * @param options.injector
+ * @internal
+ */
+declare function onChange<T>(source: Signal<T | null | undefined>, fn: (value: T | null | undefined, previousValue: T | null | undefined) => void, options?: {
+    injector: Injector;
+}): void;
+/**
+ * Listen for changes to a boolean signal and call one of two functions when the signal changes.
+ * @param source
+ * @param onTrue
+ * @param onFalse
+ * @param options
+ */
+declare function onBooleanChange(source: Signal<boolean>, onTrue?: () => void, onFalse?: () => void, options?: {
+    injector: Injector;
+}): void;
+
+export { booleanAttributeBinding, controlStatus, injectDisposables, isBoolean, isFunction, isNil, isNumber, isObject, isString, isUndefined, notNil, onBooleanChange, onChange, provideValueAccessor, safeTakeUntilDestroyed, uniqueId };
+export type { ChangeFn, NgpControlStatus, TouchedFn };

package/a11y/active-descendant/active-descendant.d.ts

@@ -1,42 +0,0 @@
-import { ElementRef, Signal } from '@angular/core';
-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>;
-}
-export 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>;
-}
-export 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;
-};
-export {};

package/a11y/visually-hidden/visually-hidden-state.d.ts

@@ -1,17 +0,0 @@
-import type { NgpVisuallyHidden } from './visually-hidden';
-/**
- * The state token  for the VisuallyHidden primitive.
- */
-export declare const NgpVisuallyHiddenStateToken: import("@angular/core").InjectionToken<NgpVisuallyHidden>;
-/**
- * Provides the VisuallyHidden state.
- */
-export declare const provideVisuallyHiddenState: (options?: import("ng-primitives/state").CreateStateProviderOptions) => import("@angular/core").FactoryProvider;
-/**
- * Injects the VisuallyHidden state.
- */
-export declare const injectVisuallyHiddenState: <U = NgpVisuallyHidden>(injectOptions?: import("@angular/core").InjectOptions) => import("@angular/core").Signal<import("ng-primitives/state").State<U>>;
-/**
- * The VisuallyHidden state registration function.
- */
-export declare const visuallyHiddenState: <U>(state: U) => import("ng-primitives/state").CreatedState<U>;

package/a11y/visually-hidden/visually-hidden.d.ts

@@ -1,50 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * Hide an element visually while keeping it present in the DOM.
- */
-export declare class NgpVisuallyHidden {
-    private readonly changeDetector;
-    /**
-     * Whether the element is hidden.
-     */
-    protected readonly hidden: import("@angular/core").WritableSignal<boolean>;
-    protected readonly style: import("@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: import("ng-primitives/state").CreatedState<NgpVisuallyHidden>;
-    /**
-     * Set the element visibility.
-     * @param visible
-     */
-    setVisibility(visible: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgpVisuallyHidden, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgpVisuallyHidden, "[ngpVisuallyHidden]", ["ngpVisuallyHidden"], {}, {}, never, never, true, never>;
-}

package/accordion/accordion/accordion-state.d.ts

@@ -1,17 +0,0 @@
-import type { NgpAccordion } from './accordion';
-/**
- * The state token  for the Accordion primitive.
- */
-export declare const NgpAccordionStateToken: import("@angular/core").InjectionToken<NgpAccordion<unknown>>;
-/**
- * Provides the Accordion state.
- */
-export declare const provideAccordionState: (options?: import("ng-primitives/state").CreateStateProviderOptions) => import("@angular/core").FactoryProvider;
-/**
- * Injects the Accordion state.
- */
-export declare const injectAccordionState: <U = NgpAccordion<unknown>>(injectOptions?: import("@angular/core").InjectOptions) => import("@angular/core").Signal<import("ng-primitives/state").State<U>>;
-/**
- * The Accordion state registration function.
- */
-export declare const accordionState: <U>(state: U) => import("ng-primitives/state").CreatedState<U>;

package/accordion/accordion/accordion.d.ts

@@ -1,50 +0,0 @@
-import { BooleanInput } from '@angular/cdk/coercion';
-import { NgpOrientation } from 'ng-primitives/common';
-import * as i0 from "@angular/core";
-/**
- * Apply the `ngpAccordion` directive to an element that represents the group of accordion items.
- */
-export declare class NgpAccordion<T> {
-    /**
-     * Access the global accordion configuration.
-     */
-    private readonly config;
-    /**
-     * The type of the accordion.
-     */
-    readonly type: import("@angular/core").InputSignal<NgpAccordionType>;
-    /**
-     * Whether the accordion is collapsible.
-     */
-    readonly collapsible: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * The value of the accordion.
-     */
-    readonly value: import("@angular/core").InputSignal<T | T[] | null>;
-    /**
-     * Event emitted when the accordion value changes.
-     */
-    readonly valueChange: import("@angular/core").OutputEmitterRef<T | T[] | null>;
-    /**
-     * Whether the accordion is disabled.
-     */
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * The accordion orientation.
-     */
-    readonly orientation: import("@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: i0.ɵɵFactoryDeclaration<NgpAccordion<any>, never>;
-    static ɵdir: i0.ɵɵ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>;
-}
-export type NgpAccordionType = 'single' | 'multiple';

package/accordion/accordion-content/accordion-content.d.ts

@@ -1,40 +0,0 @@
-import type { NgpAccordion } from '../accordion/accordion';
-import * as i0 from "@angular/core";
-/**
- * Apply the `ngpAccordionContent` directive to an element that represents the content of an accordion item.
- */
-export declare class NgpAccordionContent<T> {
-    /**
-     * Access the accordion content element reference
-     */
-    private readonly elementRef;
-    /**
-     * Access the accordion
-     */
-    protected readonly accordion: import("@angular/core").Signal<import("ng-primitives/state").State<NgpAccordion<T>>>;
-    /**
-     * Access the accordion item
-     */
-    protected readonly accordionItem: import("@angular/core").Signal<import("ng-primitives/state").State<import("ng-primitives/accordion").NgpAccordionItem<unknown>>>;
-    /**
-     * The id of the content region
-     */
-    readonly id: import("@angular/core").InputSignal<string>;
-    /**
-     * The dimensions of the content
-     */
-    private dimensions;
-    /**
-     * The hidden until-found state of the content
-     */
-    protected readonly hidden: import("@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: i0.ɵɵFactoryDeclaration<NgpAccordionContent<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgpAccordionContent<any>, "[ngpAccordionContent]", ["ngpAccordionContent"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/accordion/accordion-item/accordion-item-state.d.ts

@@ -1,17 +0,0 @@
-import type { NgpAccordionItem } from './accordion-item';
-/**
- * The state token  for the AccordionItem primitive.
- */
-export declare const NgpAccordionItemStateToken: import("@angular/core").InjectionToken<NgpAccordionItem<unknown>>;
-/**
- * Provides the AccordionItem state.
- */
-export declare const provideAccordionItemState: (options?: import("ng-primitives/state").CreateStateProviderOptions) => import("@angular/core").FactoryProvider;
-/**
- * Injects the AccordionItem state.
- */
-export declare const injectAccordionItemState: <U = NgpAccordionItem<unknown>>(injectOptions?: import("@angular/core").InjectOptions) => import("@angular/core").Signal<import("ng-primitives/state").State<U>>;
-/**
- * The AccordionItem state registration function.
- */
-export declare const accordionItemState: <U>(state: U) => import("ng-primitives/state").CreatedState<U>;

package/accordion/accordion-item/accordion-item.d.ts

@@ -1,50 +0,0 @@
-import { BooleanInput } from '@angular/cdk/coercion';
-import { NgpAccordionContent } from '../accordion-content/accordion-content';
-import { NgpAccordionTrigger } from '../accordion-trigger/accordion-trigger';
-import { NgpAccordion } from '../accordion/accordion';
-import * as i0 from "@angular/core";
-/**
- * Apply the `ngpAccordionItem` directive to an element that represents an accordion item.
- */
-export declare class NgpAccordionItem<T> {
-    /**
-     * Access the accordion.
-     */
-    protected readonly accordion: import("@angular/core").Signal<import("ng-primitives/state").State<NgpAccordion<T>>>;
-    /**
-     * The value of the accordion item.
-     */
-    readonly value: import("@angular/core").InputSignal<T>;
-    /**
-     * Whether the accordion item is disabled.
-     */
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * Access the accordion trigger
-     * @internal
-     */
-    readonly trigger: import("@angular/core").WritableSignal<NgpAccordionTrigger<T> | undefined>;
-    /**
-     * Access the accordion content
-     * @internal
-     */
-    readonly content: import("@angular/core").WritableSignal<NgpAccordionContent<T> | undefined>;
-    /**
-     * Whether the accordion item is expanded.
-     */
-    readonly open: import("@angular/core").Signal<boolean>;
-    /**
-     * The trigger id.
-     */
-    readonly triggerId: import("@angular/core").Signal<string | undefined>;
-    /**
-     * The content id.
-     */
-    readonly contentId: import("@angular/core").Signal<string | undefined>;
-    /**
-     * The accordion item state.
-     */
-    private readonly state;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgpAccordionItem<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgpAccordionItem<any>, "[ngpAccordionItem]", ["ngpAccordionItem"], { "value": { "alias": "ngpAccordionItemValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpAccordionItemDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/accordion/accordion-trigger/accordion-trigger.d.ts

@@ -1,31 +0,0 @@
-import { NgpAccordionItem } from '../accordion-item/accordion-item';
-import { NgpAccordion } from '../accordion/accordion';
-import * as i0 from "@angular/core";
-/**
- * Apply the `ngpAccordionTrigger` directive to an element that represents the trigger for an accordion item, such as a button.
- */
-export declare class NgpAccordionTrigger<T> {
-    /**
-     * The tag name of the element.
-     */
-    protected readonly tagName: string;
-    /**
-     * Access the parent accordion.
-     */
-    protected readonly accordion: import("@angular/core").Signal<import("ng-primitives/state").State<NgpAccordion<T>>>;
-    /**
-     * The item instance.
-     */
-    protected readonly accordionItem: import("@angular/core").Signal<import("ng-primitives/state").State<NgpAccordionItem<T>>>;
-    /**
-     * The id of the trigger.
-     */
-    readonly id: import("@angular/core").InputSignal<string>;
-    constructor();
-    /**
-     * Toggle the accordion item.
-     */
-    toggle(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgpAccordionTrigger<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgpAccordionTrigger<any>, "[ngpAccordionTrigger]", ["ngpAccordionTrigger"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/accordion/config/accordion-config.d.ts

@@ -1,32 +0,0 @@
-import { InjectionToken, Provider } from '@angular/core';
-import { NgpAccordionType } from '../accordion/accordion';
-export 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';
-}
-export declare const defaultAccordionConfig: NgpAccordionConfig;
-export declare const NgpAccordionConfigToken: InjectionToken<NgpAccordionConfig>;
-/**
- * Provide the default Accordion configuration
- * @param config The Accordion configuration
- * @returns The provider
- */
-export declare function provideAccordionConfig(config: Partial<NgpAccordionConfig>): Provider[];
-/**
- * Inject the Accordion configuration
- * @returns The global Accordion configuration
- */
-export declare function injectAccordionConfig(): NgpAccordionConfig;

package/ai/prompt-composer/prompt-composer-state.d.ts

@@ -1,17 +0,0 @@
-import type { NgpPromptComposer } from './prompt-composer';
-/**
- * The state token  for the PromptComposer primitive.
- */
-export declare const NgpPromptComposerStateToken: import("@angular/core").InjectionToken<NgpPromptComposer>;
-/**
- * Provides the PromptComposer state.
- */
-export declare const providePromptComposerState: (options?: import("ng-primitives/state").CreateStateProviderOptions) => import("@angular/core").FactoryProvider;
-/**
- * Injects the PromptComposer state.
- */
-export declare const injectPromptComposerState: <U = NgpPromptComposer>(injectOptions?: import("@angular/core").InjectOptions) => import("@angular/core").Signal<import("ng-primitives/state").State<U>>;
-/**
- * The PromptComposer state registration function.
- */
-export declare const promptComposerState: <U>(state: U) => import("ng-primitives/state").CreatedState<U>;

package/ai/prompt-composer/prompt-composer.d.ts

@@ -1,23 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class NgpPromptComposer {
-    private readonly thread;
-    /** Emits whenever the user submits the prompt. */
-    readonly submit: import("@angular/core").OutputEmitterRef<string>;
-    /** @internal Store the current prompt text. */
-    readonly prompt: import("@angular/core").WritableSignal<string>;
-    /** @internal Track whether the prompt is currently being dictated */
-    readonly isDictating: import("@angular/core").WritableSignal<boolean>;
-    /** @internal Determine whether the prompt input has content */
-    readonly hasPrompt: import("@angular/core").Signal<boolean>;
-    /** Whether dictation is supported by the browser */
-    readonly dictationSupported: boolean;
-    /** The state of the prompt composer. */
-    protected readonly state: import("ng-primitives/state").CreatedState<NgpPromptComposer>;
-    /**
-     * @internal
-     * Submits the current prompt if there is content, and clears the input.
-     */
-    submitPrompt(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgpPromptComposer, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgpPromptComposer, "[ngpPromptComposer]", ["ngpPromptComposer"], {}, { "submit": "ngpPromptComposerSubmit"; }, never, never, true, never>;
-}

package/ai/prompt-composer-dictation/prompt-composer-dictation-state.d.ts

@@ -1,17 +0,0 @@
-import type { NgpPromptComposerDictation } from './prompt-composer-dictation';
-/**
- * The state token  for the PromptComposerDictation primitive.
- */
-export declare const NgpPromptComposerDictationStateToken: import("@angular/core").InjectionToken<NgpPromptComposerDictation>;
-/**
- * Provides the PromptComposerDictation state.
- */
-export declare const providePromptComposerDictationState: (options?: import("ng-primitives/state").CreateStateProviderOptions) => import("@angular/core").FactoryProvider;
-/**
- * Injects the PromptComposerDictation state.
- */
-export declare const injectPromptComposerDictationState: <U = NgpPromptComposerDictation>(injectOptions?: import("@angular/core").InjectOptions) => import("@angular/core").Signal<import("ng-primitives/state").State<U>>;
-/**
- * The PromptComposerDictation state registration function.
- */
-export declare const promptComposerDictationState: <U>(state: U) => import("ng-primitives/state").CreatedState<U>;

package/ai/prompt-composer-dictation/prompt-composer-dictation.d.ts

@@ -1,29 +0,0 @@
-import { BooleanInput } from '@angular/cdk/coercion';
-import { OnDestroy } from '@angular/core';
-import * as i0 from "@angular/core";
-declare global {
-    interface Window {
-        SpeechRecognition: any;
-        webkitSpeechRecognition: any;
-    }
-}
-export declare class NgpPromptComposerDictation implements OnDestroy {
-    protected readonly composer: import("@angular/core").Signal<import("ng-primitives/state").State<import("ng-primitives/ai").NgpPromptComposer>>;
-    private recognition;
-    private basePrompt;
-    /** Whether the submit button should be disabled. */
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    /** Whether dictation is currently active */
-    readonly isDictating: import("@angular/core").Signal<boolean>;
-    /** The state of the prompt composer. */
-    protected readonly state: import("ng-primitives/state").CreatedState<NgpPromptComposerDictation>;
-    constructor();
-    ngOnDestroy(): void;
-    protected onClick(): void;
-    protected onKeydown(event: KeyboardEvent): void;
-    private initializeSpeechRecognition;
-    private startDictation;
-    private stopDictation;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgpPromptComposerDictation, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgpPromptComposerDictation, "button[ngpPromptComposerDictation]", ["ngpPromptComposerDictation"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/ai/prompt-composer-input/prompt-composer-input-state.d.ts

@@ -1,17 +0,0 @@
-import type { NgpPromptComposerInput } from './prompt-composer-input';
-/**
- * The state token  for the PromptComposerInput primitive.
- */
-export declare const NgpPromptComposerInputStateToken: import("@angular/core").InjectionToken<NgpPromptComposerInput>;
-/**
- * Provides the PromptComposerInput state.
- */
-export declare const providePromptComposerInputState: (options?: import("ng-primitives/state").CreateStateProviderOptions) => import("@angular/core").FactoryProvider;
-/**
- * Injects the PromptComposerInput state.
- */
-export declare const injectPromptComposerInputState: <U = NgpPromptComposerInput>(injectOptions?: import("@angular/core").InjectOptions) => import("@angular/core").Signal<import("ng-primitives/state").State<U>>;
-/**
- * The PromptComposerInput state registration function.
- */
-export declare const promptComposerInputState: <U>(state: U) => import("ng-primitives/state").CreatedState<U>;