import { KdsIconName } from '../../accessories/Icon/types';
import { KdsInputSegmentsConfig } from './useInputSegments';
type BaseInputProps = {
    /**
     * ID for the input element
     */
    id?: string;
    /**
     * The type of input field
     */
    type?: "text" | "email" | "password" | "number" | "tel" | "url" | "search";
    /**
     * Minimum allowed value (relevant for type="number" and type="date")
     */
    min?: number | string;
    /**
     * Maximum allowed value (relevant for type="number" and type="date")
     */
    max?: number | string;
    /**
     * Indicates whether an associated popup (e.g. listbox/combobox) is expanded
     */
    ariaExpanded?: boolean;
    /**
     * Step size (relevant for type="number")
     */
    step?: number;
    /**
     * Placeholder text when input is empty
     */
    placeholder?: string;
    /**
     * Whether the input is disabled
     */
    disabled?: boolean;
    /**
     * Icon displayed at the start of the input
     */
    leadingIcon?: KdsIconName;
    /**
     * Icon displayed at the end of the input
     */
    trailingIcon?: KdsIconName;
    /**
     * Whether the input has an error state
     */
    error?: boolean;
    /**
     * Autocomplete attribute for the input element
     */
    autocomplete?: string;
    /**
     * Accessible label for the input (for aria-label).
     */
    ariaLabel?: string;
    /**
     * ID of element that labels this input (for aria-labelledby)
     */
    ariaLabelledby?: string;
    /**
     * ID of element that describes this input (for aria-describedby)
     */
    ariaDescribedby?: string;
    /**
     * Whether the current value of the input is invalid (for aria-invalid)
     */
    ariaInvalid?: boolean;
    /**
     * ARIA role override applied to the input element.
     * Useful to preserve semantics for custom controls.
     */
    role?: string;
    /**
     * Current value for widgets like role="spinbutton".
     */
    ariaValuenow?: number;
    /**
     * Minimum value for widgets like role="spinbutton".
     */
    ariaValuemin?: number;
    /**
     * Maximum value for widgets like role="spinbutton".
     */
    ariaValuemax?: number;
    /**
     * Human-readable value text (e.g. localized) for widgets like role="spinbutton".
     */
    ariaValuetext?: string;
    /**
     * ID of the currently active descendant element (for aria-activedescendant).
     * Used when the input controls an external listbox or similar widget.
     */
    ariaActivedescendant?: string;
    /**
     * Indicates the type of popup element controlled by this input (for aria-haspopup).
     * Used when the input triggers a listbox, menu, dialog, etc.
     */
    ariaHaspopup?: "listbox" | "menu" | "dialog" | "grid" | "tree" | "true";
    /**
     * ID of the popup element controlled by this input (for aria-controls).
     * Used together with aria-haspopup to link the input to its popup.
     */
    ariaControls?: string;
    /**
     * Indicates whether the input provides an autocomplete experience
     * (for aria-autocomplete). Used with combobox roles.
     */
    ariaAutocomplete?: "none" | "inline" | "list" | "both";
    /**
     * Unit shown next to the input value
     */
    unit?: string;
    /**
     * Hints at the type of data that might be entered by the user.
     * Useful for showing an appropriate on-screen keyboard on mobile.
     */
    inputmode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search";
    /**
     * Whether to show a clear button when the input has a value.
     */
    clearable?: boolean;
    /**
     * Pattern attribute for the input element, used for client-side validation
     * of text inputs. Should be a valid regular expression.
     */
    pattern?: string;
    /**
     * Optional segmented input configuration for fixed-format masked inputs.
     */
    segments?: KdsInputSegmentsConfig;
};
type __VLS_Props = BaseInputProps;
type __VLS_PublicProps = {
    modelValue?: string;
} & __VLS_Props;
declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        leading?(_: {}): any;
        trailing?(_: {}): any;
    };
    refs: {
        input: HTMLInputElement;
    };
    rootEl: HTMLDivElement;
};
type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
    /**
     * Focuses the input element
     */
    focus: () => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    input: (event: Event) => any;
    click: (event: MouseEvent) => any;
    blur: (event: FocusEvent) => any;
    focus: (event: FocusEvent) => any;
    keydown: (event: KeyboardEvent) => any;
    paste: (event: ClipboardEvent) => any;
    "update:modelValue": (value: string) => any;
}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
    onInput?: ((event: Event) => any) | undefined;
    onClick?: ((event: MouseEvent) => any) | undefined;
    onBlur?: ((event: FocusEvent) => any) | undefined;
    onFocus?: ((event: FocusEvent) => any) | undefined;
    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
    onPaste?: ((event: ClipboardEvent) => any) | undefined;
    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
    input: HTMLInputElement;
}, HTMLDivElement>;
declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};
//# sourceMappingURL=BaseInput.vue.d.ts.map