import { type InputHTMLAttributes, type VNode } from 'vue';
import { type InputType, type InputValidateState, type OverriddenInputAttributes } from '../input';
import { type OUIAProps } from '../helpers/ouia';
interface Props<T extends InputType, N extends boolean> extends OUIAProps, Omit<InputHTMLAttributes, 'value' | 'type' | 'autocomplete'>, OverriddenInputAttributes {
    /** Flag to show if the text input is disabled. */
    disabled?: boolean;
    /** Flag to apply expanded styling */
    expanded?: boolean;
    /** Id of the element the text input controls the expansion of, such as a menu. The input becomes a combobox with aria-expanded set from expanded. */
    expandedControls?: string;
    /** Flag to make the input read only, without the read only styling */
    readonly?: boolean;
    /** Read only variant. */
    readOnlyVariant?: 'plain' | 'default';
    /** Value to indicate if the text input is modified to show that validation state.
     * If set to success, text input will be modified to indicate valid state.
     * If set to error, text input will be modified to indicate error state.
     */
    validated?: InputValidateState;
    /** Type that the text input accepts. */
    type?: T;
    /** Value of the text input. */
    modelValue?: string | number | null;
    modelModifiers?: {
        number?: N;
        trim?: boolean;
        lazy?: boolean;
    };
    /** Aria-label. The text input requires an associated id or aria-label. */
    ariaLabel?: string;
    /** Truncates the text at its start while the input is not focused, keeping its end in view */
    startTruncated?: boolean;
    /** When to validate the input with the browser constraint validation, true for enter or submit */
    autoValidate?: '' | 'blur' | 'input' | 'change' | 'enter' | boolean;
    /** Disables validation status icon */
    noStatusIcon?: boolean;
}
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: <T extends InputType = "text", N extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: import("vue").PublicProps & __VLS_PrettifyLocal<Props<T, N> & {
        onInput?: ((event: Event) => any) | undefined;
        onBlur?: ((event: FocusEvent) => any) | undefined;
        onChange?: ((event: Event) => any) | undefined;
        onFocus?: ((event: FocusEvent) => any) | undefined;
        onInvalid?: ((event: Event) => any) | undefined;
        onKeyup?: ((event: KeyboardEvent) => any) | undefined;
        "onUpdate:validated"?: ((value: InputValidateState) => any) | undefined;
        "onUpdate:modelValue"?: ((value: N extends true ? number : T extends "number" ? number : string) => any) | undefined;
    }> & (typeof globalThis extends {
        __VLS_PROPS_FALLBACK: infer P;
    } ? P : {});
    expose: (exposed: import("vue").ShallowUnwrapRef<{
        input: Readonly<import("vue").ShallowRef<HTMLInputElement | null, HTMLInputElement | null>>;
        focus: () => void;
        value: import("vue").ModelRef<string | number | null | undefined, PropertyKey, string | number | null | undefined, string | number | null | undefined>;
        effectiveValidated: import("vue").ComputedRef<InputValidateState>;
        innerValidated: import("vue").Ref<InputValidateState, InputValidateState>;
        checkValidity: () => boolean;
        reportValidity: (once?: boolean) => boolean;
        setCustomValidity: (error: string) => void;
    }>) => void;
    attrs: any;
    slots: {
        /** Custom icon to render. With a validated status, it is rendered in addition to the status icon. */
        icon?: (props?: Record<never, never>) => VNode[];
    };
    emit: {
        (name: "change", event: Event): void;
        (name: "blur", event: FocusEvent): void;
        (name: "focus", event: FocusEvent): void;
        (name: "input", event: Event): void;
        (name: "invalid", event: Event): void;
        (name: "keyup", event: KeyboardEvent): void;
        (name: "update:modelValue", value: N extends true ? number : T extends "number" ? number : string): void;
        (name: "update:validated", value: InputValidateState): void;
    };
}>) => import("vue").VNode & {
    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
};
type __VLS_PrettifyLocal<T> = (T extends any ? {
    [K in keyof T]: T[K];
} : {
    [K in keyof T as K]: T[K];
}) & {};
//# sourceMappingURL=TextInput.vue.d.ts.map