import * as i0 from '@angular/core';
import { InputSignalWithTransform, InputSignal, EmbeddedViewRef, TemplateRef, ViewContainerRef, Signal, ElementRef, WritableSignal, ModelSignal, OnDestroy, Injector, Type, Provider, OutputEmitterRef, EventEmitter } from '@angular/core';
import * as _juulsgaard_ngx_forms_core from '@juulsgaard/ngx-forms-core';
import { FormUnit, FormRoot, FormLayer, FormList, ControlFormLayer, FormNode, FormNodeEvent, FormSelectNode, BaseFormDialog, FormDialog, FormNodeType, AnonFormNode, FormValidationContext, FormPage } from '@juulsgaard/ngx-forms-core';
import * as _juulsgaard_ngx_forms from '@juulsgaard/ngx-forms';
import * as rxjs from 'rxjs';
import { Subject, Observable, Subscribable } from 'rxjs';
import { ThemePalette, ErrorStateMatcher } from '@angular/material/core';
import { MatFormFieldAppearance, MatFormFieldControl } from '@angular/material/form-field';
import { MapFunc, Selection, SimpleObject } from '@juulsgaard/ts-tools';
import { UntypedFormControl, FormGroupDirective, NgForm } from '@angular/forms';
import { RenderSourceDirective } from '@juulsgaard/ngx-tools';
import { TemplateDialogInstance, DialogManagerService } from '@juulsgaard/ngx-ui';
import { FocusOptions as FocusOptions$1 } from '@angular/cdk/a11y';

