ng-primitives 0.89.0 → 0.91.0

package/file-upload/index.d.ts

@@ -1,4 +1,148 @@
-export { NgpFileDropzone } from './file-dropzone/file-dropzone';
-export { injectFileDropzoneState, provideFileDropzoneState, } from './file-dropzone/file-dropzone-state';
-export { NgpFileUpload } from './file-upload/file-upload';
-export { injectFileUploadState, provideFileUploadState } from './file-upload/file-upload-state';
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as ng_primitives_state from 'ng-primitives/state';
+
+/**
+ * Capture files dropped on the element.
+ */
+declare class NgpFileDropzone {
+    /**
+     * Access the host element.
+     */
+    private readonly elementRef;
+    /**
+     * The accepted file types. This can be an array of strings or a comma-separated string.
+     * Accepted types can either be file extensions (e.g. `.jpg`) or MIME types (e.g. `image/jpeg`).
+     */
+    readonly fileTypes: _angular_core.InputSignalWithTransform<string[] | undefined, string | string[]>;
+    /**
+     * Whether to allow multiple files to be selected.
+     */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether to allow the user to select directories.
+     */
+    readonly directory: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the file upload is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Emits when the user selects files.
+     */
+    readonly selected: _angular_core.OutputEmitterRef<FileList | null>;
+    /**
+     * Emits when uploaded files are rejected because they do not match the allowed {@link fileTypes}.
+     */
+    readonly rejected: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits when the user drags a file over the file upload.
+     */
+    readonly dragOver: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Whether the user is currently dragging a file over the file upload.
+     */
+    protected readonly isDragOver: _angular_core.WritableSignal<boolean>;
+    /**
+     * The file upload state.
+     */
+    private readonly state;
+    constructor();
+    protected onDragEnter(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpFileDropzone, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpFileDropzone, "[ngpFileDropzone]", ["ngpFileDropzone"], { "fileTypes": { "alias": "ngpFileDropzoneFileTypes"; "required": false; "isSignal": true; }; "multiple": { "alias": "ngpFileDropzoneMultiple"; "required": false; "isSignal": true; }; "directory": { "alias": "ngpFileDropzoneDirectory"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpFileDropzoneDisabled"; "required": false; "isSignal": true; }; }, { "selected": "ngpFileDropzoneSelected"; "rejected": "ngpFileDropzoneRejected"; "dragOver": "ngpFileDropzoneDragOver"; }, never, never, true, never>;
+}
+
+/**
+ * Provides the FileDropzone state.
+ */
+declare const provideFileDropzoneState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the FileDropzone state.
+ */
+declare const injectFileDropzoneState: <U = NgpFileDropzone>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * A directive that allows you to turn any element into a file upload trigger.
+ */
+declare class NgpFileUpload {
+    /**
+     * Access the document
+     */
+    private readonly document;
+    /**
+     * Access the host element.
+     */
+    private readonly elementRef;
+    /**
+     * The accepted file types. This can be an array of strings or a comma-separated string.
+     * Accepted types can either be file extensions (e.g. `.jpg`) or MIME types (e.g. `image/jpeg`).
+     */
+    readonly fileTypes: _angular_core.InputSignalWithTransform<string[] | undefined, string | string[]>;
+    /**
+     * Whether to allow multiple files to be selected.
+     */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether to allow the user to select directories.
+     */
+    readonly directory: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether drag-and-drop is enabled.
+     */
+    readonly dragAndDrop: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the file upload is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Emits when the user selects files.
+     */
+    readonly selected: _angular_core.OutputEmitterRef<FileList | null>;
+    /**
+     * Emits when the user cancel the file selection.
+     */
+    readonly canceled: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits when uploaded files are rejected because they do not match the allowed {@link fileTypes}.
+     */
+    readonly rejected: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits when the user drags a file over the file upload.
+     */
+    readonly dragOver: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Whether the user is currently dragging a file over the file upload.
+     */
+    protected readonly isDragOver: _angular_core.WritableSignal<boolean>;
+    /**
+     * Store the file input element.
+     */
+    private input;
+    /**
+     * The file upload state.
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpFileUpload>;
+    constructor();
+    protected showFileDialog(): void;
+    protected onDragEnter(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpFileUpload, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpFileUpload, "[ngpFileUpload]", ["ngpFileUpload"], { "fileTypes": { "alias": "ngpFileUploadFileTypes"; "required": false; "isSignal": true; }; "multiple": { "alias": "ngpFileUploadMultiple"; "required": false; "isSignal": true; }; "directory": { "alias": "ngpFileUploadDirectory"; "required": false; "isSignal": true; }; "dragAndDrop": { "alias": "ngpFileUploadDragDrop"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpFileUploadDisabled"; "required": false; "isSignal": true; }; }, { "selected": "ngpFileUploadSelected"; "canceled": "ngpFileUploadCanceled"; "rejected": "ngpFileUploadRejected"; "dragOver": "ngpFileUploadDragOver"; }, never, never, true, never>;
+}
+
+/**
+ * Provides the FileUpload state.
+ */
+declare const provideFileUploadState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the FileUpload state.
+ */
+declare const injectFileUploadState: <U = NgpFileUpload>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpFileDropzone, NgpFileUpload, injectFileDropzoneState, injectFileUploadState, provideFileDropzoneState, provideFileUploadState };

package/focus-trap/index.d.ts

@@ -1,2 +1,98 @@
-export { NgpFocusTrap } from './focus-trap/focus-trap';
-export { provideFocusTrapState, injectFocusTrapState } from './focus-trap/focus-trap-state';
+import * as ng_primitives_state from 'ng-primitives/state';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+/**
+ * The `NgpFocusTrap` directive traps focus within the host element.
+ */
+declare class NgpFocusTrap implements OnInit, OnDestroy {
+    /**
+     * Access any parent overlay.
+     */
+    private readonly overlay;
+    /**
+     * Create a new focus trap.
+     */
+    private readonly focusTrap;
+    /**
+     * Access the injector.
+     */
+    private readonly injector;
+    /**
+     * Access the focus monitor.
+     */
+    private readonly focusMonitor;
+    /**
+     * Access the interactivity checker.
+     */
+    private readonly interactivityChecker;
+    /**
+     * Get the focus trap container element.
+     */
+    private readonly elementRef;
+    /**
+     * Access NgZone to run the focus trap events outside of Angular's zone.
+     */
+    private readonly ngZone;
+    /**
+     * Store the mutation observer.
+     */
+    private mutationObserver;
+    /**
+     * Store the last focused element.
+     */
+    private lastFocusedElement;
+    /**
+     * Whether the focus trap is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The focus trap state.
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpFocusTrap>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private handleFocusIn;
+    /**
+     * Handles the `focusout` event.
+     */
+    private handleFocusOut;
+    /**
+     * If the focused element gets removed from the DOM, browsers move focus back to the document.body.
+     * We move focus to the container to keep focus trapped correctly.
+     */
+    private handleMutations;
+    /**
+     * Handles the `keydown` event.
+     */
+    protected handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Returns the first and last tabbable elements inside a container.
+     */
+    private getTabbableEdges;
+    /**
+     * Returns a list of potential focusable elements inside a container.
+     */
+    private getTabbableCandidates;
+    /**
+     * Returns the first visible element in a list..
+     */
+    private findVisible;
+    private focus;
+    private focusFirst;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpFocusTrap, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpFocusTrap, "[ngpFocusTrap]", ["ngpFocusTrap"], { "disabled": { "alias": "ngpFocusTrapDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Provides the FocusTrap state.
+ */
+declare const provideFocusTrapState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the FocusTrap state.
+ */
+declare const injectFocusTrapState: <U = NgpFocusTrap>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+export { NgpFocusTrap, injectFocusTrapState, provideFocusTrapState };

package/form-field/index.d.ts

@@ -1,7 +1,266 @@
-export { NgpDescription } from './description/description';
-export { NgpError } from './error/error';
-export { NgpFormControl, setupFormControl } from './form-control/form-control';
-export { injectFormControlState, provideFormControlState } from './form-control/form-control-state';
-export { NgpFormField } from './form-field/form-field';
-export { injectFormFieldState, provideFormFieldState } from './form-field/form-field-state';
-export { NgpLabel } from './label/label';
+import * as ng_primitives_state from 'ng-primitives/state';
+import * as ng_primitives_form_field from 'ng-primitives/form-field';
+import * as _angular_core from '@angular/core';
+import { OnChanges, OnDestroy, SimpleChanges, Signal } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { NgpControlStatus } from 'ng-primitives/utils';
+
+/**
+ * The `NgpDescription` directive is used to mark a description element within a form field. There may be multiple descriptions associated with a form control.
+ */
+declare class NgpDescription {
+    /**
+     * The id of the description. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Access the form field that the description is associated with.
+     */
+    protected readonly formField: _angular_core.Signal<ng_primitives_state.State<ng_primitives_form_field.NgpFormField>>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpDescription, "[ngpDescription]", ["ngpDescription"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The `NgpError` directive is used to mark an error message element within a form field. There may be multiple error messages associated with a form control.
+ */
+declare class NgpError implements OnChanges, OnDestroy {
+    /**
+     * Access the form field that the description is associated with.
+     */
+    protected readonly formField: _angular_core.Signal<ng_primitives_state.State<ng_primitives_form_field.NgpFormField>>;
+    /**
+     * The id of the error message. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * The validator associated with the error message.
+     */
+    readonly validator: _angular_core.InputSignal<string | null>;
+    /**
+     * Determine if there is an error message.
+     */
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    /**
+     * Determine whether the validator associated with this error is failing.
+     */
+    protected readonly state: _angular_core.Signal<"fail" | "pass">;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpError, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpError, "[ngpError]", ["ngpError"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "validator": { "alias": "ngpErrorValidator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Typically this primitive would be not be used directly, but instead a more specific form control primitive would be used (e.g. `ngpInput`). All of our form control primitives use `ngpFormControl` internally so they will have the same accessibility features as described below.
+ *
+ * The `NgpFormControl` directive is used to mark a form control element within a form field. This element will have an `aria-labelledby` attribute set to the ID of the label element within the form field and an `aria-describedby` attribute set to the ID of the description elements within the form field.
+ */
+declare class NgpFormControl {
+    /**
+     * The id of the form control. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Whether the form control is disabled by a parent.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The status of the form control.
+     */
+    readonly status: Signal<NgpControlStatus>;
+    /**
+     * The element reference.
+     */
+    private readonly elementRef;
+    /**
+     * Whether the element supports the disabled attribute.
+     */
+    protected readonly supportsDisabledAttribute: boolean;
+    /**
+     * The state of the form control.
+     */
+    private readonly state;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpFormControl, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpFormControl, "[ngpFormControl]", ["ngpFormControl"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpFormControlDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface NgpFormControlProps {
+    id: Signal<string>;
+    disabled?: Signal<boolean>;
+}
+declare function ngpFormControl({ id, disabled, }: NgpFormControlProps): Signal<NgpControlStatus>;
+
+/**
+ * Provides the FormControl state.
+ */
+declare const provideFormControlState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the FormControl state.
+ */
+declare const injectFormControlState: <U = NgpFormControl>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * The `NgpFormField` directive is a container for form field elements. Any labels, form controls, or descriptions should be placed within this directive.
+ */
+declare class NgpFormField implements OnDestroy {
+    /**
+     * Store the form label.
+     * @internal
+     */
+    readonly labels: _angular_core.WritableSignal<string[]>;
+    /**
+     * Store the form descriptions.
+     * @internal
+     */
+    readonly descriptions: _angular_core.WritableSignal<string[]>;
+    /**
+     * Store the id of the associated form control.
+     * @internal
+     */
+    readonly formControl: _angular_core.WritableSignal<string | null>;
+    /**
+     * Find any NgControl within the form field.
+     * @internal
+     */
+    private readonly ngControl;
+    /**
+     * Store the validation error messages.
+     * @internal
+     */
+    readonly errors: _angular_core.WritableSignal<string[]>;
+    /**
+     * Whether the control is pristine.
+     * @internal
+     */
+    readonly pristine: _angular_core.WritableSignal<boolean | null>;
+    /**
+     * Whether the control is touched.
+     * @internal
+     */
+    readonly touched: _angular_core.WritableSignal<boolean | null>;
+    /**
+     * Whether the control is dirty.
+     * @internal
+     */
+    readonly dirty: _angular_core.WritableSignal<boolean | null>;
+    /**
+     * Whether the control is valid.
+     */
+    readonly valid: _angular_core.WritableSignal<boolean | null>;
+    /**
+     * Whether the control is invalid.
+     * @internal
+     */
+    readonly invalid: _angular_core.WritableSignal<boolean | null>;
+    /**
+     * Whether the control is pending.
+     * @internal
+     */
+    readonly pending: _angular_core.WritableSignal<boolean | null>;
+    /**
+     * Whether the control is disabled.
+     * @internal
+     */
+    readonly disabled: _angular_core.WritableSignal<boolean | null>;
+    /**
+     * Store the current status subscription.
+     */
+    private subscription?;
+    /**
+     * Injector for creating effects outside the constructor.
+     */
+    private readonly injector;
+    /**
+     * The form field state.
+     */
+    protected readonly state: ng_primitives_state.CreatedState<NgpFormField>;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Setup a listener for the form control status.
+     * @param control
+     */
+    private setupSubscriptions;
+    private updateStatus;
+    /**
+     * Register the id of the associated form control.
+     * @param id
+     * @internal
+     */
+    setFormControl(id: string): void;
+    /**
+     * Register a label with the form field.
+     * @param label
+     * @internal
+     */
+    addLabel(label: string): void;
+    /**
+     * Register a description with the form field.
+     * @param description
+     * @internal
+     */
+    addDescription(description: string): void;
+    /**
+     * Remove the associated form control.
+     * @internal
+     */
+    removeFormControl(): void;
+    /**
+     * Remove a label from the form field.
+     * @param label
+     * @internal
+     */
+    removeLabel(label: string): void;
+    /**
+     * Remove a description from the form field.
+     * @param description
+     * @internal
+     */
+    removeDescription(description: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpFormField, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpFormField, "[ngpFormField]", ["ngpFormField"], {}, {}, ["ngControl"], never, true, never>;
+}
+
+/**
+ * Provides the FormField state.
+ */
+declare const provideFormFieldState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
+/**
+ * Injects the FormField state.
+ */
+declare const injectFormFieldState: <U = NgpFormField>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+
+/**
+ * The `NgpLabel` directive is used to mark a label element within a form field. Preferably, there should use an HTML `<label>` element.
+ */
+declare class NgpLabel {
+    /**
+     * The id of the label. If not provided, a unique id will be generated.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Access the form field that the label is associated with.
+     */
+    protected readonly formField: _angular_core.Signal<ng_primitives_state.State<ng_primitives_form_field.NgpFormField>>;
+    /**
+     * Derive the for attribute value if the label is an HTML label element.
+     */
+    protected readonly htmlFor: _angular_core.Signal<string | null>;
+    /**
+     * Access the element that the label is associated with.
+     */
+    private readonly elementRef;
+    /**
+     * Determine if the label is an HTML label element.
+     */
+    protected readonly isLabel: boolean;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpLabel, "[ngpLabel]", ["ngpLabel"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgpDescription, NgpError, NgpFormControl, NgpFormField, NgpLabel, injectFormControlState, injectFormFieldState, ngpFormControl, provideFormControlState, provideFormFieldState };

package/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: null;
-export default _default;
+
+export { };

package/input/index.d.ts

@@ -1,2 +1,84 @@
-export { NgpInput } from './input/input';
-export { injectInputState, provideInputState } from './input/input-state';
+import * as ng_primitives_utils from 'ng-primitives/utils';
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+
+declare class NgpInput {
+    /**
+     * The id of the input.
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Whether the element is disabled.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The input state.
+     */
+    protected readonly state: {
+        id: _angular_core.Signal<string>;
+        disabled: _angular_core.WritableSignal<boolean>;
+        status: _angular_core.Signal<ng_primitives_utils.NgpControlStatus>;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpInput, "input[ngpInput]", ["ngpInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Public state surface for the Input primitive.
+ */
+interface NgpInputState {
+    /**
+     * The id of the input.
+     */
+    readonly id: Signal<string>;
+    /**
+     * Whether the input is disabled.
+     */
+    readonly disabled: WritableSignal<boolean>;
+}
+/**
+ * Inputs for configuring the Input primitive.
+ */
+interface NgpInputProps {
+    /**
+     * The id of the input.
+     */
+    readonly id?: Signal<string>;
+    /**
+     * Whether the input is disabled.
+     */
+    readonly disabled?: Signal<boolean>;
+}
+declare const ngpInput: ({ id, disabled: _disabled }: NgpInputProps) => {
+    id: Signal<string>;
+    disabled: WritableSignal<boolean>;
+    status: Signal<ng_primitives_utils.NgpControlStatus>;
+};
+declare const injectInputState: {
+    (): Signal<{
+        id: Signal<string>;
+        disabled: WritableSignal<boolean>;
+        status: Signal<ng_primitives_utils.NgpControlStatus>;
+    }>;
+    (options: {
+        hoisted: true;
+    }): Signal<{
+        id: Signal<string>;
+        disabled: WritableSignal<boolean>;
+        status: Signal<ng_primitives_utils.NgpControlStatus>;
+    } | null>;
+    (options?: {
+        hoisted?: boolean;
+    }): Signal<{
+        id: Signal<string>;
+        disabled: WritableSignal<boolean>;
+        status: Signal<ng_primitives_utils.NgpControlStatus>;
+    } | null>;
+};
+declare const provideInputState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+export { NgpInput, injectInputState, ngpInput, provideInputState };
+export type { NgpInputProps, NgpInputState };