/**
 * TyInput Web Component - text input with label, error, icon slots and
 * locale-aware numeric formatting (format-on-blur / raw-on-focus via a parsed
 * "shadow value"). Debounce 0-5000ms; blur flushes any pending debounced event.
 */
import type { Flavor, Size, InputType, TyInputElement } from '../types/common.js';
import { TyComponent } from '../base/ty-component.js';
import type { PropertyChange } from '../utils/property-manager.js';
interface InputState {
    shadowValue: number | string | null;
    isFocused: boolean;
    listenersSetup: boolean;
    inputHandler: ((e: Event) => void) | null;
    changeHandler: ((e: Event) => void) | null;
    focusHandler: ((e: Event) => void) | null;
    blurHandler: ((e: Event) => void) | null;
    inputDebounceTimer: number | null;
    changeDebounceTimer: number | null;
    localeObserver?: () => void;
}
export declare class TyInput extends TyComponent<InputState> implements TyInputElement {
    static formAssociated: boolean;
    protected static properties: {
        type: {
            type: "string";
            visual: boolean;
            default: string;
            validate: (v: any) => boolean;
            coerce: (v: any) => any;
        };
        value: {
            type: "string";
            visual: boolean;
            formValue: boolean;
            emitChange: boolean;
            default: string;
        };
        name: {
            type: "string";
            default: string;
        };
        placeholder: {
            type: "string";
            visual: boolean;
            default: string;
        };
        label: {
            type: "string";
            visual: boolean;
            default: string;
        };
        disabled: {
            type: "boolean";
            visual: boolean;
            default: boolean;
        };
        required: {
            type: "boolean";
            visual: boolean;
            default: boolean;
        };
        error: {
            type: "string";
            visual: boolean;
            default: string;
        };
        size: {
            type: "string";
            visual: boolean;
            default: Size;
            validate: (v: any) => boolean;
            coerce: (v: any) => any;
        };
        flavor: {
            type: "string";
            visual: boolean;
            default: string;
        };
        currency: {
            type: "string";
            visual: boolean;
            default: string;
        };
        locale: {
            type: "string";
            visual: boolean;
            default: string;
        };
        precision: {
            type: "number";
            visual: boolean;
            default: undefined;
            validate: (v: any) => boolean;
            coerce: (v: any) => number | undefined;
        };
        debounce: {
            type: "number";
            default: number;
            validate: (v: any) => boolean;
            coerce: (v: any) => number;
        };
    };
    private _shadowValue;
    private _isFocused;
    private _listenersSetup;
    private _errorAutoDanger;
    private _customFlavorSheet;
    private _inputHandler;
    private _changeHandler;
    private _focusHandler;
    private _blurHandler;
    private _inputDebounceTimer;
    private _changeDebounceTimer;
    private _localeObserver?;
    constructor();
    /** TyComponent already handled pre-connection property capture. */
    protected onConnect(): void;
    /** Custom (non-built-in) flavors — see utils/flavor-sheet.ts. */
    private _syncCustomFlavor;
    protected onDisconnect(): void;
    /** Handle property changes — called BEFORE render. */
    protected onPropertiesChanged(changes: PropertyChange[]): void;
    protected onFormReset(): void;
    /**
     * Override form value to return shadow value
     * This ensures numeric types submit their parsed values
     */
    protected getFormValue(): FormDataEntryValue | null;
    private initializeShadowValue;
    private parseShadowValue;
    private shouldFormat;
    private getFormatConfig;
    private getDisplayValue;
    get type(): InputType;
    set type(v: InputType);
    get value(): string;
    set value(v: string);
    get name(): string;
    set name(v: string);
    get placeholder(): string;
    set placeholder(v: string);
    get label(): string;
    set label(v: string);
    get disabled(): boolean;
    set disabled(v: boolean);
    get required(): boolean;
    set required(v: boolean);
    get error(): string;
    set error(v: string);
    get size(): Size;
    set size(v: Size);
    get flavor(): Flavor;
    set flavor(v: Flavor);
    get currency(): string;
    set currency(v: string);
    get locale(): string;
    set locale(v: string);
    get precision(): number | undefined;
    set precision(v: number | string | undefined);
    get debounce(): number;
    set debounce(v: number | string);
    get form(): HTMLFormElement | null;
    private buildClassList;
    private dispatchInputEvent;
    private dispatchChangeEvent;
    private removeEventListeners;
    /** IMPORTANT: Only called ONCE, not on every render. */
    private setupEventListeners;
    /** Render the input component with wrapper and slots. */
    render(): void;
    /**
     * Wire the password reveal toggle (rendered only for type="password").
     * Toggles the NATIVE input's type between password/text — the component's
     * `type` property stays "password" (form value and API unaffected).
     */
    private setupPasswordToggle;
    /**
     * Reflect constraint validation to the owning <form> via ElementInternals.
     * Without this `required` is only cosmetic — the inner shadow <input> can't
     * block the outer form. Empty + required => valueMissing; otherwise valid.
     * Disabled fields are barred from constraint validation.
     */
    private updateValidity;
}
export {};