import * as _angular_core from '@angular/core';
import { Signal } from '@angular/core';
import * as forty_cdk_core from 'forty-cdk/core';
import { ForFieldContext, FieldControlHandle } from 'forty-cdk/core';
export { FOR_FIELD_CONTEXT, FieldControlHandle, ForFieldContext, injectFieldWiring } from 'forty-cdk/core';
import { ValidationError } from '@angular/forms/signals';

/**
 * Headless form-field container that wires accessible labelling, description,
 * and error association for a single control. It renders nothing and imposes no
 * layout: its only job is to connect a `[forLabel]`, `[forFieldDescription]`,
 * and `[forFieldError]` to the control via `id` / `aria-labelledby` /
 * `aria-describedby` / `aria-errormessage`, and to reflect the control's
 * validation state as `data-*` hooks for styling.
 *
 * Any forty-cdk form control (every `FormValueControl` / `FormCheckboxControl`
 * primitive) auto-associates when wrapped — no extra markup. A plain native
 * `<input>` opts in with `[forFieldControl]`.
 *
 * Host reflects `data-invalid` / `data-disabled` / `data-required` /
 * `data-touched` from the registered control.
 *
 * @example
 * ```html
 * <div forField>
 *   <label forLabel>Notifications</label>
 *   <button forSwitch [formField]="settings.notify"></button>
 *   <p forFieldDescription>We'll only email you about security.</p>
 *   @if (settings.notify().invalid()) {
 *     <p forFieldError #err="forFieldError">{{ err.messages().join(', ') }}</p>
 *   }
 * </div>
 * ```
 */