declare class FormDirective<TControls extends Record<string, FormUnit>> {
    private templateRef;
    private viewContainer;
    form: InputSignalWithTransform<FormRoot<TControls, any>, FormRoot<TControls, any> | {
        readonly form: FormRoot<TControls, any>;
    }>;
    readonly show: InputSignal<boolean>;
    view?: EmbeddedViewRef<FormDirectiveContext<TControls>>;
    constructor(templateRef: TemplateRef<FormDirectiveContext<TControls>>, viewContainer: ViewContainerRef);
    get control(): FormRoot<TControls, any>;
    static ngTemplateContextGuard<TControls extends Record<string, FormUnit>>(directive: FormDirective<TControls>, context: unknown): context is FormDirectiveContext<TControls>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormDirective<any>, "[ngxForm]", never, { "form": { "alias": "ngxForm"; "required": true; "isSignal": true; }; "show": { "alias": "ngxFormWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
interface FormDirectiveContext<TControls extends Record<string, FormUnit>> {
    ngxForm: TControls;
}

declare class FormLayerDirective<TControls extends Record<string, FormUnit>> {
    private templateRef;
    private viewContainer;
    readonly layer: InputSignal<FormLayer<TControls, any>>;
    readonly show: InputSignal<boolean>;
    view?: EmbeddedViewRef<FormLayerDirectiveContext<TControls>>;
    constructor(templateRef: TemplateRef<FormLayerDirectiveContext<TControls>>, viewContainer: ViewContainerRef);
    static ngTemplateContextGuard<TControls extends Record<string, FormUnit>>(directive: FormLayerDirective<TControls>, context: unknown): context is FormLayerDirectiveContext<TControls>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormLayerDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormLayerDirective<any>, "[ngxFormLayer]", never, { "layer": { "alias": "ngxFormLayer"; "required": true; "isSignal": true; }; "show": { "alias": "ngxFormLayerWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
interface FormLayerDirectiveContext<TControls extends Record<string, FormUnit>> {
    ngxFormLayer: TControls;
}

declare class FormListDirective<TControls extends Record<string, FormUnit>> {
    private templateRef;
    private viewContainer;
    readonly list: InputSignal<FormList<TControls, any, any>>;
    readonly show: InputSignal<boolean>;
    views: Map<ControlFormLayer<TControls>, EmbeddedViewRef<FormListDirectiveContext<TControls>>>;
    constructor(templateRef: TemplateRef<FormListDirectiveContext<TControls>>, viewContainer: ViewContainerRef);
    private clear;
    static ngTemplateContextGuard<TControls extends Record<string, FormUnit>>(directive: FormListDirective<TControls>, context: unknown): context is FormListDirectiveContext<TControls>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormListDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormListDirective<any>, "[ngxFormList][ngxFormListIn]", never, { "list": { "alias": "ngxFormListIn"; "required": true; "isSignal": true; }; "show": { "alias": "ngxFormListWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class FormListDirectiveContext<TControls extends Record<string, FormUnit>> {
    $implicit: TControls;
    ngxFormListIn: TControls[];
    index: number;
    layer: ControlFormLayer<TControls>;
    constructor(layer: ControlFormLayer<TControls>, index: number, list: TControls[]);
    update(layer: ControlFormLayer<TControls>, index: number, list: TControls[]): boolean;
}

declare class FormCardComponent {
    readonly icon: InputSignal<string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormCardComponent, "ngx-form-card", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class FormFlowWrapperComponent {
    readonly minWidth: InputSignal<number>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFlowWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFlowWrapperComponent, "ngx-form-flow", never, { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class NgxFormCardTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxFormCardTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxFormCardTitleDirective, "[ngxFormCardTitle]", never, {}, {}, never, never, true, never>;
}

declare class NgxFormCardDescriptionDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxFormCardDescriptionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxFormCardDescriptionDirective, "[ngxFormCardDescription]", never, {}, {}, never, never, true, never>;
}

declare class NgxFormCardTextDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxFormCardTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxFormCardTextDirective, "[ngxFormCardText]", never, {}, {}, never, never, true, never>;
}

declare class NgxFormCardWarningDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxFormCardWarningDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxFormCardWarningDirective, "[ngxFormCardWarning]", never, {}, {}, never, never, true, never>;
}

declare abstract class BaseInputComponent<TIn, TVal> {
    readonly baseClass = true;
    protected inputElementRef: Signal<ElementRef<HTMLElement | HTMLTextAreaElement | HTMLInputElement> | undefined>;
    /** The main input element */
    protected inputElement: Signal<HTMLElement | HTMLTextAreaElement | HTMLInputElement | undefined>;
    /** A list of all NgModels in the input */
    private ngModels;
    readonly requiredIn: InputSignalWithTransform<boolean, unknown>;
    readonly hideRequired: InputSignalWithTransform<boolean, unknown>;
    protected required: Signal<boolean>;
    private _touched;
    readonly touched: Signal<boolean>;
    readonly changed: Signal<boolean>;
    markAsTouched(): void;
    markAsUntouched(): void;
    /** The internal error state used for input level errors */
    protected inputError: WritableSignal<string | undefined>;
    private inputErrors;
    readonly errors: Signal<string[]>;
    readonly hasError: Signal<boolean>;
    protected readonly errorMatcher: Signal<_juulsgaard_ngx_forms.TouchedErrorStateMatcher | _juulsgaard_ngx_forms.AlwaysErrorStateMatcher | _juulsgaard_ngx_forms.NeverErrorStateMatcher>;
    readonly canShowError: Signal<boolean>;
    readonly showError: Signal<boolean>;
    /** The internal error state used for input level warnings */
    protected inputWarning: WritableSignal<string | undefined>;
    private inputWarnings;
    readonly warnings: Signal<string[]>;
    readonly hasWarning: Signal<boolean>;
    /** A controls that contains the input value / state */
    readonly control: InputSignal<FormNode<TIn> | FormNode<TIn | undefined> | undefined>;
    readonly valueIn: ModelSignal<TIn | undefined>;
    readonly valueIn$: InputSignalWithTransform<Subject<TIn | undefined> | Observable<TIn | undefined> | undefined, Subject<TIn | undefined> | Subscribable<TIn | undefined> | undefined | null>;
    private externalSubject;
    protected externalValue: Signal<TIn | undefined>;
    protected _value: WritableSignal<TVal>;
    /** The value representing the internal input state */
    protected get value(): TVal;
    /** The value representing the internal input state */
    protected set value(val: TVal);
    readonly disabledIn: InputSignalWithTransform<boolean, unknown>;
    /** Marks that the input should be shown as disabled */
    protected disabled: Signal<boolean>;
    /** Disable hiding the input when it's disabled */
    readonly showDisabledIn: InputSignalWithTransform<boolean, unknown>;
    protected showDisabled: Signal<boolean>;
    /** Marks whether the input should be displayed or not */
    protected show: Signal<boolean>;
    private formScope;
    readonly readonlyIn: InputSignalWithTransform<boolean, unknown>;
    protected readonly: Signal<boolean>;
    /** The input label */
    readonly labelIn: InputSignal<string | undefined>;
    protected label: Signal<string | undefined>;
    /** A placeholder text, if not set the label will be used */
    readonly placeholderIn: InputSignal<string | undefined>;
    protected placeholder: Signal<string>;
    /** Input to tell the browser what type of autocomplete the input should use */
    readonly autocompleteIn: InputSignal<string | undefined>;
    protected autocomplete: Signal<string | undefined>;
    /** Focus the input when it's first created */
    readonly autofocusIn: InputSignalWithTransform<boolean, unknown>;
    protected autofocus: Signal<boolean | undefined>;
    /** Add a tooltip with additional information about the input */
    readonly tooltipIn: InputSignal<string | undefined>;
    protected tooltip: Signal<string | undefined>;
    /** Set the theme color for the input */
    readonly colorIn: InputSignal<ThemePalette>;
    protected color: Signal<ThemePalette>;
    /** Change the material input style */
    readonly appearanceIn: InputSignal<MatFormFieldAppearance>;
    protected appearance: Signal<MatFormFieldAppearance>;
    /** Hide the required asterisk */
    readonly directionIn: InputSignal<"ltr" | "rtl" | "auto" | undefined>;
    protected direction: Signal<"ltr" | "rtl" | "auto" | undefined>;
    private lastValue?;
    private element;
    private scrollContainer;
    protected constructor();
    /** Focus the input */
    focus(options?: FocusOptions): void;
    /** Select the contents of the input */
    select(): void;
    scrollTo(): void;
    /**
     * Processes the value from the FormNode before it is assigned to the inputValue prop
     * @param value The value to processed
     */
    abstract preprocessValue(value: TIn | undefined): TVal;
    /**
     * Processes the value generated by the input component and returns the value that is stored in the FormNode
     * @param value The value to be processed
     */
    abstract postprocessValue(value: TVal): TIn | undefined;
    /**
     * Generate an initial value for the internal state
     */
    getInitialValue(): TVal;
    /** Handle events dispatched from the FormNode */
    protected handleAction(event: FormNodeEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInputComponent<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseInputComponent<any, any>, never, never, { "requiredIn": { "alias": "required"; "required": false; "isSignal": true; }; "hideRequired": { "alias": "hideRequired"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; "valueIn": { "alias": "value"; "required": false; "isSignal": true; }; "valueIn$": { "alias": "value$"; "required": false; "isSignal": true; }; "disabledIn": { "alias": "disabled"; "required": false; "isSignal": true; }; "showDisabledIn": { "alias": "showDisabled"; "required": false; "isSignal": true; }; "readonlyIn": { "alias": "readonly"; "required": false; "isSignal": true; }; "labelIn": { "alias": "label"; "required": false; "isSignal": true; }; "placeholderIn": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocompleteIn": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "autofocusIn": { "alias": "autofocus"; "required": false; "isSignal": true; }; "tooltipIn": { "alias": "tooltip"; "required": false; "isSignal": true; }; "colorIn": { "alias": "color"; "required": false; "isSignal": true; }; "appearanceIn": { "alias": "appearance"; "required": false; "isSignal": true; }; "directionIn": { "alias": "direction"; "required": false; "isSignal": true; }; }, { "valueIn": "valueChange"; }, never, never, true, never>;
}

declare abstract class BaseSelectInputComponent<TValue, TItem, TMultiple extends boolean, TState> extends BaseInputComponent<TMultiple extends true ? TValue[] : TValue, TState> {
    abstract readonly multiple: TMultiple;
    readonly control: InputSignal<FormNode<TMultiple extends true ? TValue[] : TValue> | FormNode<(TMultiple extends true ? TValue[] : TValue) | undefined> | FormSelectNode<TValue, TItem, TMultiple> | undefined>;
    protected selectControl: Signal<FormSelectNode<TValue, TItem, TMultiple> | undefined>;
    private controlItems$;
    private controlItems;
    readonly itemsIn: InputSignal<TItem[] | undefined>;
    protected items: Signal<TItem[]>;
    protected readonly mappedItems: Signal<FormSelectValue<TItem, TValue>[]>;
    protected empty: Signal<boolean>;
    readonly hideEmptyIn: InputSignalWithTransform<boolean, unknown>;
    protected hideEmpty: Signal<boolean>;
    protected hidden: Signal<boolean>;
    readonly clearableIn: InputSignalWithTransform<boolean, unknown>;
    protected clearable: Signal<boolean>;
    readonly selectGroupsIn: InputSignalWithTransform<boolean, unknown>;
    protected selectGroups: Signal<boolean>;
    constructor();
    readonly bindValue: InputSignalWithTransform<MapFunc<TItem, TValue> | undefined, string | Selection<TItem, TValue> | undefined | null>;
    private controlBindValue;
    protected getValue: Signal<MapFunc<TItem, TValue> | undefined>;
    protected mapValue(item: TItem): TValue;
    readonly bindLabel: InputSignalWithTransform<MapFunc<TItem, string> | undefined, string | Selection<TItem, string> | undefined | null>;
    private controlBindLabel;
    protected getLabel: Signal<MapFunc<TItem, string> | undefined>;
    protected mapLabel(item: TItem): string;
    readonly bindOption: InputSignalWithTransform<MapFunc<TItem, string> | undefined, string | Selection<TItem, string> | undefined | null>;
    private controlBindOption;
    protected getOption: Signal<MapFunc<TItem, string> | undefined>;
    protected mapOption(item: TItem): string;
    readonly groupByIn: InputSignalWithTransform<MapFunc<TItem, string> | undefined, string | Selection<TItem, string> | undefined | null>;
    protected groupBy: Signal<MapFunc<TItem, string> | undefined>;
    getInitialValue(): TState;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSelectInputComponent<any, any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseSelectInputComponent<any, any, any, any>, never, never, { "itemsIn": { "alias": "items"; "required": false; "isSignal": true; }; "hideEmptyIn": { "alias": "hideEmpty"; "required": false; "isSignal": true; }; "clearableIn": { "alias": "clearable"; "required": false; "isSignal": true; }; "selectGroupsIn": { "alias": "selectGroupsIn"; "required": false; "isSignal": true; }; "bindValue": { "alias": "bindValue"; "required": false; "isSignal": true; }; "bindLabel": { "alias": "bindLabel"; "required": false; "isSignal": true; }; "bindOption": { "alias": "bindOption"; "required": false; "isSignal": true; }; "groupByIn": { "alias": "groupBy"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class FormSelectValue<T, TId> {
    readonly value: T;
    readonly id: TId;
    readonly name: string;
    constructor(value: T, id?: TId, name?: string);
}
declare abstract class BaseMultiSelectInputComponent<TValue, TItem, TState> extends BaseSelectInputComponent<TValue, TItem, true, TState> {
    readonly multiple = true;
    readonly control: InputSignal<FormNode<TValue[]> | FormNode<TValue[] | undefined> | FormSelectNode<TValue, TItem, true> | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseMultiSelectInputComponent<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseMultiSelectInputComponent<any, any, any>, never, never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare abstract class BaseSingleSelectInputComponent<TValue, TItem, TState> extends BaseSelectInputComponent<TValue, TItem, false, TState> {
    readonly multiple = false;
    readonly control: InputSignal<FormNode<TValue> | FormNode<TValue | undefined> | FormSelectNode<TValue, TItem, false> | FormSelectNode<TValue | undefined, TItem, false> | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSingleSelectInputComponent<any, any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseSingleSelectInputComponent<any, any, any>, never, never, { "control": { "alias": "control"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TouchedErrorStateMatcher implements ErrorStateMatcher {
    isErrorState(control: UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
}
declare const touchedErrorStateMatcher: TouchedErrorStateMatcher;
declare class AlwaysErrorStateMatcher implements ErrorStateMatcher {
    isErrorState(control: UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
}
declare const alwaysErrorStateMatcher: AlwaysErrorStateMatcher;
declare class NeverErrorStateMatcher implements ErrorStateMatcher {
    isErrorState(control: UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
}
declare const neverErrorStateMatcher: NeverErrorStateMatcher;

declare abstract class FormContext {
    abstract readonly readonly: Signal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormContext, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormContext>;
}

declare class FormWrapperComponent extends FormContext {
    readonly submitted: i0.OutputEmitterRef<void>;
    readonly fieldset: InputSignalWithTransform<boolean, unknown>;
    readonly readonly: InputSignalWithTransform<boolean, unknown>;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<FormWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormWrapperComponent, "ngx-form-wrapper", never, { "fieldset": { "alias": "fieldset"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, ["*"], true, never>;
}

/** Form rendering for a FormDialog. Can only be used inside Form Dialogs */
declare class FormDialogDirective<TControls extends Record<string, FormUnit>> {
    readonly viewContainer: ViewContainerRef;
    readonly template: TemplateRef<DialogFormContext<TControls>>;
    form: InputSignalWithTransform<FormRoot<TControls, SimpleObject>, BaseFormDialog<TControls, SimpleObject>>;
    private view?;
    readonly show: i0.WritableSignal<boolean>;
    constructor(viewContainer: ViewContainerRef, template: TemplateRef<DialogFormContext<TControls>>);
    static ngTemplateContextGuard<TControls extends Record<string, FormUnit>>(directive: FormDialogDirective<TControls>, context: unknown): context is DialogFormContext<TControls>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormDialogDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormDialogDirective<any>, "[ngxDialogForm]", never, { "form": { "alias": "dialogForm"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
interface DialogFormContext<TControls extends Record<string, FormUnit>> {
    dialogForm: TControls;
}

declare class FormDialogComponent<T extends Record<string, unknown>> implements OnDestroy {
    private manager;
    private injector;
    readonly showErrors: i0.WritableSignal<boolean>;
    readonly config: InputSignal<FormDialog<T>>;
    readonly formTemplate: i0.Signal<FormDialogDirective<Record<string, _juulsgaard_ngx_forms_core.FormUnit>> | undefined>;
    readonly content: i0.Signal<RenderSourceDirective<any>>;
    readonly footer: i0.Signal<RenderSourceDirective<any>>;
    readonly canClose: InputSignalWithTransform<boolean, unknown>;
    private defaults;
    instance?: TemplateDialogInstance;
    constructor(manager: DialogManagerService, injector: Injector);
    ngOnDestroy(): void;
    destroy(): void;
    formSubmit(): Promise<void>;
    onEnter(event: Event | KeyboardEvent): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormDialogComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormDialogComponent<any>, "ngx-form-dialog", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "canClose": { "alias": "canClose"; "required": false; "isSignal": true; }; }, {}, ["formTemplate"], ["*"], true, never>;
}

interface FormInputConfig {
    register(type: FormNodeType, component: Type<BaseInputComponent<any, any>>): this;
}
declare class FormInputRegistry {
    private map;
    constructor(map: Map<FormNodeType, Type<BaseInputComponent<any, any>>>);
    getComponent(type: FormNodeType): Type<BaseInputComponent<any, any>> | undefined;
}
declare function provideFormInputs(builder: (cfg: FormInputConfig) => void): Provider;

declare class FormInputDirective {
    /** The input label */
    readonly label: InputSignal<string | undefined>;
    /** A placeholder text, if not set the label will be used */
    readonly placeholder: InputSignal<string | undefined>;
    /** Input to tell the browser what type of autocomplete the input should use */
    readonly autocomplete: InputSignal<string | undefined>;
    /** Focus the input when it's first created */
    readonly autofocus: InputSignalWithTransform<boolean, unknown>;
    /** Add a tooltip with additional information about the input */
    readonly tooltip: InputSignal<string | undefined>;
    /** Set the theme color for the input */
    readonly color: InputSignal<ThemePalette>;
    /** Change the material input style */
    readonly appearance: InputSignal<MatFormFieldAppearance>;
    /** Hide the required asterisk */
    readonly direction: InputSignal<"ltr" | "rtl" | "auto" | undefined>;
    readonly disabled: InputSignalWithTransform<boolean, unknown>;
    readonly readonly: InputSignalWithTransform<boolean, unknown>;
    readonly control: InputSignal<AnonFormNode | undefined>;
    private registry;
    private viewContainer;
    private component?;
    constructor();
    private updateComponentInputs;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormInputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FormInputDirective, "form-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare abstract class NgxFormFieldDirective<T> implements MatFormFieldControl<T | undefined> {
    static nextId: number;
    protected uid: string;
    readonly idIn: InputSignal<string | undefined>;
    protected readonly _id: i0.Signal<string>;
    get id(): string;
    readonly ngxModel: ModelSignal<T | undefined>;
    readonly control: InputSignal<FormNode<T> | FormNode<T | undefined> | undefined>;
    private readonly _value;
    readonly touched: i0.OutputEmitterRef<void>;
    readonly ngControl: null;
    protected element: any;
    private lastValue?;
    protected constructor();
    protected abstract writeValue(value: T | undefined): void;
    protected setValue(value: T | undefined): void;
    get value(): T | undefined;
    set value(value: T | undefined);
    private readonly _stateChanges;
    readonly stateChanges: rxjs.Observable<void>;
    protected update(): void;
    readonly placeholderIn: InputSignal<string | undefined>;
    protected readonly _placeholder: i0.Signal<string>;
    get placeholder(): string;
    protected readonly _focused: i0.WritableSignal<boolean>;
    get focused(): boolean;
    protected readonly _empty: i0.Signal<boolean>;
    get empty(): boolean;
    protected abstract isEmpty(value: T | undefined): boolean;
    protected readonly _shouldLabelFloat: i0.Signal<boolean>;
    get shouldLabelFloat(): boolean;
    readonly requiredIn: InputSignalWithTransform<boolean, unknown>;
    protected readonly _required: i0.Signal<boolean>;
    get required(): boolean;
    readonly disabledIn: InputSignalWithTransform<boolean, unknown>;
    protected readonly _disabled: i0.Signal<boolean>;
    get disabled(): boolean;
    readonly nodeErrorState: i0.Signal<boolean>;
    readonly errorStateIn: InputSignalWithTransform<boolean, unknown>;
    protected readonly _errorState: i0.Signal<boolean>;
    get errorState(): boolean;
    readonly controlType = "ngx-input";
    protected readonly _autofilled: i0.WritableSignal<boolean>;
    get autofilled(): boolean;
    readonly userAriaDescribedByIn: InputSignal<string | undefined>;
    protected readonly _userAriaDescribedBy: i0.Signal<string>;
    get userAriaDescribedBy(): string;
    onContainerClick(): void;
    setDescribedByIds(ids: string[]): void;
    abstract focus(options?: FocusOptions): void;
    protected onFocus(): void;
    protected onBlur(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxFormFieldDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxFormFieldDirective<any>, never, never, { "idIn": { "alias": "id"; "required": false; "isSignal": true; }; "ngxModel": { "alias": "ngxModel"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; "placeholderIn": { "alias": "placeholder"; "required": false; "isSignal": true; }; "requiredIn": { "alias": "required"; "required": false; "isSignal": true; }; "disabledIn": { "alias": "disabled"; "required": false; "isSignal": true; }; "errorStateIn": { "alias": "showError"; "required": false; "isSignal": true; }; "userAriaDescribedByIn": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; }, { "ngxModel": "ngxModelChange"; "touched": "touched"; }, never, never, true, never>;
}

declare class NgxInputDirective<T> extends NgxFormFieldDirective<T> {
    protected _inMdcFormField: boolean;
    private autofillMonitor;
    constructor();
    focus(options: FocusOptions$1 | undefined): void;
    protected isEmpty(value: T | undefined): boolean;
    protected writeValue(value: T | undefined): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxInputDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgxInputDirective<any>, "input[ngxInput], textarea[ngxInput], [contentEditable][ngxInput]", never, {}, {}, never, never, true, never>;
}

declare class FormErrorStateComponent {
    readonly errors: InputSignalWithTransform<FormValidationContext[] | string[], FormValidationContext[] | string[] | undefined>;
    readonly warnings: InputSignalWithTransform<FormValidationContext[] | string[], FormValidationContext[] | string[] | undefined>;
    tooltip: i0.Signal<string>;
    readonly button: InputSignalWithTransform<boolean, unknown>;
    readonly show: InputSignal<boolean>;
    readonly showChange: OutputEmitterRef<boolean>;
    toggleErrors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormErrorStateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormErrorStateComponent, "ngx-form-error-state", never, { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "warnings": { "alias": "warnings"; "required": false; "isSignal": true; }; "button": { "alias": "button"; "required": false; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; }, { "showChange": "showChange"; }, never, never, true, never>;
}

declare class FormErrorsComponent {
    show: InputSignalWithTransform<boolean, unknown>;
    showAllIn: ModelSignal<boolean | undefined>;
    private _showAll;
    showAll: Signal<boolean>;
    errors: InputSignalWithTransform<FormValidationContext[] | string[], FormValidationContext[] | string[] | undefined>;
    warnings: InputSignalWithTransform<FormValidationContext[] | string[], FormValidationContext[] | string[] | undefined>;
    list: Signal<Data[]>;
    hasMore: Signal<boolean>;
    first: Signal<Data | undefined>;
    rest: Signal<Data[]>;
    constructor();
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormErrorsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormErrorsComponent, "ngx-form-errors", never, { "show": { "alias": "show"; "required": false; "isSignal": true; }; "showAllIn": { "alias": "showAll"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "warnings": { "alias": "warnings"; "required": false; "isSignal": true; }; }, { "showAllIn": "showAllChange"; }, never, never, true, never>;
}
interface Data {
    type: 'warning' | 'error';
    message: string;
    icon?: string;
    scrollTo?: () => void;
    context?: FormValidationContext;
}

declare class FormHeaderComponent<T extends SimpleObject> {
    readonly form: InputSignal<FormPage<T>>;
    back: EventEmitter<void>;
    close: EventEmitter<void>;
    showErrors: EventEmitter<void>;
    readonly heading: InputSignal<string | undefined>;
    readonly subHeading: InputSignal<string | undefined>;
    readonly hideClose: InputSignalWithTransform<boolean, unknown>;
    readonly hideBack: InputSignalWithTransform<boolean, unknown>;
    private uiContext;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<FormHeaderComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormHeaderComponent<any>, "ngx-form-header", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "subHeading": { "alias": "subHeading"; "required": false; "isSignal": true; }; "hideClose": { "alias": "hideClose"; "required": false; "isSignal": true; }; "hideBack": { "alias": "hideBack"; "required": false; "isSignal": true; }; }, { "back": "back"; "close": "close"; "showErrors": "showErrors"; }, never, ["*"], true, never>;
}

declare class FormSubmitComponent<T extends SimpleObject> {
    readonly form: InputSignal<FormPage<T>>;
    readonly disableShortcut: i0.InputSignalWithTransform<boolean, unknown>;
    private tabContext;
    private formContext;
    readonly showErrors: i0.WritableSignal<boolean>;
    readonly readonly: i0.Signal<boolean>;
    constructor();
    onSubmit(): void;
    onDelete(): void;
    onShowChange(show: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormSubmitComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormSubmitComponent<any>, "ngx-form-submit", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "disableShortcut": { "alias": "disableShortcut"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

export { AlwaysErrorStateMatcher, BaseInputComponent, BaseMultiSelectInputComponent, BaseSelectInputComponent, BaseSingleSelectInputComponent, FormCardComponent, FormContext, FormDialogComponent, FormDialogDirective, FormDirective, FormErrorStateComponent, FormErrorsComponent, FormFlowWrapperComponent, FormHeaderComponent, FormInputDirective, FormInputRegistry, FormLayerDirective, FormListDirective, FormSelectValue, FormSubmitComponent, FormWrapperComponent, NeverErrorStateMatcher, NgxFormCardDescriptionDirective, NgxFormCardTextDirective, NgxFormCardTitleDirective, NgxFormCardWarningDirective, NgxFormFieldDirective, NgxInputDirective, TouchedErrorStateMatcher, alwaysErrorStateMatcher, neverErrorStateMatcher, provideFormInputs, touchedErrorStateMatcher };
export type { DialogFormContext, FormInputConfig };