import { Observable, Subject } from 'rxjs';
import * as _angular_core from '@angular/core';
import { AfterContentInit, Signal, OnInit, Injector } from '@angular/core';
import { AbstractControl } from '@angular/forms';
import { ControlBaseDirective } from '@talenra/ngx-base/shared';

/**
 * Values accepted by the `FormField`'s `status` property.
 *
 * ### Import
 *
 * ```typescript
 * import { FormFieldStatus } from '@talenra/ngx-base/form-field';
 * ```
 *
 * @see {@link FormField}
 * @see {@link TFormFieldStatus}
 */
declare const FormFieldStatus: {
    readonly Default: "default";
    readonly Invalid: "invalid";
};
/**
 * Type of values accepted by the `FormField`'s `status` property.
 *
 * ### Import
 *
 * ```typescript
 * import { TFormFieldStatus } from '@talenra/ngx-base/form-field';
 * ```
 *
 * @see {@link FormField}
 * @see {@link FormFieldStatus}
 */
type TFormFieldStatus = (typeof FormFieldStatus)[keyof typeof FormFieldStatus];
/**
 * Values accepted by the `FormField`'s `size§` property.
 *
 * ### Import
 *
 * ```typescript
 * import { FormFieldSize } from '@talenra/ngx-base/form-field';
 * ```
 *
 * @see {@link FormField}
 * @see {@link TFormFieldSize}
 */
declare const FormFieldSize: {
    readonly S: "s";
    readonly M: "m";
};
/**
 * Type of values accepted by the `FormField`'s `size` property.
 *
 * ### Import
 *
 * ```typescript
 * import { TFormFieldSize } from '@talenra/ngx-base/form-field';
 * ```
 *
 * @see {@link FormField}
 * @see {@link FormFieldSize}
 */
type TFormFieldSize = (typeof FormFieldSize)[keyof typeof FormFieldSize];

/**
 * `<talenra-form-field>` is a wrapper for form inputs.
 *
 * - implements the label associated with the input
 * - adds a hook to display validation errors
 * - shows an optional hint text
 * - injects consistent styling and behaviour for different inputs
 *
 * Minimal example:
 *
 * ```html
 * <talenra-form-field label="Email">
 *   <input talenra-input formControlName="email" type="email" />
 * </talenra-form-field>
 * ```
 *
 * Example using a hint text and validation errors:
 *
 * ```html
 * <talenra-form-field label="Email">
 *   <input talenra-input formControlName="email" type="email" required />
 *   <talenra-form-error [isVisible]="emailEmpty">This field is required.</talenra-form-error>
 *   <talenra-form-error [isVisible]="emailInvalid">Email address is invalid.</talenra-form-error>
 * </talenra-form-field>
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { FormFieldComponent } from '@talenra/ngx-base/form-field';
 * ```
 *
 * <example-url>../../#/input</example-url>
 *
 * @see {@link FormErrorComponent}
 */
