import { NeonSize } from '@/model/common/size/NeonSize';
import { NeonFunctionalColor } from '@/model/common/color/NeonFunctionalColor';
import { NeonDropdownPlacement } from '@/model/presentation/dropdown/NeonDropdownPlacement';
/**
 * <strong>NeonDatePicker</strong> is the equivalent of the native
 * <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/date" target="_blank">HTML Date Input</a>.
 * It accepts an <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> date string &
 * allows the user to select a date. Dates are formatted with the provided locale, if none is provided the browser
 * locale is used as a default. On touch devices the native date picker is presented to the user.
 *
 * The input date is displayed to the user WITHOUT any adjustment for their timezone, however 'Today' on the calendar is
 * highlighted for the user's timezone.
 *
 * This component interaction was inspired by this <a href="https://icehaunter.github.io/vue3-datepicker" target="_blank">vue-datepicker</a>
 */
declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    /**
     * Id for the date picker button.
     */
    id: {
        type: StringConstructor;
    };
    /**
     * The selected date. A date string in the
     * <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
     */
    modelValue: {
        type: StringConstructor;
        default: null;
    };
    /**
     * The locale used for display purposes. This defaults to the browser's locale if none is provided.
     */
    locale: {
        type: StringConstructor;
        default: null;
    };
    /**
     * Disable date picker
     */
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
     */
    size: {
        type: () => NeonSize;
        default: NeonSize;
    };
    /**
     * Color of the date picker
     */
    color: {
        type: () => NeonFunctionalColor;
        default: NeonFunctionalColor;
    };
    /**
     * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
     */
    min: {
        type: StringConstructor;
        default: null;
    };
    /**
     * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
     */
    max: {
        type: StringConstructor;
        default: null;
    };
    /**
     * The placement of the dropdown calendar popup.
     */
    placement: {
        type: () => NeonDropdownPlacement;
        default: NeonDropdownPlacement;
    };
    /**
     * Disabled dates, a list of <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format
     * dates for which to disable selection.
     */
    disabledDates: {
        type: () => Array<string>;
        default: () => never[];
    };
    /**
     * This is the placeholder for the text input when no value is provided.
     */
    placeholder: {
        type: StringConstructor;
        required: false;
    };
    /**
     * This is the label of the input field which opens the calendar. This is technically a button.
     */
    openCalendarLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the label of the 'Done' button in the calendar popup.
     */
    doneLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the label of the 'Clear' button in the calendar popup.
     */
    clearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Change month' button in the calendar popup.
     */
    changeMonthLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Previous month' button in the calendar popup.
     */
    previousMonthLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Next month' button in the calendar popup.
     */
    nextMonthLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Change year' button in the calendar popup.
     */
    changeYearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Previous year' button in the calendar popup.
     */
    previousYearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Next year' button in the calendar popup.
     */
    nextYearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Previous decade' button in the calendar popup.
     */
    previousDecadeLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Next decade' button in the calendar popup.
     */
    nextDecadeLabel: {
        type: StringConstructor;
        default: string;
    };
}>, {
    attrs: {
        [x: string]: unknown;
    };
    calendar: import("vue").ComputedRef<import("../../../model/user-input/calendar/NeonCalendarConfig").NeonCalendarConfig>;
    calendarOpen: import("vue").Ref<boolean, boolean>;
    dropdown: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
    formattedValue: import("vue").ComputedRef<string>;
    isChangeDateDisabled: import("vue").ComputedRef<boolean | "">;
    isChangeYearDisabled: import("vue").ComputedRef<boolean | "">;
    isNextDisabled: import("vue").ComputedRef<boolean | "">;
    isNextDecadeDisabled: import("vue").ComputedRef<boolean | "">;
    isNextYearDisabled: import("vue").ComputedRef<boolean | "">;
    isPreviousDisabled: import("vue").ComputedRef<boolean | "">;
    isPreviousDecadeDisabled: import("vue").ComputedRef<boolean | "">;
    isPreviousYearDisabled: import("vue").ComputedRef<boolean | "">;
    monthSelectionOpen: import("vue").Ref<boolean, boolean>;
    optional: boolean;
    today: import("vue").ComputedRef<string>;
    calendarRef: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
    yearSelectionOpen: import("vue").Ref<boolean, boolean>;
    changeMonth: () => void;
    changeYear: () => void;
    clear: () => void;
    done: () => void;
    emitDate: (newDate: string) => void;
    isDisabled: (isoDate: string) => boolean | "";
    isoDate: (day: number, month: number, year: number) => string;
    isMonthDisabled: (year: number, month: number) => boolean | "" | null;
    isYearDisabled: (year: number) => boolean | 0 | null;
    toggleCalendar: () => void;
    onNext: () => void;
    onNextDecade: () => void;
    onNextYear: () => void;
    onPrevious: () => void;
    onPreviousDecade: () => void;
    onPreviousYear: () => void;
    resetToCalendar: () => void;
    selectMonth: (month: number) => void;
    selectYear: (year: number) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    /**
     * Id for the date picker button.
     */
    id: {
        type: StringConstructor;
    };
    /**
     * The selected date. A date string in the
     * <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
     */
    modelValue: {
        type: StringConstructor;
        default: null;
    };
    /**
     * The locale used for display purposes. This defaults to the browser's locale if none is provided.
     */
    locale: {
        type: StringConstructor;
        default: null;
    };
    /**
     * Disable date picker
     */
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
     */
    size: {
        type: () => NeonSize;
        default: NeonSize;
    };
    /**
     * Color of the date picker
     */
    color: {
        type: () => NeonFunctionalColor;
        default: NeonFunctionalColor;
    };
    /**
     * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
     */
    min: {
        type: StringConstructor;
        default: null;
    };
    /**
     * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
     */
    max: {
        type: StringConstructor;
        default: null;
    };
    /**
     * The placement of the dropdown calendar popup.
     */
    placement: {
        type: () => NeonDropdownPlacement;
        default: NeonDropdownPlacement;
    };
    /**
     * Disabled dates, a list of <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format
     * dates for which to disable selection.
     */
    disabledDates: {
        type: () => Array<string>;
        default: () => never[];
    };
    /**
     * This is the placeholder for the text input when no value is provided.
     */
    placeholder: {
        type: StringConstructor;
        required: false;
    };
    /**
     * This is the label of the input field which opens the calendar. This is technically a button.
     */
    openCalendarLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the label of the 'Done' button in the calendar popup.
     */
    doneLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the label of the 'Clear' button in the calendar popup.
     */
    clearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Change month' button in the calendar popup.
     */
    changeMonthLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Previous month' button in the calendar popup.
     */
    previousMonthLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Next month' button in the calendar popup.
     */
    nextMonthLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Change year' button in the calendar popup.
     */
    changeYearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Previous year' button in the calendar popup.
     */
    previousYearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Next year' button in the calendar popup.
     */
    nextYearLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Previous decade' button in the calendar popup.
     */
    previousDecadeLabel: {
        type: StringConstructor;
        default: string;
    };
    /**
     * This is the ARIA label of the 'Next decade' button in the calendar popup.
     */
    nextDecadeLabel: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{}>, {
    color: NeonFunctionalColor;
    disabled: boolean;
    size: NeonSize;
    max: string;
    modelValue: string;
    placement: NeonDropdownPlacement;
    locale: string;
    min: string;
    disabledDates: string[];
    openCalendarLabel: string;
    doneLabel: string;
    clearLabel: string;
    changeMonthLabel: string;
    previousMonthLabel: string;
    nextMonthLabel: string;
    changeYearLabel: string;
    previousYearLabel: string;
    nextYearLabel: string;
    previousDecadeLabel: string;
    nextDecadeLabel: string;
}, {}, {
    NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        href: {
            type: StringConstructor;
            default: null;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        size: {
            type: () => import("../../../neon").NeonButtonSize;
            default: import("../../../neon").NeonButtonSize;
        };
        color: {
            type: () => NeonFunctionalColor; /**
             * Id for the date picker button.
             */
            default: NeonFunctionalColor;
        };
        inverse: {
            type: BooleanConstructor;
            default: boolean;
        };
        alternateColor: {
            type: () => NeonFunctionalColor;
            default: null;
        };
        icon: {
            type: StringConstructor;
            default: null;
        };
        iconAriaLabel: {
            type: StringConstructor;
        };
        iconPosition: {
            type: () => import("../../../neon").NeonHorizontalPosition; /**
             * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
             */
            default: import("../../../neon").NeonHorizontalPosition;
        };
        buttonStyle: {
            type: () => import("../../../neon").NeonButtonStyle;
            default: import("../../../neon").NeonButtonStyle;
        };
        buttonType: {
            type: () => import("../../../neon").NeonButtonType;
            default: import("../../../neon").NeonButtonType;
        };
        state: {
            type: () => import("../../../neon").NeonState;
            default: import("../../../neon").NeonState;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        transparent: {
            type: BooleanConstructor;
            default: boolean;
        };
        outline: {
            type: BooleanConstructor;
            default: boolean;
        };
        circular: {
            type: BooleanConstructor;
            default: null;
        };
        fullWidth: {
            type: BooleanConstructor;
            default: null;
        };
        indicator: {
            type: BooleanConstructor;
            default: boolean;
        };
        indicatorExpanded: {
            type: BooleanConstructor;
            default: null;
        };
    }>, {
        iconName: import("vue").ComputedRef<string>;
        classes: import("vue").ComputedRef<(string | false | {
            [x: string]: boolean | "" | NeonFunctionalColor;
            'neon-button--text-transparent': boolean;
            'neon-button--disabled': boolean;
            'neon-button--inverse': boolean;
            'neon-button--circular': boolean;
            'neon-button--no-outline': boolean;
            'neon-button--full-width': boolean;
            'neon-button--with-icon neon-button--icon-only': boolean | "";
            'neon-button--with-icon neon-button--icon-left': boolean | "";
            'neon-button--with-icon neon-button--icon-right': boolean | "";
        })[]>;
        button: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
        attrs: {
            [x: string]: unknown;
        };
        sanitizedAttributes: import("vue").ComputedRef<{
            [x: string]: unknown;
        }>;
        clickLink: () => void | undefined;
        clickButton: () => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        href: {
            type: StringConstructor;
            default: null;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        size: {
            type: () => import("../../../neon").NeonButtonSize;
            default: import("../../../neon").NeonButtonSize;
        };
        color: {
            type: () => NeonFunctionalColor; /**
             * Id for the date picker button.
             */
            default: NeonFunctionalColor;
        };
        inverse: {
            type: BooleanConstructor;
            default: boolean;
        };
        alternateColor: {
            type: () => NeonFunctionalColor;
            default: null;
        };
        icon: {
            type: StringConstructor;
            default: null;
        };
        iconAriaLabel: {
            type: StringConstructor;
        };
        iconPosition: {
            type: () => import("../../../neon").NeonHorizontalPosition; /**
             * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
             */
            default: import("../../../neon").NeonHorizontalPosition;
        };
        buttonStyle: {
            type: () => import("../../../neon").NeonButtonStyle;
            default: import("../../../neon").NeonButtonStyle;
        };
        buttonType: {
            type: () => import("../../../neon").NeonButtonType;
            default: import("../../../neon").NeonButtonType;
        };
        state: {
            type: () => import("../../../neon").NeonState;
            default: import("../../../neon").NeonState;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        transparent: {
            type: BooleanConstructor;
            default: boolean;
        };
        outline: {
            type: BooleanConstructor;
            default: boolean;
        };
        circular: {
            type: BooleanConstructor;
            default: null;
        };
        fullWidth: {
            type: BooleanConstructor;
            default: null;
        };
        indicator: {
            type: BooleanConstructor;
            default: boolean;
        };
        indicatorExpanded: {
            type: BooleanConstructor;
            default: null;
        };
    }>> & Readonly<{
        onClick?: ((...args: any[]) => any) | undefined;
    }>, {
        color: NeonFunctionalColor;
        icon: string;
        label: string;
        inverse: boolean;
        disabled: boolean;
        href: string;
        size: import("../../../neon").NeonButtonSize;
        alternateColor: NeonFunctionalColor;
        outline: boolean;
        iconPosition: import("../../../neon").NeonHorizontalPosition;
        buttonStyle: import("../../../neon").NeonButtonStyle;
        buttonType: import("../../../neon").NeonButtonType;
        state: import("../../../neon").NeonState;
        transparent: boolean;
        circular: boolean;
        fullWidth: boolean;
        indicator: boolean;
        indicatorExpanded: boolean;
    }, {}, {
        NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            expanded: {
                type: BooleanConstructor;
                default: boolean;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            expanded: {
                type: BooleanConstructor;
                default: boolean;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
        }>> & Readonly<{}>, {
            color: NeonFunctionalColor;
            inverse: boolean;
            disabled: boolean;
            expanded: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            name: {
                type: StringConstructor;
                required: true;
            };
            id: {
                type: StringConstructor;
                default: null;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            inverse: {
                type: BooleanConstructor; /**
                 * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                 */
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            sanitizedAttributes: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            icon: import("vue").ComputedRef<string | undefined>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            name: {
                type: StringConstructor;
                required: true;
            };
            id: {
                type: StringConstructor;
                default: null;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            inverse: {
                type: BooleanConstructor; /**
                 * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                 */
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, {
            color: NeonFunctionalColor;
            id: string;
            inverse: boolean;
            disabled: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            href: {
                type: StringConstructor;
                default: null;
            };
            noStyle: {
                type: BooleanConstructor;
                default: boolean;
            };
            outlineStyle: {
                type: () => import("../../../neon").NeonOutlineStyle;
                default: import("../../../neon").NeonOutlineStyle;
            };
            externalIndicator: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            neonLink: import("vue").Ref<HTMLAnchorElement | null, HTMLAnchorElement | null>;
            routerUrl: import("vue").ComputedRef<string | undefined>;
            sanitizedAttributes: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            activeRoute: import("vue").ComputedRef<boolean | "" | undefined>;
            exactRoute: import("vue").ComputedRef<boolean | "" | undefined>;
            onClick: () => void; /**
             * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
             */
            onSpace: () => Promise<void>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            href: {
                type: StringConstructor;
                default: null;
            };
            noStyle: {
                type: BooleanConstructor;
                default: boolean;
            };
            outlineStyle: {
                type: () => import("../../../neon").NeonOutlineStyle;
                default: import("../../../neon").NeonOutlineStyle;
            };
            externalIndicator: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
        }>, {
            href: string;
            noStyle: boolean;
            outlineStyle: import("../../../neon").NeonOutlineStyle;
            externalIndicator: boolean;
        }, {}, {
            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                name: {
                    type: StringConstructor;
                    required: true;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
                inverse: {
                    type: BooleanConstructor; /**
                     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                     */
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                sanitizedAttributes: import("vue").ComputedRef<{
                    [x: string]: unknown;
                }>;
                icon: import("vue").ComputedRef<string | undefined>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                name: {
                    type: StringConstructor;
                    required: true;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
                inverse: {
                    type: BooleanConstructor; /**
                     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                     */
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, {
                color: NeonFunctionalColor;
                id: string;
                inverse: boolean;
                disabled: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    NeonDropdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
        };
        modelValue: {
            type: BooleanConstructor; /**
             * The locale used for display purposes. This defaults to the browser's locale if none is provided.
             */
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null;
        };
        imageAlt: {
            type: StringConstructor;
            default: null;
        };
        icon: {
            type: StringConstructor;
            default: null;
        };
        iconAriaLabel: {
            type: StringConstructor;
        };
        indicator: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: () => NeonSize;
            default: NeonSize;
        };
        color: {
            type: () => NeonFunctionalColor;
            default: NeonFunctionalColor;
        };
        alternateColor: {
            type: () => NeonFunctionalColor;
            default: null;
        };
        dropdownStyle: {
            type: () => import("../../../neon").NeonDropdownStyle;
            default: import("../../../neon").NeonDropdownStyle;
        };
        placement: {
            type: () => NeonDropdownPlacement;
            default: NeonDropdownPlacement;
        };
        placementContainer: {
            type: () => HTMLElement;
            default: null;
        };
        openOnHover: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        dropdownButton: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
        dropdownContent: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
        dropdownPlacement: import("vue").Ref<NeonDropdownPlacement, NeonDropdownPlacement>;
        closableUtils: import("vue").Ref<{
            open: () => void;
            destroy: () => void;
            escapeKeyListener: (event: KeyboardEvent) => void;
            close: () => void;
        } | null, import("../../../neon").NeonClosableUtils | {
            open: () => void;
            destroy: () => void;
            escapeKeyListener: (event: KeyboardEvent) => void;
            close: () => void;
        } | null>;
        isButtonStyle: import("vue").ComputedRef<boolean>;
        onClose: () => void;
        close: () => void;
        toggleOpen: () => void;
        onBlur: () => void;
        onFocus: () => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "dropdown-placement")[], "update:modelValue" | "blur" | "focus" | "dropdown-placement", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
        };
        modelValue: {
            type: BooleanConstructor; /**
             * The locale used for display purposes. This defaults to the browser's locale if none is provided.
             */
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null;
        };
        imageAlt: {
            type: StringConstructor;
            default: null;
        };
        icon: {
            type: StringConstructor;
            default: null;
        };
        iconAriaLabel: {
            type: StringConstructor;
        };
        indicator: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: () => NeonSize;
            default: NeonSize;
        };
        color: {
            type: () => NeonFunctionalColor;
            default: NeonFunctionalColor;
        };
        alternateColor: {
            type: () => NeonFunctionalColor;
            default: null;
        };
        dropdownStyle: {
            type: () => import("../../../neon").NeonDropdownStyle;
            default: import("../../../neon").NeonDropdownStyle;
        };
        placement: {
            type: () => NeonDropdownPlacement;
            default: NeonDropdownPlacement;
        };
        placementContainer: {
            type: () => HTMLElement;
            default: null;
        };
        openOnHover: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onFocus?: ((...args: any[]) => any) | undefined;
        onBlur?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onDropdown-placement"?: ((...args: any[]) => any) | undefined;
    }>, {
        color: NeonFunctionalColor;
        icon: string;
        label: string;
        disabled: boolean;
        image: string;
        size: NeonSize;
        placement: NeonDropdownPlacement;
        alternateColor: NeonFunctionalColor;
        indicator: boolean;
        imageAlt: string;
        dropdownStyle: import("../../../neon").NeonDropdownStyle;
        placementContainer: HTMLElement;
        openOnHover: boolean;
    }, {}, {
        NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            label: {
                type: StringConstructor;
                default: null;
            };
            image: {
                type: StringConstructor;
                default: null;
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            circular: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: () => import("../../../neon").NeonBadgeSize;
                default: import("../../../neon").NeonBadgeSize;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: NeonFunctionalColor;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            editable: {
                type: BooleanConstructor;
                default: boolean;
            };
            accept: {
                type: StringConstructor;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean; /**
                 * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                 */
            };
            jazziconId: {
                type: StringConstructor;
                default: null; /**
                 * The placement of the dropdown calendar popup.
                 */
            }; /**
             * The placement of the dropdown calendar popup.
             */
            imageAlt: {
                type: StringConstructor;
                default: string;
            };
            editButtonTitle: {
                type: StringConstructor;
                default: string;
            };
        }>, {
            emit: (event: "change-image", ...args: any[]) => void;
            svg: import("vue").ComputedRef<string | null>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change-image"[], "change-image", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            label: {
                type: StringConstructor;
                default: null;
            };
            image: {
                type: StringConstructor;
                default: null;
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            circular: {
                type: BooleanConstructor;
                default: boolean;
            };
            size: {
                type: () => import("../../../neon").NeonBadgeSize;
                default: import("../../../neon").NeonBadgeSize;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: NeonFunctionalColor;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            editable: {
                type: BooleanConstructor;
                default: boolean;
            };
            accept: {
                type: StringConstructor;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean; /**
                 * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                 */
            };
            jazziconId: {
                type: StringConstructor;
                default: null; /**
                 * The placement of the dropdown calendar popup.
                 */
            }; /**
             * The placement of the dropdown calendar popup.
             */
            imageAlt: {
                type: StringConstructor;
                default: string;
            };
            editButtonTitle: {
                type: StringConstructor;
                default: string;
            };
        }>> & Readonly<{
            "onChange-image"?: ((...args: any[]) => any) | undefined;
        }>, {
            color: NeonFunctionalColor;
            icon: string;
            label: string;
            disabled: boolean;
            image: string;
            size: import("../../../neon").NeonBadgeSize;
            alternateColor: NeonFunctionalColor;
            circular: boolean;
            accept: string;
            editable: boolean;
            jazziconId: string;
            imageAlt: string;
            editButtonTitle: string;
        }, {}, {
            NeonFile: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                directUpload: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                accept: {
                    type: StringConstructor;
                    default: null;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                size: {
                    type: () => NeonSize;
                    default: NeonSize;
                };
                state: {
                    type: () => import("../../../neon").NeonState;
                    default: import("../../../neon").NeonState;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: NeonFunctionalColor;
                };
                buttonStyle: {
                    type: () => import("../../../neon").NeonButtonStyle;
                    default: import("../../../neon").NeonButtonStyle;
                };
                circular: {
                    type: BooleanConstructor;
                    default: null;
                };
                label: {
                    type: StringConstructor;
                    default: null;
                };
                icon: {
                    type: StringConstructor;
                    default: null;
                };
                title: {
                    type: StringConstructor;
                    default: string;
                };
            }>, {
                fileInput: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: null;
                    };
                    type: {
                        type: () => import("../../../neon").NeonInputType;
                        default: import("../../../neon").NeonInputType;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    inputmode: {
                        type: () => import("../../../neon").NeonInputMode;
                        default: import("../../../neon").NeonInputMode;
                    };
                    autocomplete: {
                        type: StringConstructor;
                        default: string;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    rows: {
                        type: NumberConstructor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconReadonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tabindex: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateHighlight: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    maxlength: {
                        type: NumberConstructor;
                        default: null;
                    };
                    maxlengthLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    debounce: {
                        type: NumberConstructor;
                        default: undefined;
                    };
                }>> & Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
                }>, {
                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
                    focused: import("vue").Ref<boolean, boolean>;
                    sanitizedAttributes: import("vue").ComputedRef<{
                        [x: string]: unknown;
                    }>;
                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
                    iconName: import("vue").ComputedRef<string | undefined>;
                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
                    computedPlaceholder: import("vue").ComputedRef<string>;
                    counterLabel: import("vue").ComputedRef<string | null>;
                    focus: () => void;
                    click: () => void;
                    onFocus: () => void;
                    onBlur: () => void;
                    iconClicked: ($event: Event) => void;
                    changeValue: (event: InputEvent) => void;
                    onKeyDown: (event: KeyboardEvent) => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], import("vue").PublicProps, {
                    color: NeonFunctionalColor;
                    icon: string;
                    type: import("../../../neon").NeonInputType;
                    id: string;
                    disabled: boolean;
                    size: NeonSize;
                    placeholder: string;
                    tabindex: number;
                    inputmode: import("../../../neon").NeonInputMode;
                    modelValue: string;
                    state: import("../../../neon").NeonState;
                    autocomplete: string;
                    rows: number;
                    iconReadonly: boolean;
                    hideIcon: boolean;
                    stateHighlight: boolean;
                    stateIcon: boolean;
                    maxlength: number;
                    maxlengthLabel: string;
                    debounce: number;
                }, true, {}, {}, {
                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        sanitizedAttributes: import("vue").ComputedRef<{
                            [x: string]: unknown;
                        }>;
                        icon: import("vue").ComputedRef<string | undefined>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{}>, {
                        color: NeonFunctionalColor;
                        id: string;
                        inverse: boolean;
                        disabled: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: null;
                    };
                    type: {
                        type: () => import("../../../neon").NeonInputType;
                        default: import("../../../neon").NeonInputType;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    inputmode: {
                        type: () => import("../../../neon").NeonInputMode;
                        default: import("../../../neon").NeonInputMode;
                    };
                    autocomplete: {
                        type: StringConstructor;
                        default: string;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    rows: {
                        type: NumberConstructor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconReadonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tabindex: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateHighlight: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    maxlength: {
                        type: NumberConstructor;
                        default: null;
                    };
                    maxlengthLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    debounce: {
                        type: NumberConstructor;
                        default: undefined;
                    };
                }>> & Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
                }>, {
                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
                    focused: import("vue").Ref<boolean, boolean>;
                    sanitizedAttributes: import("vue").ComputedRef<{
                        [x: string]: unknown;
                    }>;
                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
                    iconName: import("vue").ComputedRef<string | undefined>;
                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
                    computedPlaceholder: import("vue").ComputedRef<string>;
                    counterLabel: import("vue").ComputedRef<string | null>;
                    focus: () => void;
                    click: () => void;
                    onFocus: () => void;
                    onBlur: () => void;
                    iconClicked: ($event: Event) => void;
                    changeValue: (event: InputEvent) => void;
                    onKeyDown: (event: KeyboardEvent) => void;
                }, {}, {}, {}, {
                    color: NeonFunctionalColor;
                    icon: string;
                    type: import("../../../neon").NeonInputType;
                    id: string;
                    disabled: boolean;
                    size: NeonSize;
                    placeholder: string;
                    tabindex: number;
                    inputmode: import("../../../neon").NeonInputMode;
                    modelValue: string;
                    state: import("../../../neon").NeonState;
                    autocomplete: string;
                    rows: number;
                    iconReadonly: boolean;
                    hideIcon: boolean;
                    stateHighlight: boolean;
                    stateIcon: boolean;
                    maxlength: number;
                    maxlengthLabel: string;
                    debounce: number;
                }> | null, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: null;
                    };
                    type: {
                        type: () => import("../../../neon").NeonInputType;
                        default: import("../../../neon").NeonInputType;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    inputmode: {
                        type: () => import("../../../neon").NeonInputMode;
                        default: import("../../../neon").NeonInputMode;
                    };
                    autocomplete: {
                        type: StringConstructor;
                        default: string;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    rows: {
                        type: NumberConstructor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconReadonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tabindex: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateHighlight: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    maxlength: {
                        type: NumberConstructor;
                        default: null;
                    };
                    maxlengthLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    debounce: {
                        type: NumberConstructor;
                        default: undefined;
                    };
                }>> & Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
                }>, {
                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
                    focused: import("vue").Ref<boolean, boolean>;
                    sanitizedAttributes: import("vue").ComputedRef<{
                        [x: string]: unknown;
                    }>;
                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
                    iconName: import("vue").ComputedRef<string | undefined>;
                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
                    computedPlaceholder: import("vue").ComputedRef<string>;
                    counterLabel: import("vue").ComputedRef<string | null>;
                    focus: () => void;
                    click: () => void;
                    onFocus: () => void;
                    onBlur: () => void;
                    iconClicked: ($event: Event) => void;
                    changeValue: (event: InputEvent) => void;
                    onKeyDown: (event: KeyboardEvent) => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], import("vue").PublicProps, {
                    color: NeonFunctionalColor;
                    icon: string;
                    type: import("../../../neon").NeonInputType;
                    id: string;
                    disabled: boolean;
                    size: NeonSize;
                    placeholder: string;
                    tabindex: number;
                    inputmode: import("../../../neon").NeonInputMode;
                    modelValue: string;
                    state: import("../../../neon").NeonState;
                    autocomplete: string;
                    rows: number;
                    iconReadonly: boolean;
                    hideIcon: boolean;
                    stateHighlight: boolean;
                    stateIcon: boolean;
                    maxlength: number;
                    maxlengthLabel: string;
                    debounce: number;
                }, true, {}, {}, {
                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        sanitizedAttributes: import("vue").ComputedRef<{
                            [x: string]: unknown;
                        }>;
                        icon: import("vue").ComputedRef<string | undefined>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{}>, {
                        color: NeonFunctionalColor;
                        id: string;
                        inverse: boolean;
                        disabled: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: null;
                    };
                    type: {
                        type: () => import("../../../neon").NeonInputType;
                        default: import("../../../neon").NeonInputType;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    inputmode: {
                        type: () => import("../../../neon").NeonInputMode;
                        default: import("../../../neon").NeonInputMode;
                    };
                    autocomplete: {
                        type: StringConstructor;
                        default: string;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    rows: {
                        type: NumberConstructor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconReadonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tabindex: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateHighlight: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    maxlength: {
                        type: NumberConstructor;
                        default: null;
                    };
                    maxlengthLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    debounce: {
                        type: NumberConstructor;
                        default: undefined;
                    };
                }>> & Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
                }>, {
                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
                    focused: import("vue").Ref<boolean, boolean>;
                    sanitizedAttributes: import("vue").ComputedRef<{
                        [x: string]: unknown;
                    }>;
                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
                    iconName: import("vue").ComputedRef<string | undefined>;
                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
                    computedPlaceholder: import("vue").ComputedRef<string>;
                    counterLabel: import("vue").ComputedRef<string | null>;
                    focus: () => void;
                    click: () => void;
                    onFocus: () => void;
                    onBlur: () => void;
                    iconClicked: ($event: Event) => void;
                    changeValue: (event: InputEvent) => void;
                    onKeyDown: (event: KeyboardEvent) => void;
                }, {}, {}, {}, {
                    color: NeonFunctionalColor;
                    icon: string;
                    type: import("../../../neon").NeonInputType;
                    id: string;
                    disabled: boolean;
                    size: NeonSize;
                    placeholder: string;
                    tabindex: number;
                    inputmode: import("../../../neon").NeonInputMode;
                    modelValue: string;
                    state: import("../../../neon").NeonState;
                    autocomplete: string;
                    rows: number;
                    iconReadonly: boolean;
                    hideIcon: boolean;
                    stateHighlight: boolean;
                    stateIcon: boolean;
                    maxlength: number;
                    maxlengthLabel: string;
                    debounce: number;
                }> | null>;
                files: import("vue").Ref<{
                    readonly lastModified: number;
                    readonly name: string;
                    readonly webkitRelativePath: string;
                    readonly size: number;
                    readonly type: string;
                    arrayBuffer: () => Promise<ArrayBuffer>;
                    slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
                    stream: () => ReadableStream<Uint8Array>;
                    text: () => Promise<string>;
                }[], File[] | {
                    readonly lastModified: number;
                    readonly name: string;
                    readonly webkitRelativePath: string;
                    readonly size: number;
                    readonly type: string;
                    arrayBuffer: () => Promise<ArrayBuffer>;
                    slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
                    stream: () => ReadableStream<Uint8Array>;
                    text: () => Promise<string>;
                }[]>;
                fileList: import("vue").ComputedRef<{
                    key: string;
                    label: string;
                }[]>;
                fileInputModel: import("vue").Ref<string, string>;
                remove: (filename: string) => void;
                clearAll: () => void;
                openFileDialog: () => void;
                onInput: (event: Event) => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                directUpload: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                multiple: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                accept: {
                    type: StringConstructor;
                    default: null;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                size: {
                    type: () => NeonSize;
                    default: NeonSize;
                };
                state: {
                    type: () => import("../../../neon").NeonState;
                    default: import("../../../neon").NeonState;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: NeonFunctionalColor;
                };
                buttonStyle: {
                    type: () => import("../../../neon").NeonButtonStyle;
                    default: import("../../../neon").NeonButtonStyle;
                };
                circular: {
                    type: BooleanConstructor;
                    default: null;
                };
                label: {
                    type: StringConstructor;
                    default: null;
                };
                icon: {
                    type: StringConstructor;
                    default: null;
                };
                title: {
                    type: StringConstructor;
                    default: string;
                };
            }>> & Readonly<{
                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
            }>, {
                color: NeonFunctionalColor;
                icon: string;
                label: string;
                id: string;
                disabled: boolean;
                title: string;
                size: NeonSize;
                buttonStyle: import("../../../neon").NeonButtonStyle;
                state: import("../../../neon").NeonState;
                circular: boolean;
                directUpload: boolean;
                multiple: boolean;
                accept: string;
            }, {}, {
                NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    href: {
                        type: StringConstructor;
                        default: null;
                    };
                    label: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => import("../../../neon").NeonButtonSize;
                        default: import("../../../neon").NeonButtonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor; /**
                         * Id for the date picker button.
                         */
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => import("../../../neon").NeonHorizontalPosition; /**
                         * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                         */
                        default: import("../../../neon").NeonHorizontalPosition;
                    };
                    buttonStyle: {
                        type: () => import("../../../neon").NeonButtonStyle;
                        default: import("../../../neon").NeonButtonStyle;
                    };
                    buttonType: {
                        type: () => import("../../../neon").NeonButtonType;
                        default: import("../../../neon").NeonButtonType;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    transparent: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    circular: {
                        type: BooleanConstructor;
                        default: null;
                    };
                    fullWidth: {
                        type: BooleanConstructor;
                        default: null;
                    };
                    indicator: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    indicatorExpanded: {
                        type: BooleanConstructor;
                        default: null;
                    };
                }>, {
                    iconName: import("vue").ComputedRef<string>;
                    classes: import("vue").ComputedRef<(string | false | {
                        [x: string]: boolean | "" | NeonFunctionalColor;
                        'neon-button--text-transparent': boolean;
                        'neon-button--disabled': boolean;
                        'neon-button--inverse': boolean;
                        'neon-button--circular': boolean;
                        'neon-button--no-outline': boolean;
                        'neon-button--full-width': boolean;
                        'neon-button--with-icon neon-button--icon-only': boolean | "";
                        'neon-button--with-icon neon-button--icon-left': boolean | "";
                        'neon-button--with-icon neon-button--icon-right': boolean | "";
                    })[]>;
                    button: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
                    attrs: {
                        [x: string]: unknown;
                    };
                    sanitizedAttributes: import("vue").ComputedRef<{
                        [x: string]: unknown;
                    }>;
                    clickLink: () => void | undefined;
                    clickButton: () => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    href: {
                        type: StringConstructor;
                        default: null;
                    };
                    label: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => import("../../../neon").NeonButtonSize;
                        default: import("../../../neon").NeonButtonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor; /**
                         * Id for the date picker button.
                         */
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => import("../../../neon").NeonHorizontalPosition; /**
                         * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                         */
                        default: import("../../../neon").NeonHorizontalPosition;
                    };
                    buttonStyle: {
                        type: () => import("../../../neon").NeonButtonStyle;
                        default: import("../../../neon").NeonButtonStyle;
                    };
                    buttonType: {
                        type: () => import("../../../neon").NeonButtonType;
                        default: import("../../../neon").NeonButtonType;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    transparent: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    outline: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    circular: {
                        type: BooleanConstructor;
                        default: null;
                    };
                    fullWidth: {
                        type: BooleanConstructor;
                        default: null;
                    };
                    indicator: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    indicatorExpanded: {
                        type: BooleanConstructor;
                        default: null;
                    };
                }>> & Readonly<{
                    onClick?: ((...args: any[]) => any) | undefined;
                }>, {
                    color: NeonFunctionalColor;
                    icon: string;
                    label: string;
                    inverse: boolean;
                    disabled: boolean;
                    href: string;
                    size: import("../../../neon").NeonButtonSize;
                    alternateColor: NeonFunctionalColor;
                    outline: boolean;
                    iconPosition: import("../../../neon").NeonHorizontalPosition;
                    buttonStyle: import("../../../neon").NeonButtonStyle;
                    buttonType: import("../../../neon").NeonButtonType;
                    state: import("../../../neon").NeonState;
                    transparent: boolean;
                    circular: boolean;
                    fullWidth: boolean;
                    indicator: boolean;
                    indicatorExpanded: boolean;
                }, {}, {
                    NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        expanded: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        inverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        expanded: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        inverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                    }>> & Readonly<{}>, {
                        color: NeonFunctionalColor;
                        inverse: boolean;
                        disabled: boolean;
                        expanded: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        sanitizedAttributes: import("vue").ComputedRef<{
                            [x: string]: unknown;
                        }>;
                        icon: import("vue").ComputedRef<string | undefined>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{}>, {
                        color: NeonFunctionalColor;
                        id: string;
                        inverse: boolean;
                        disabled: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        href: {
                            type: StringConstructor;
                            default: null;
                        };
                        noStyle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outlineStyle: {
                            type: () => import("../../../neon").NeonOutlineStyle;
                            default: import("../../../neon").NeonOutlineStyle;
                        };
                        externalIndicator: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        neonLink: import("vue").Ref<HTMLAnchorElement | null, HTMLAnchorElement | null>;
                        routerUrl: import("vue").ComputedRef<string | undefined>;
                        sanitizedAttributes: import("vue").ComputedRef<{
                            [x: string]: unknown;
                        }>;
                        activeRoute: import("vue").ComputedRef<boolean | "" | undefined>;
                        exactRoute: import("vue").ComputedRef<boolean | "" | undefined>;
                        onClick: () => void; /**
                         * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                         */
                        onSpace: () => Promise<void>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        href: {
                            type: StringConstructor;
                            default: null;
                        };
                        noStyle: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        outlineStyle: {
                            type: () => import("../../../neon").NeonOutlineStyle;
                            default: import("../../../neon").NeonOutlineStyle;
                        };
                        externalIndicator: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{
                        onClick?: ((...args: any[]) => any) | undefined;
                    }>, {
                        href: string;
                        noStyle: boolean;
                        outlineStyle: import("../../../neon").NeonOutlineStyle;
                        externalIndicator: boolean;
                    }, {}, {
                        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            name: {
                                type: StringConstructor;
                                required: true;
                            };
                            id: {
                                type: StringConstructor;
                                default: null;
                            };
                            color: {
                                type: () => NeonFunctionalColor;
                                default: null;
                            };
                            inverse: {
                                type: BooleanConstructor; /**
                                 * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                                 */
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                        }>, {
                            sanitizedAttributes: import("vue").ComputedRef<{
                                [x: string]: unknown;
                            }>;
                            icon: import("vue").ComputedRef<string | undefined>;
                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                            name: {
                                type: StringConstructor;
                                required: true;
                            };
                            id: {
                                type: StringConstructor;
                                default: null;
                            };
                            color: {
                                type: () => NeonFunctionalColor;
                                default: null;
                            };
                            inverse: {
                                type: BooleanConstructor; /**
                                 * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                                 */
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                        }>> & Readonly<{}>, {
                            color: NeonFunctionalColor;
                            id: string;
                            inverse: boolean;
                            disabled: boolean;
                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                NeonInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: null;
                    };
                    type: {
                        type: () => import("../../../neon").NeonInputType;
                        default: import("../../../neon").NeonInputType;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    inputmode: {
                        type: () => import("../../../neon").NeonInputMode;
                        default: import("../../../neon").NeonInputMode;
                    };
                    autocomplete: {
                        type: StringConstructor;
                        default: string;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    rows: {
                        type: NumberConstructor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconReadonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tabindex: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateHighlight: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    maxlength: {
                        type: NumberConstructor;
                        default: null;
                    };
                    maxlengthLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    debounce: {
                        type: NumberConstructor;
                        default: undefined;
                    };
                }>, {
                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
                    focused: import("vue").Ref<boolean, boolean>;
                    sanitizedAttributes: import("vue").ComputedRef<{
                        [x: string]: unknown;
                    }>;
                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
                    iconName: import("vue").ComputedRef<string | undefined>;
                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
                    computedPlaceholder: import("vue").ComputedRef<string>;
                    counterLabel: import("vue").ComputedRef<string | null>;
                    focus: () => void;
                    click: () => void;
                    onFocus: () => void;
                    onBlur: () => void;
                    iconClicked: ($event: Event) => void;
                    changeValue: (event: InputEvent) => void;
                    onKeyDown: (event: KeyboardEvent) => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], "update:modelValue" | "blur" | "focus" | "icon-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: StringConstructor;
                        default: null;
                    };
                    type: {
                        type: () => import("../../../neon").NeonInputType;
                        default: import("../../../neon").NeonInputType;
                    };
                    placeholder: {
                        type: StringConstructor;
                        default: null;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    inputmode: {
                        type: () => import("../../../neon").NeonInputMode;
                        default: import("../../../neon").NeonInputMode;
                    };
                    autocomplete: {
                        type: StringConstructor;
                        default: string;
                    };
                    state: {
                        type: () => import("../../../neon").NeonState;
                        default: import("../../../neon").NeonState;
                    };
                    rows: {
                        type: NumberConstructor;
                        default: null;
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconReadonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tabindex: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateHighlight: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    stateIcon: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    maxlength: {
                        type: NumberConstructor;
                        default: null;
                    };
                    maxlengthLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    debounce: {
                        type: NumberConstructor;
                        default: undefined;
                    };
                }>> & Readonly<{
                    onFocus?: ((...args: any[]) => any) | undefined;
                    onBlur?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
                }>, {
                    color: NeonFunctionalColor;
                    icon: string;
                    type: import("../../../neon").NeonInputType;
                    id: string;
                    disabled: boolean;
                    size: NeonSize;
                    placeholder: string;
                    tabindex: number;
                    inputmode: import("../../../neon").NeonInputMode;
                    modelValue: string;
                    state: import("../../../neon").NeonState;
                    autocomplete: string;
                    rows: number;
                    iconReadonly: boolean;
                    hideIcon: boolean;
                    stateHighlight: boolean;
                    stateIcon: boolean;
                    maxlength: number;
                    maxlengthLabel: string;
                    debounce: number;
                }, {}, {
                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        sanitizedAttributes: import("vue").ComputedRef<{
                            [x: string]: unknown;
                        }>;
                        icon: import("vue").ComputedRef<string | undefined>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{}>, {
                        color: NeonFunctionalColor;
                        id: string;
                        inverse: boolean;
                        disabled: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                NeonList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: () => import("../../../neon").NeonListItem[];
                        required: true;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>, {
                    remove: (key: string) => void; /**
                     * The selected date. A date string in the
                     * <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                     */
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "close")[], "update:modelValue" | "close", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    modelValue: {
                        type: () => import("../../../neon").NeonListItem[];
                        required: true;
                    };
                    size: {
                        type: () => NeonSize;
                        default: NeonSize;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: NeonFunctionalColor;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    onClose?: ((...args: any[]) => any) | undefined;
                }>, {
                    color: NeonFunctionalColor;
                    disabled: boolean;
                    size: NeonSize;
                }, {}, {
                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>, {
                        sanitizedAttributes: import("vue").ComputedRef<{
                            [x: string]: unknown;
                        }>;
                        icon: import("vue").ComputedRef<string | undefined>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        name: {
                            type: StringConstructor;
                            required: true;
                        };
                        id: {
                            type: StringConstructor;
                            default: null;
                        };
                        color: {
                            type: () => NeonFunctionalColor;
                            default: null;
                        };
                        inverse: {
                            type: BooleanConstructor; /**
                             * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                             */
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                    }>> & Readonly<{}>, {
                        color: NeonFunctionalColor;
                        id: string;
                        inverse: boolean;
                        disabled: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                name: {
                    type: StringConstructor;
                    required: true;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
                inverse: {
                    type: BooleanConstructor; /**
                     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                     */
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                sanitizedAttributes: import("vue").ComputedRef<{
                    [x: string]: unknown;
                }>;
                icon: import("vue").ComputedRef<string | undefined>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                name: {
                    type: StringConstructor;
                    required: true;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
                inverse: {
                    type: BooleanConstructor; /**
                     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                     */
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, {
                color: NeonFunctionalColor;
                id: string;
                inverse: boolean;
                disabled: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            href: {
                type: StringConstructor;
                default: null;
            };
            label: {
                type: StringConstructor;
                default: null;
            };
            size: {
                type: () => import("../../../neon").NeonButtonSize;
                default: import("../../../neon").NeonButtonSize;
            };
            color: {
                type: () => NeonFunctionalColor; /**
                 * Id for the date picker button.
                 */
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => import("../../../neon").NeonHorizontalPosition; /**
                 * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                 */
                default: import("../../../neon").NeonHorizontalPosition;
            };
            buttonStyle: {
                type: () => import("../../../neon").NeonButtonStyle;
                default: import("../../../neon").NeonButtonStyle;
            };
            buttonType: {
                type: () => import("../../../neon").NeonButtonType;
                default: import("../../../neon").NeonButtonType;
            };
            state: {
                type: () => import("../../../neon").NeonState;
                default: import("../../../neon").NeonState;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            transparent: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            circular: {
                type: BooleanConstructor;
                default: null;
            };
            fullWidth: {
                type: BooleanConstructor;
                default: null;
            };
            indicator: {
                type: BooleanConstructor;
                default: boolean;
            };
            indicatorExpanded: {
                type: BooleanConstructor;
                default: null;
            };
        }>, {
            iconName: import("vue").ComputedRef<string>;
            classes: import("vue").ComputedRef<(string | false | {
                [x: string]: boolean | "" | NeonFunctionalColor;
                'neon-button--text-transparent': boolean;
                'neon-button--disabled': boolean;
                'neon-button--inverse': boolean;
                'neon-button--circular': boolean;
                'neon-button--no-outline': boolean;
                'neon-button--full-width': boolean;
                'neon-button--with-icon neon-button--icon-only': boolean | "";
                'neon-button--with-icon neon-button--icon-left': boolean | "";
                'neon-button--with-icon neon-button--icon-right': boolean | "";
            })[]>;
            button: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
            attrs: {
                [x: string]: unknown;
            };
            sanitizedAttributes: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            clickLink: () => void | undefined;
            clickButton: () => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            href: {
                type: StringConstructor;
                default: null;
            };
            label: {
                type: StringConstructor;
                default: null;
            };
            size: {
                type: () => import("../../../neon").NeonButtonSize;
                default: import("../../../neon").NeonButtonSize;
            };
            color: {
                type: () => NeonFunctionalColor; /**
                 * Id for the date picker button.
                 */
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => import("../../../neon").NeonHorizontalPosition; /**
                 * Minimum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                 */
                default: import("../../../neon").NeonHorizontalPosition;
            };
            buttonStyle: {
                type: () => import("../../../neon").NeonButtonStyle;
                default: import("../../../neon").NeonButtonStyle;
            };
            buttonType: {
                type: () => import("../../../neon").NeonButtonType;
                default: import("../../../neon").NeonButtonType;
            };
            state: {
                type: () => import("../../../neon").NeonState;
                default: import("../../../neon").NeonState;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            transparent: {
                type: BooleanConstructor;
                default: boolean;
            };
            outline: {
                type: BooleanConstructor;
                default: boolean;
            };
            circular: {
                type: BooleanConstructor;
                default: null;
            };
            fullWidth: {
                type: BooleanConstructor;
                default: null;
            };
            indicator: {
                type: BooleanConstructor;
                default: boolean;
            };
            indicatorExpanded: {
                type: BooleanConstructor;
                default: null;
            };
        }>> & Readonly<{
            onClick?: ((...args: any[]) => any) | undefined;
        }>, {
            color: NeonFunctionalColor;
            icon: string;
            label: string;
            inverse: boolean;
            disabled: boolean;
            href: string;
            size: import("../../../neon").NeonButtonSize;
            alternateColor: NeonFunctionalColor;
            outline: boolean;
            iconPosition: import("../../../neon").NeonHorizontalPosition;
            buttonStyle: import("../../../neon").NeonButtonStyle;
            buttonType: import("../../../neon").NeonButtonType;
            state: import("../../../neon").NeonState;
            transparent: boolean;
            circular: boolean;
            fullWidth: boolean;
            indicator: boolean;
            indicatorExpanded: boolean;
        }, {}, {
            NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                expanded: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                inverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                expanded: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                inverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
            }>> & Readonly<{}>, {
                color: NeonFunctionalColor;
                inverse: boolean;
                disabled: boolean;
                expanded: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                name: {
                    type: StringConstructor;
                    required: true;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
                inverse: {
                    type: BooleanConstructor; /**
                     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                     */
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                sanitizedAttributes: import("vue").ComputedRef<{
                    [x: string]: unknown;
                }>;
                icon: import("vue").ComputedRef<string | undefined>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                name: {
                    type: StringConstructor;
                    required: true;
                };
                id: {
                    type: StringConstructor;
                    default: null;
                };
                color: {
                    type: () => NeonFunctionalColor;
                    default: null;
                };
                inverse: {
                    type: BooleanConstructor; /**
                     * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                     */
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, {
                color: NeonFunctionalColor;
                id: string;
                inverse: boolean;
                disabled: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                href: {
                    type: StringConstructor;
                    default: null;
                };
                noStyle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outlineStyle: {
                    type: () => import("../../../neon").NeonOutlineStyle;
                    default: import("../../../neon").NeonOutlineStyle;
                };
                externalIndicator: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                neonLink: import("vue").Ref<HTMLAnchorElement | null, HTMLAnchorElement | null>;
                routerUrl: import("vue").ComputedRef<string | undefined>;
                sanitizedAttributes: import("vue").ComputedRef<{
                    [x: string]: unknown;
                }>;
                activeRoute: import("vue").ComputedRef<boolean | "" | undefined>;
                exactRoute: import("vue").ComputedRef<boolean | "" | undefined>;
                onClick: () => void; /**
                 * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
                 */
                onSpace: () => Promise<void>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                href: {
                    type: StringConstructor;
                    default: null;
                };
                noStyle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                outlineStyle: {
                    type: () => import("../../../neon").NeonOutlineStyle;
                    default: import("../../../neon").NeonOutlineStyle;
                };
                externalIndicator: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onClick?: ((...args: any[]) => any) | undefined;
            }>, {
                href: string;
                noStyle: boolean;
                outlineStyle: import("../../../neon").NeonOutlineStyle;
                externalIndicator: boolean;
            }, {}, {
                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    name: {
                        type: StringConstructor;
                        required: true;
                    };
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: null;
                    };
                    inverse: {
                        type: BooleanConstructor; /**
                         * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                         */
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>, {
                    sanitizedAttributes: import("vue").ComputedRef<{
                        [x: string]: unknown;
                    }>;
                    icon: import("vue").ComputedRef<string | undefined>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    name: {
                        type: StringConstructor;
                        required: true;
                    };
                    id: {
                        type: StringConstructor;
                        default: null;
                    };
                    color: {
                        type: () => NeonFunctionalColor;
                        default: null;
                    };
                    inverse: {
                        type: BooleanConstructor; /**
                         * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                         */
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{}>, {
                    color: NeonFunctionalColor;
                    id: string;
                    inverse: boolean;
                    disabled: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            expanded: {
                type: BooleanConstructor;
                default: boolean;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            expanded: {
                type: BooleanConstructor;
                default: boolean;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
        }>> & Readonly<{}>, {
            color: NeonFunctionalColor;
            inverse: boolean;
            disabled: boolean;
            expanded: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    NeonInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
            default: null;
        };
        modelValue: {
            type: StringConstructor;
            default: null;
        };
        type: {
            type: () => import("../../../neon").NeonInputType;
            default: import("../../../neon").NeonInputType;
        };
        placeholder: {
            type: StringConstructor;
            default: null;
        };
        size: {
            type: () => NeonSize;
            default: NeonSize;
        };
        color: {
            type: () => NeonFunctionalColor;
            default: NeonFunctionalColor;
        };
        inputmode: {
            type: () => import("../../../neon").NeonInputMode;
            default: import("../../../neon").NeonInputMode;
        };
        autocomplete: {
            type: StringConstructor;
            default: string;
        };
        state: {
            type: () => import("../../../neon").NeonState;
            default: import("../../../neon").NeonState;
        };
        rows: {
            type: NumberConstructor;
            default: null;
        };
        icon: {
            type: StringConstructor;
            default: null;
        };
        iconReadonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideIcon: {
            type: BooleanConstructor;
            default: boolean;
        };
        tabindex: {
            type: NumberConstructor;
            default: number;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        stateHighlight: {
            type: BooleanConstructor;
            default: boolean;
        };
        stateIcon: {
            type: BooleanConstructor;
            default: boolean;
        };
        maxlength: {
            type: NumberConstructor;
            default: null;
        };
        maxlengthLabel: {
            type: StringConstructor;
            default: string;
        };
        debounce: {
            type: NumberConstructor;
            default: undefined;
        };
    }>, {
        neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
        focused: import("vue").Ref<boolean, boolean>;
        sanitizedAttributes: import("vue").ComputedRef<{
            [x: string]: unknown;
        }>;
        iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
        iconName: import("vue").ComputedRef<string | undefined>;
        iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
        computedPlaceholder: import("vue").ComputedRef<string>;
        counterLabel: import("vue").ComputedRef<string | null>;
        focus: () => void;
        click: () => void;
        onFocus: () => void;
        onBlur: () => void;
        iconClicked: ($event: Event) => void;
        changeValue: (event: InputEvent) => void;
        onKeyDown: (event: KeyboardEvent) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], "update:modelValue" | "blur" | "focus" | "icon-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
            default: null;
        };
        modelValue: {
            type: StringConstructor;
            default: null;
        };
        type: {
            type: () => import("../../../neon").NeonInputType;
            default: import("../../../neon").NeonInputType;
        };
        placeholder: {
            type: StringConstructor;
            default: null;
        };
        size: {
            type: () => NeonSize;
            default: NeonSize;
        };
        color: {
            type: () => NeonFunctionalColor;
            default: NeonFunctionalColor;
        };
        inputmode: {
            type: () => import("../../../neon").NeonInputMode;
            default: import("../../../neon").NeonInputMode;
        };
        autocomplete: {
            type: StringConstructor;
            default: string;
        };
        state: {
            type: () => import("../../../neon").NeonState;
            default: import("../../../neon").NeonState;
        };
        rows: {
            type: NumberConstructor;
            default: null;
        };
        icon: {
            type: StringConstructor;
            default: null;
        };
        iconReadonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideIcon: {
            type: BooleanConstructor;
            default: boolean;
        };
        tabindex: {
            type: NumberConstructor;
            default: number;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        stateHighlight: {
            type: BooleanConstructor;
            default: boolean;
        };
        stateIcon: {
            type: BooleanConstructor;
            default: boolean;
        };
        maxlength: {
            type: NumberConstructor;
            default: null;
        };
        maxlengthLabel: {
            type: StringConstructor;
            default: string;
        };
        debounce: {
            type: NumberConstructor;
            default: undefined;
        };
    }>> & Readonly<{
        onFocus?: ((...args: any[]) => any) | undefined;
        onBlur?: ((...args: any[]) => any) | undefined;
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        "onIcon-click"?: ((...args: any[]) => any) | undefined;
    }>, {
        color: NeonFunctionalColor;
        icon: string;
        type: import("../../../neon").NeonInputType;
        id: string;
        disabled: boolean;
        size: NeonSize;
        placeholder: string;
        tabindex: number;
        inputmode: import("../../../neon").NeonInputMode;
        modelValue: string;
        state: import("../../../neon").NeonState;
        autocomplete: string;
        rows: number;
        iconReadonly: boolean;
        hideIcon: boolean;
        stateHighlight: boolean;
        stateIcon: boolean;
        maxlength: number;
        maxlengthLabel: string;
        debounce: number;
    }, {}, {
        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            name: {
                type: StringConstructor;
                required: true;
            };
            id: {
                type: StringConstructor;
                default: null;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            inverse: {
                type: BooleanConstructor; /**
                 * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                 */
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            sanitizedAttributes: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            icon: import("vue").ComputedRef<string | undefined>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            name: {
                type: StringConstructor;
                required: true;
            };
            id: {
                type: StringConstructor;
                default: null;
            };
            color: {
                type: () => NeonFunctionalColor;
                default: null;
            };
            inverse: {
                type: BooleanConstructor; /**
                 * The size of the date picker, one of NeonSize.Small | NeonSize.Medium | NeonSize.Large.
                 */
                default: boolean;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, {
            color: NeonFunctionalColor;
            id: string;
            inverse: boolean;
            disabled: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _default;