import { LitElement } from 'lit';

type Constructor<T = {}> = new (...args: any[]) => T;
/**
 * Consumer-supplied validation messages for constraint validation.
 * Each key maps to the corresponding ValidityState flag.
 * Provided values override the built-in English fallback strings.
 */
export interface ValidationMessages {
    valueMissing?: string;
    typeMismatch?: string;
    patternMismatch?: string;
    tooLong?: string;
    tooShort?: string;
    rangeUnderflow?: string;
    rangeOverflow?: string;
    stepMismatch?: string;
    badInput?: string;
    customError?: string;
}
/**
 * Sync the validity state of an inner <input> or <textarea> to ElementInternals.
 *
 * This is the recommended delegation strategy: let the native input run its own
 * constraint validation (required, minlength, type="email", pattern, etc.) and
 * then mirror the result into ElementInternals so the host custom element's
 * validity reflects the inner element.
 *
 * Call this on every `input` and `change` event, and once after `firstUpdated`.
 *
 * @param internals - The ElementInternals handle from attachInternals()
 * @param inputEl   - The inner native input, textarea, or select element
 */
export declare function syncInnerInputValidity(internals: ElementInternals, inputEl: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement | null | undefined): void;
/**
 * Type-level declaration of everything FaceMixin adds to a class.
 *
 * Using `declare class` (rather than `interface`) is the Lit-recommended approach
 * for mixins that include protected members — it avoids TS4094 "anonymous class
 * type may not be private or protected" errors in declaration emit.
 *
 * Import this type when you need to declare a FACE-capable component in type position.
 */
export declare class FaceMixinInterface {
    /** Registers this element as form-associated with the browser */
    static readonly formAssociated: boolean;
    /** ElementInternals handle — subclasses use this to call setFormValue/setValidity */
    protected _internals: ElementInternals;
    /** The name under which this control's value is submitted with the parent form */
    name: string;
    /** The parent <form> element, or null */
    readonly form: HTMLFormElement | null;
    /** Current ValidityState, updated via _internals.setValidity() */
    readonly validity: ValidityState;
    /** Browser-generated or custom validation message */
    readonly validationMessage: string;
    /** Whether this element participates in constraint validation */
    readonly willValidate: boolean;
    /** Silent validity check; fires 'invalid' event if invalid */
    checkValidity(): boolean;
    /** Validity check with browser tooltip if invalid */
    reportValidity(): boolean;
    /** FACE lifecycle — called when a fieldset disabled ancestor changes */
    formDisabledCallback(disabled: boolean): void;
    /** FACE lifecycle — called on form reset; subclasses should override */
    formResetCallback(): void;
    /**
     * FACE lifecycle — called when the browser restores session state or autofills.
     * Subclasses should override to restore their own state from the saved value.
     */
    formStateRestoreCallback(state: File | string | FormData | null, mode: 'restore' | 'autocomplete'): void;
    /**
     * Toggle a custom state in ElementInternals.states (CustomStateSet).
     * Enables :state() pseudo-class targeting from external CSS.
     * Guards against environments where states is unavailable.
     */
    protected _setState(state: string, active: boolean): void;
}
/**
 * FaceMixin
 *
 * Compose onto any LitElement subclass to get full FACE boilerplate.
 * Subclasses MUST override `formResetCallback()` to restore their own default state.
 */
export declare const FaceMixin: <T extends Constructor<LitElement>>(superClass: T) => Constructor<FaceMixinInterface> & T;
export {};
//# sourceMappingURL=face-mixin.d.ts.map