import * as i0 from '@angular/core';
import { AfterContentInit, AfterContentChecked, AfterViewInit, ElementRef, ChangeDetectorRef } from '@angular/core';
import * as i3 from '@daffodil/design';
import { DaffPrefixDirective, DaffSuffixDirective, DaffFormLabelDirective } from '@daffodil/design';
import * as i2 from '@daffodil/design/form';
import { DaffFormFieldLabelDirective, DaffHintComponent, DaffErrorMessageComponent } from '@daffodil/design/form';
import { NgControl } from '@angular/forms';
import { BehaviorSubject, Observable } from 'rxjs';

/**
 * DaffFormFieldActionDirective marks an element, typically a button, as an action attached to a form control inside `DaffFormFieldComponent`.
 */
declare class DaffFormFieldActionDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffFormFieldActionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DaffFormFieldActionDirective, "[daffFormFieldAction]", never, {}, {}, never, never, true, never>;
}

interface DaffFormFieldState {
    focused: boolean;
    filled: boolean;
    disabled: boolean;
    error: boolean;
    valid: boolean;
}

/**
 * Form controls must extend this class to be used inside `DaffFormFieldComponent`.
 *
 * > **Note**
 * > The control is defined as an abstract class instead of an interface to support Angular's dependency injection. Interfaces are erased during TypeScript compilation and cannot be used as DI tokens.
 * >
 * > By using an abstract class, the Angular DI container can match the class token for injection.
 */
declare abstract class DaffFormFieldControl<T> {
    ngControl: NgControl | null;
    /**
     * The type of the control (e.g., 'input', 'select', 'textarea').
     * Used to apply control-specific styling or behavior.
     */
    abstract readonly controlType?: any;
    /**
     * Whether the control supports automatic label behavior.
     * When `true`, the form field will associate the label with the control using `for` and `id` attributes.
     *
     * Defaults to `true`.
     */
    readonly supportsAutoLabelling?: boolean;
    /**
     * Whether the control currently has focus.
     */
    abstract readonly focused: boolean;
    /**
     * Whether the control is required for form validation.
     */
    abstract readonly required: boolean;
    /**
     * Whether the control is disabled.
     */
    abstract readonly disabled: boolean;
    /**
     * The unique identifier for the control element.
     */
    readonly id?: string;
    /**
     * Whether the label should be in the raised position.
     * By default, matches the focused state.
     */
    get raised(): boolean;
    /**
     * Sets focus on the control.
     *
     * @param event - Optional event that triggers the focus.
     */
    abstract focus(event?: Event): void;
    /**
     * The current value of the control.
     */
    abstract readonly value: T;
    constructor(ngControl: NgControl | null);
    /**
     * Computes the current state of the form field control.
     * Combines control properties and form validation state.
     */
    get state(): DaffFormFieldState;
    _stateChanges: BehaviorSubject<{
        focused: boolean;
        filled: boolean;
        disabled: boolean;
        error: boolean;
        valid: boolean;
    }>;
    /**
     * Observable stream of state changes for the form field control.
     */
    stateChanges: Observable<DaffFormFieldState>;
    /**
     * Emits the current state.
     */
    emitState(deferred?: boolean): void;
}

type DaffFormFieldApperanace = 'fluid' | 'fixed';
/**
 * DaffFormFieldComponent is a wrapping component that provides consistent styling and behavior for form control elements.
 */