declare class ForField implements ForFieldContext {
    #private;
    constructor();
    /**
     * Id assigned to the control; a label's `for` points here. Adopts a
     * nominated control's own id (`labelledElementId`) when present so the label
     * and the primitive's internal `aria-labelledby` resolve to the same
     * focusable element; otherwise the field's owned/host-adopted id.
     */
    readonly controlId: Signal<string>;
    /** Id of the label element. */
    readonly labelId: _angular_core.WritableSignal<string>;
    /** Id of the description element. */
    readonly descriptionId: _angular_core.WritableSignal<string>;
    /** Id of the error element. */
    readonly errorId: _angular_core.WritableSignal<string>;
    /**
     * The currently registered control handle, or null. A `[forField]` targets a
     * single control; if several register, the last one wins and unregistering it
     * falls back to the previous still-mounted one (mirroring the counted label /
     * description / error slots). A duplicate emits a dev-mode warning.
     */
    readonly control: Signal<FieldControlHandle | null>;
    /** Whether the registered control is currently invalid. */
    readonly invalid: Signal<boolean>;
    /** Whether the registered control is required. */
    readonly required: Signal<boolean>;
    /**
     * Whether the field is disabled: the registered control's own disabled state
     * OR'd with a surrounding `[forFieldset]`'s `disabled` (so a disabled group
     * reaches custom-role controls a native `<fieldset disabled>` can't).
     */
    readonly disabled: Signal<boolean>;
    /** Whether the registered control has been touched. */
    readonly touched: Signal<boolean>;
    /** Resolved `aria-labelledby` for the control (label id, or null). */
    readonly labelledBy: Signal<string | null>;
    /**
     * Resolved `aria-describedby`: the description id always, plus the error id
     * when the control is invalid. The error id is carried here as well as on
     * `aria-errormessage`, whose assistive-tech support is uneven.
     */
    readonly describedBy: Signal<string | null>;
    /** Resolved `aria-errormessage`: the error id when present and invalid, else null. */
    readonly errorMessageId: Signal<string | null>;
    /**
     * Register the control whose state the field reflects. The field targets a
     * single control — its `controlId` is one id, not an id list — so one control
     * per `[forField]` is the supported shape; group several controls under a
     * `[forFieldset]` instead. Registrations are tracked (mirroring the label /
     * description / error slots), so unmounting one of several accidental
     * duplicates never drops the association while another is still mounted; a
     * duplicate emits a dev-mode warning.
     */
    registerControl(handle: FieldControlHandle): void;
    /** Remove a previously registered control. */
    unregisterControl(handle: FieldControlHandle): void;
    /**
     * Register the label slot; returns an unregister callback. The field targets
     * a single label per slot — its `labelId` / `descriptionId` / `errorId` are
     * single ids, not id lists — so one `[forLabel]`, `[forFieldDescription]`,
     * and `[forFieldError]` per field is the supported shape. Registrations are
     * counted (mirroring `ForFieldset`'s legend counting), so unmounting one of
     * several accidental duplicates never drops the association while another is
     * still mounted; a duplicate emits a dev-mode warning.
     */
    registerLabel(): () => void;
    /** Register the description slot; returns an unregister callback. See {@link registerLabel} for the counted single-instance-per-slot contract. */
    registerDescription(): () => void;
    /** Register the error slot; returns an unregister callback. See {@link registerLabel} for the counted single-instance-per-slot contract. */
    registerError(): () => void;
    /**
     * Forward a click to the control and move focus into it — matching the
     * activation a native `<label for>` triggers via the browser, so a
     * `[forLabel]` the browser will not forward for toggles a custom-role control
     * instead of only focusing it.
     *
     * Focus prefers the control's own {@link FieldControlHandle.focus} entry
     * point over the association target, because the two diverge on a composite:
     * the `role="group"` a segmented date / time field is named on takes no
     * focus, while its `focus()` lands on the first editable segment (and no-ops
     * while disabled).
     */
    clickControl(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForField, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForField, "[forField]", ["forField"], {}, {}, never, never, true, never>;
}

/**
 * Accessible label for a form control. Inside a `[forField]` it auto-wires:
 * it adopts the field's `labelId` and registers itself so the control gains
 * `aria-labelledby`.
 *
 * Click-to-activate is consistent across both host shapes: a native `<label>`
 * emits `for` and the browser forwards the click to the control (toggling a
 * checkbox / switch, activating a button); a non-`<label>` host has no native
 * `for` forwarding, so the directive forwards the click itself — clicking the
 * label activates the control either way, not just focuses it. A native
 * `<label>` whose `for` resolves to a non-labelable element gets the same
 * treatment, since the browser forwards nothing there: that is the composite
 * case, where the control is named on a `role="group"` a `<label for>` cannot
 * reach (`[forDateField]`, `[forTimeField]`, their range siblings). A click
 * that originated on the control (when the control is nested inside the label
 * host) is not re-forwarded, so a label-wrapping layout toggles once, matching
 * native `<label>` semantics.
 *
 * Usable standalone outside a field — there it is an inert
 * marker and the consumer wires native `for` themselves.
 *
 * @example
 * ```html
 * <div forField>
 *   <label forLabel>Email</label>
 *   <input forFieldControl type="email" />
 * </div>
 * ```
 */
declare class ForLabel {
    #private;
    protected readonly ctx: forty_cdk_core.ForFieldContext | null;
    /** The label's id when inside a field, else null. */
    protected readonly labelId: _angular_core.Signal<string | null>;
    /** `for` is only meaningful on a native `<label>`; null otherwise. */
    protected readonly forAttr: _angular_core.Signal<string | null>;
    constructor();
    protected onClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForLabel, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForLabel, "[forLabel]", ["forLabel"], {}, {}, never, never, true, never>;
}

/**
 * Supplementary description / hint for a form control. Adopts the field's
 * `descriptionId` and registers itself so the control gains
 * `aria-describedby`. Apply on a `<p>` / `<span>` inside a `[forField]`.
 */
declare class ForFieldDescription {
    protected readonly ctx: forty_cdk_core.ForFieldContext;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFieldDescription, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFieldDescription, "[forFieldDescription]", ["forFieldDescription"], {}, {}, never, never, true, never>;
}

/**
 * Error region for a form control. Adopts the field's `errorId`, registers
 * itself so the control gains `aria-errormessage` (and the id is folded into
 * `aria-describedby`) while invalid, and **reads the control's Signal Forms
 * validation errors automatically** — the consumer renders `messages()` (or
 * the raw `errors()`) without any manual plumbing.
 *
 * Carries `role="alert"`. Gate its mount on the field's `invalid()` (exposed via
 * the `[forField]` export, or the bound Signal Forms field) — a template
 * reference to this directive is block-scoped to the `@if` body, so it cannot
 * appear in the condition that mounts it. When unmounted the control's
 * `aria-errormessage` drops automatically.
 *
 * @example
 * ```html
 * <div forField #field="forField">
 *   <!-- label / control / description … -->
 *   @if (field.invalid()) {
 *     <p forFieldError #err="forFieldError">{{ err.messages().join(', ') }}</p>
 *   }
 * </div>
 * ```
 */
declare class ForFieldError {
    protected readonly ctx: forty_cdk_core.ForFieldContext;
    /** The control's current validation errors (Signal Forms). */
    readonly errors: _angular_core.Signal<readonly ValidationError.WithOptionalFieldTree[]>;
    /** Human-readable messages derived from {@link errors}. */
    readonly messages: _angular_core.Signal<readonly string[]>;
    /** Whether the control currently has at least one error. */
    readonly hasErrors: _angular_core.Signal<boolean>;
    /** Whether the error region should be shown (control invalid and has errors). */
    readonly shown: _angular_core.Signal<boolean>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFieldError, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFieldError, "[forFieldError]", ["forFieldError"], {}, {}, never, never, true, never>;
}

/**
 * Opt-in marker that wires a non-forty-cdk control — a native `<input>`,
 * `<textarea>`, `<select>`, or any custom element — into its surrounding
 * `[forField]`. forty-cdk form primitives (which extend the shared form base)
 * auto-wire and do **not** need this; it exists for plain native controls that
 * have no primitive of their own.
 *
 * Validation state is consumer-driven via the `invalid` / `required` /
 * `disabled` / `touched` inputs (native controls have no Signal Forms errors
 * to surface). Reflects `aria-invalid` on the host.
 *
 * @example
 * ```html
 * <div forField>
 *   <label forLabel>Email</label>
 *   <input forFieldControl type="email" [invalid]="emailInvalid()" />
 * </div>
 * ```
 */
declare class ForFieldControl {
    /** Marks the control invalid — drives the field's error region and `aria-invalid`. */
    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Marks the control required — reflected by the field as `data-required`. */
    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Marks the control disabled — reflected by the field as `data-disabled`. */
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Marks the control touched — reflected by the field as `data-touched`. */
    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFieldControl, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFieldControl, "[forFieldControl]", ["forFieldControl"], { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { ForField, ForFieldControl, ForFieldDescription, ForFieldError, ForLabel };