import * as i0 from '@angular/core';
import { InjectionToken, AfterContentInit, AfterContentChecked, OnDestroy, ElementRef, InputSignal, QueryList, Signal } from '@angular/core';
import * as i1 from '@sbb-esta/angular/core';
import { NgControl, AbstractControlDirective } from '@angular/forms';
import { Observable } from 'rxjs';

/**
 * Injection token that can be used to reference instances of `SbbError`. It serves as
 * alternative token to the actual `SbbError` class which could cause unnecessary
 * retention of the class and its directive metadata.
 */
declare const SBB_ERROR: InjectionToken<SbbError>;
/** Single error message to be shown underneath the form field. */
declare class SbbError {
    id: string;
    constructor(...args: unknown[]);
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbError, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SbbError, "sbb-error, [sbbError]", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
}

/** An interface which allows a control to work inside of a `SbbField`. */
declare abstract class SbbFormFieldControl<TValue> {
    /** The value of the control. */
    value: TValue | null;
    /**
     * Stream that emits whenever the state of the control changes such that the parent `SbbField`
     * needs to run change detection.
     */
    readonly stateChanges: Observable<void>;
    /** The id of the form field. */
    readonly id: string;
    /** The attached NgControl or AbstractControlDirective, if any exists. */
    readonly ngControl: NgControl | AbstractControlDirective | undefined;
    /** Whether the control is focused. */
    readonly focused: boolean;
    /** Whether the control is empty. */
    readonly empty: boolean;
    /** Whether the control is required. */
    readonly required: boolean;
    /** Whether the control is disabled. */
    readonly disabled: boolean;
    /** Whether the control is in an error state. */
    readonly errorState: boolean;
    /**
     * An optional name for the control type that can be used to distinguish `sbb-form-field` elements
     * based on their control type. The form field will add a class,
     * `sbb-form-field-type-{{controlType}}` to its root element.
     */
    readonly controlType?: string;
    /**
     * Whether the input is currently in an autofilled state. If property is not present on the
     * control it is assumed to be false.
     */
    readonly autofilled?: boolean;
    /**
     * Value of `aria-describedby` that should be merged with the described-by ids
     * which are set by the form-field.
     */
    readonly userAriaDescribedBy?: string;
    /**
     * Whether to automatically assign the ID of the form field as the `for` attribute
     * on the `<label>` inside the form field. Set this to true to prevent the form
     * field from associating the label with non-native elements.
     */
    readonly disableAutomaticLabeling?: boolean;
    /** Sets the list of element IDs that currently describe this control. */
    abstract setDescribedByIds(ids: string[]): void;
    /** Handles a click on the control's container. */
    abstract onContainerClick(event: MouseEvent): void;
}

/**
 * Injection token that can be used to inject an instances of `SbbFormField`. It serves
 * as alternative token to the actual `SbbFormField` class which would cause unnecessary
 * retention of the `SbbFormField` class and its component metadata.
 */
declare const SBB_FORM_FIELD: InjectionToken<SbbFormField>;
declare class SbbFormField implements AfterContentInit, AfterContentChecked, OnDestroy {
    _elementRef: ElementRef<HTMLElement>;
    private _changeDetectorRef;
    /** The label text for the input. */
    label: InputSignal<string | undefined>;
    private _destroyed;
    readonly _labelId: string;
    _connectionContainerRef: ElementRef;
    _controlNonStatic: SbbFormFieldControl<any>;
    _controlStatic: SbbFormFieldControl<any>;
    get _control(): SbbFormFieldControl<any>;
    set _control(value: SbbFormFieldControl<any>);
    private _explicitFormFieldControl;
    _errorChildren: QueryList<SbbError>;
    private readonly _labelChild;
    private _previousControl;
    private _stateChanges;
    private _valueChanges;
    private _describedByChanges;
    constructor(...args: unknown[]);
    /**
     * Gets the id of the label element. If no label is present, returns `null`.
     */
    getLabelId: Signal<string | null>;
    ngAfterContentInit(): void;
    ngAfterContentChecked(): void;
    ngOnDestroy(): void;
    /**
     * Determines whether a class from the AbstractControlDirective
     * should be forwarded to the host element.
     */
    _shouldForward(prop: keyof AbstractControlDirective): boolean;
    _hasLabel: Signal<boolean>;
    _hasErrors(): boolean;
    /**
     * Sets the list of element IDs that describe the child control. This allows the control to update
     * its `aria-describedby` attribute accordingly.
     */
    private _syncDescribedByIds;
    /** Throws an error if the form field's control is missing. */
    protected _validateControlChild(): void;
    /**
     * Gets an ElementRef for the element that a overlay attached to the form-field should be
     * positioned relative to.
     */
    getConnectedOverlayOrigin(): ElementRef;
    /** Initializes the registered form field control. */
    private _initializeControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbFormField, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SbbFormField, "sbb-form-field", ["sbbFormField"], { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, ["_labelChild", "_controlNonStatic", "_controlStatic", "_errorChildren"], ["sbb-label", "*", "sbb-error,[sbbError]"], true, never>;
}

declare class SbbLabel {
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbLabel, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SbbLabel, "sbb-label", never, {}, {}, never, never, true, never>;
}

declare class SbbFormFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SbbFormFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SbbFormFieldModule, never, [typeof i1.SbbCommonModule, typeof SbbFormField, typeof SbbError, typeof SbbLabel], [typeof SbbFormField, typeof SbbError, typeof SbbLabel]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SbbFormFieldModule>;
}

/** @docs-private */
declare function getSbbFormFieldMissingControlError(): Error;

export { SBB_ERROR, SBB_FORM_FIELD, SbbError, SbbFormField, SbbFormFieldControl, SbbFormFieldModule, SbbLabel, getSbbFormFieldMissingControlError };