declare class DaffFormFieldComponent implements AfterContentInit, AfterContentChecked, AfterViewInit {
    private cd;
    elementRef: ElementRef;
    /** @docs-private */
    get isNativeSelect(): boolean;
    constructor(cd: ChangeDetectorRef, elementRef: ElementRef);
    /** @docs-private */
    _prefix: DaffPrefixDirective;
    /** @docs-private */
    _suffix: DaffSuffixDirective;
    /**
     * @docs-private
     *
     * The child form control that the form field manages.
     */
    _control: DaffFormFieldControl<unknown>;
    /**
     * @docs-private
     * @deprecated Deprecated in version 0.86.0. Will be removed in version 1.0.0.
     */
    _formLabelDirective: DaffFormLabelDirective;
    /**
     * @docs-private
     */
    _formFieldLabelDirective: DaffFormFieldLabelDirective;
    /**
     * @docs-private
     */
    _action: DaffFormFieldActionDirective;
    /**
     * @docs-private
     */
    private _hint;
    /**
     * @docs-private
     */
    private _error;
    /**
     * @docs-private
     *
     * Tracking property to keep a record of whether or not the
     * form field should be marked as error.
     */
    isError: boolean;
    /**
     * @docs-private
     *
     * Tracking property to keep a record of whether or not the
     * form field contains any user input.
     */
    isFilled: boolean;
    /**
     * @docs-private
     *
     * Tracking property to keep a record of whether or not the
     * form field should be marked as disabled.
     */
    isDisabled: boolean;
    /**
     * @docs-private
     *
     * Tracking property to keep a record of whether or not the
     * form field should be marked as valid.
     */
    isValid: boolean;
    /**
     * @docs-private
     *
     * Determines whether or not the form field should display its focused state.
     */
    get isFocused(): boolean;
    /**
     * @docs-private
     */
    get isRaised(): boolean;
    private _appearance;
    /**
     * The appearance of the form field. Defaults to `fluid`.
     */
    get appearance(): DaffFormFieldApperanace;
    set appearance(value: DaffFormFieldApperanace);
    /**
     * @docs-private
     */
    get isFixed(): boolean;
    /**
     * The unique id of the form field. Defaults to an autogenerated value. When using this,
     * it's your responsibility to ensure that the id for each form field is unique.
     *
     * It gets assigned to the `for` attribute on the `<label>` inside of the form field.
     */
    id: string;
    /**
     * @docs-private
     */
    hasHint(): boolean;
    /**
     * @docs-private
     */
    hintId: string;
    /**
     * @docs-private
     */
    hasErrorMessage(): boolean;
    /**
     * @docs-private
     */
    errorMessageId: string;
    /**
     * @docs-private
     */
    get autoLabelId(): string;
    /**
     * @docs-private
     */
    get customId(): string;
    /**
     * @docs-private
     *
     * Displays a console warning if the `DaffFormFieldLabelDirective` is not used on controls (native HTML control elements) that support auto-labelling.
     */
    ngAfterViewInit(): void;
    /**
     * Validates whether or not the form field is in a "usable" state.
     */
    private _validateFormControl;
    /**
     * @docs-private
     *
     * Lifecycle hook to verify that the form field has an acceptable
     * child control instance. Mostly useful for development-time
     * validation of usage.
     */
    ngAfterContentInit(): void;
    /**
     * @docs-private
     *
     * Lifecycle hook to verify that the form field has an acceptable
     * child control instance. Mostly useful for development-time
     * validation of usage.
     */
    ngAfterContentChecked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffFormFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DaffFormFieldComponent, "daff-form-field", never, { "appearance": { "alias": "appearance"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, ["_prefix", "_suffix", "_control", "_formLabelDirective", "_formFieldLabelDirective", "_action", "_hint", "_error"], ["*", "[daffPrefix]", "*", "[daffSuffix]", "daff-hint", "daff-error-message", "[daffFormFieldAction]", "label[daffFormLabel]", "daff-form-label", "label"], true, [{ directive: typeof i3.DaffSkeletonableDirective; inputs: { "skeleton": "skeleton"; }; outputs: {}; }]>;
}

/**
 * @deprecated in favor of standalone components. Deprecated in version 0.84.0. Will be removed in version 1.0.0.
 */
declare class DaffFormFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DaffFormFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffFormFieldModule, never, [typeof DaffFormFieldComponent, typeof i2.DaffErrorMessageComponent, typeof i2.DaffHintComponent, typeof i2.DaffFormFieldLabelDirective, typeof i3.DaffFormLabelModule], [typeof DaffFormFieldComponent, typeof i2.DaffErrorMessageComponent, typeof i2.DaffHintComponent, typeof i2.DaffFormFieldLabelDirective, typeof i3.DaffFormLabelModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DaffFormFieldModule>;
}

/**
 * @docs-private
 */
declare const DAFF_FORM_FIELD_COMPONENTS: readonly [typeof DaffFormFieldComponent, typeof DaffFormLabelDirective, typeof DaffPrefixDirective, typeof DaffSuffixDirective, typeof DaffFormFieldActionDirective, typeof DaffHintComponent, typeof DaffFormFieldLabelDirective, typeof DaffErrorMessageComponent];

export { DAFF_FORM_FIELD_COMPONENTS, DaffFormFieldActionDirective, DaffFormFieldComponent, DaffFormFieldControl, DaffFormFieldModule };