declare class FormFieldComponent implements AfterContentInit {
    /** Optional hint text displayed to the user */
    hint?: string;
    /**
     * Label displayed to the user
     *
     * ```html
     * <talenra-form-field ... label="Email"></talenra-form-field>
     * ```
     */
    label: _angular_core.InputSignal<string>;
    /**
     * Determines the size of FormField and the wrapped control. Defaults to `m`.
     *
     * ```html
     * <talenra-form-field ... size="s"></talenra-form-field>
     * ```
     *
     * @see {@link FormFieldSize}
     */
    size: _angular_core.InputSignal<TFormFieldSize>;
    /**
     * Suppress the clear button which is displayed by default if the input has a
     * value and is focused.
     *
     * ```html
     * <talenra-form-field ... hideClearButton></talenra-form-field>
     * ````
     */
    hideClearButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Status of the form-field. Controls display status like "invalid".
     *
     * @internal
     */
    status: _angular_core.WritableSignal<TFormFieldStatus>;
    /** @internal */
    control?: FormFieldControl<any>;
    private hostClass;
    private readonly changeDetector;
    private readonly destroyRef;
    /** @internal */
    ngAfterContentInit(): void;
    private updateState;
    private updateHostClass;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldComponent, "talenra-form-field", never, { "hint": { "alias": "hint"; "required": false; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hideClearButton": { "alias": "hideClearButton"; "required": false; "isSignal": true; }; }, {}, ["control"], ["*", "talenra-form-error"], true, never>;
}

/**
 * Abstract class defining the requirements for a control implemented by a `FormFieldComponent` instance.
 */
declare abstract class FormFieldControl<T> {
    /** Determines whether the control is disabled. */
    readonly disabled: boolean;
    /** Determines whether the control is read-only. */
    readonly readonly: boolean;
    /** Determines whether the control has focus. */
    readonly hasFocus: boolean;
    /** Determines whether the control or any element within has focus. Used to toggle clear button visibility. */
    readonly hasFocusWithin: boolean;
    /** The control's id (the value used in the HTML element's id attribute). */
    readonly id: string;
    /** Determines whether the control contains a value. */
    readonly isEmpty: boolean;
    /** Determines whether the control's value is required. */
    readonly required: boolean;
    /** Determines whether the control's value is invalid. */
    readonly invalid: boolean;
    /** Determines whether the control is touched. A control is considered touched after the user has triggered a 'blur' event on the control. */
    readonly touched: boolean;
    /** Determines whether the control is dirty. A control is considered dirty after the user has changed its value in the UI. */
    readonly dirty: boolean;
    /** Reference to the enclosing FormField if available */
    readonly formField?: FormFieldComponent;
    /** Determines whether the control's content has scroll offset. */
    readonly hasScroll: Signal<boolean>;
    /** Observable, pushes an empty notification whenever the state of the control changes (e.g. when it gets focus). */
    readonly stateChanges: Observable<void>;
    /**
     * Determines whether the control (Input, Date, Select, etc.) includes its own ControlContainer. Most controls are ok
     * to use the FormField's ControlContainer, but some controls (e.g. Date) require their own ControlContainer, like
     * Date, which has two separate input fields for date and time.
     *
     * true → The FormField will not display a label, read-only icon (padlock), clear button etc.
     * false → The FormField will display a label, read-only icon, clear button etc.
     *
     * see {@link DateComponent}
     */
    readonly hasControlContainer?: boolean;
    /**
     * `clearValue` is triggered when the user clicks the clear button in the FormField. It is the responsibility of the
     * control to clear its value and take any other necessary actions.
     */
    readonly clearValue: () => void;
}

/**
 * Clear button component. Used in ControlContainer to clear the wrapped control's value.
 *
 * @internal
 */
declare class ClearButtonComponent {
    /** Determines whether clear button is visible (fade-in/out). */
    isVisible: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClearButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClearButtonComponent, "talenra-clear-button", never, { "isVisible": { "alias": "isVisible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Wrapper for form controls used in FormField context. Adds read-only icon and underline effects.
 *
 * ### Import
 *
 * ```typescript
 * import { ControlContainerComponent } from '@talenra/ngx-base/form-field';
 * ```
 *
 * @internal
 */
declare class ControlContainerComponent implements OnInit {
    /** Label displayed to the user */
    label: _angular_core.InputSignal<string>;
    /** Determines whether the wrapped control is required. */
    required: _angular_core.InputSignal<boolean>;
    /** Determines whether the wrapped control has focus. */
    hasFocus: _angular_core.InputSignal<boolean>;
    /** Determines whether the wrapped control is read-only. */
    readonly: _angular_core.InputSignal<boolean>;
    /** Determines whether the wrapped control is disabled. */
    disabled: _angular_core.InputSignal<boolean>;
    /** Status of the form-field (e.g. "invalid"). */
    status: _angular_core.InputSignal<TFormFieldStatus>;
    /** Determindes whether the wrapped control contains a value. */
    isEmpty: _angular_core.InputSignal<boolean>;
    /**
     * Determines the size of ControlContainer. Defaults to "m".
     *
     * ```html
     * <talenra-control-container ... size="s"></talenra-control-container>
     * ```
     *
     * @see {@link FormFieldSize}
     */
    size: _angular_core.InputSignal<TFormFieldSize>;
    /**
     * Suppress the clear button which is displayed by default if the input has a value and is focused.
     *
     * ```html
     * <talenra-control-container ... hideClearButton></talenra-control-container>
     * ````
     */
    hideClearButton: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Determines whether the control's content has scroll offset (textarea). Used to show/hide the label's background.
     */
    hasScroll: _angular_core.InputSignal<boolean>;
    /**
     * Event emitted when the clear button is pressed.
     *
     * ```typescript
     * protected onClearValue(): void {
     *   console.log('Clear value');
     * }
     * ```
     *
     * ```html
     * <talenra-control-container (clearValue)="onClearValue()"></talenra-control-container>
     * ```
     */
    clearValue: _angular_core.OutputEmitterRef<void>;
    /** Determines whether clear button is visible */
    protected showClearButton: _angular_core.Signal<boolean>;
    /**
     * Determines whether the wrapped control (e.g. Input, Select) includes its own ControlContainer
     *
     * @see {@link FormFieldControl.hasControlContainer}
     */
    hasChildControlContainer: _angular_core.InputSignal<boolean>;
    /** Whether the UI shall use transitions (e.g. when the control gets focus) */
    private useTransition;
    /** @internal */
    ngOnInit(): void;
    /** Used for property binding in component's metadata */
    private FormFieldStatus;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ControlContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ControlContainerComponent, "talenra-control-container", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hasFocus": { "alias": "hasFocus"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "isEmpty": { "alias": "isEmpty"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hideClearButton": { "alias": "hideClearButton"; "required": false; "isSignal": true; }; "hasScroll": { "alias": "hasScroll"; "required": false; "isSignal": true; }; "hasChildControlContainer": { "alias": "hasChildControlContainer"; "required": false; "isSignal": true; }; }, { "clearValue": "clearValue"; }, never, ["*"], true, never>;
}

/**
 * `<talenra-form-error>` is used as a child element of `<talenra-form-field>` to display input validation errors.
 *
 * Use multiple instances to provide accurate description of the errors.
 *
 * ```html
 * <talenra-form-field label="Email">
 *   <input talenra-input formControlName="email" type="email" required />
 *   <talenra-form-error [isVisible]="emailEmpty">This field is required.</talenra-form-error>
 *   <talenra-form-error [isVisible]="emailInvalid">Email address is invalid.</talenra-form-error>
 * </talenra-form-field>
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { FormErrorComponent } from '@talenra/ngx-base/form-field';
 * ```
 *
 * <example-url>../../#/input</example-url>
 *
 * @see {@link FormFieldComponent}
 */
declare class FormErrorComponent {
    /**
     * The component's active state determines whether the error message is displayed to the user.
     *
     * ```html
     * <talenra-form-error [isVisible]="emailInvalid">Email address is invalid.</talenra-form-error>
     * ```
     */
    get isVisible(): boolean;
    /** Set the component's active state. */
    set isVisible(value: boolean | undefined);
    private _isVisible;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormErrorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormErrorComponent, "talenra-form-error", never, { "isVisible": { "alias": "isVisible"; "required": false; }; }, {}, never, ["*"], true, never>;
    static ngAcceptInputType_isVisible: unknown;
}

/**
 * Base class to be expanded by controls used with FormFieldComponent.
 *
 * s. {@link InputComponent} or {@link SelectComponent} for examples.
 *
 * @internal
 */
declare class FormFieldControlBaseComponent<T = any> extends ControlBaseDirective {
    /** @internal */
    hasFocus: boolean;
    /**
     * Determines whether the control or any element within Form Field has focus. Used to toggle clear button visibility.
     *
     * @internal
     */
    private _hasFocusWithin;
    get hasFocusWithin(): boolean;
    set hasFocusWithin(value: boolean);
    /** @internal */
    id: string;
    /** @internal */
    tabindex: number;
    /** @internal */
    control: AbstractControl | null;
    /** Determines whether the control is required. */
    get required(): boolean;
    /** Set the control's required state */
    set required(value: boolean);
    /** @internal */
    _required: boolean | undefined;
    /**
     * Get whether the control is invalid.
     *
     * @internal
     */
    get invalid(): boolean;
    /**
     * Get whether the control is touched.
     *
     * @internal
     */
    get touched(): boolean;
    /**
     * Get whether the control is dirty.
     *
     * @internal
     */
    get dirty(): boolean;
    /** @internal */
    stateChanges: Subject<void>;
    /**
     * Reference to the enclosing `FormFieldComponent`.
     *
     * @internal
     */
    formField?: FormFieldComponent;
    /**
     * Determine whether the control's content has scroll offset.
     *
     * @internal
     */
    hasScroll: _angular_core.WritableSignal<boolean>;
    protected injector: Injector;
    /** @internal */
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldControlBaseComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldControlBaseComponent<any>, "ng-component", never, { "required": { "alias": "required"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_required: unknown;
}

export { ClearButtonComponent, ControlContainerComponent, FormErrorComponent, FormFieldComponent, FormFieldControl, FormFieldControlBaseComponent, FormFieldSize, FormFieldStatus };
export type { TFormFieldSize, TFormFieldStatus };