import type { NeonDropdownMenuItem } from '@/model/presentation/dropdown/NeonDropdownMenuItem';
import { NeonSize } from '@/model/common/size/NeonSize';
import { NeonFunctionalColor } from '@/model/common/color/NeonFunctionalColor';
import { NeonDropdownPlacement } from '@/model/presentation/dropdown/NeonDropdownPlacement';
import { NeonHorizontalPosition } from '@/model/common/position/NeonHorizontalPosition';
/**
 * <p>A dropdown menu consisting of a button to open the menu and a list of menu items. Clicking on a menu item will
 * result in navigating to the provided URL or notifying the parent component via the @click event.</p>
 * <p><strong>Note:</strong> As well as the options described below, pass through attributes supported by
 * <a href="/presentation/dropdown">NeonDropdown</a> to change the style of the dropdown button.</p>
 */
declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    /**
     * A list of menu items to render in the dropdown menu.
     */
    model: {
        type: () => Array<NeonDropdownMenuItem>;
        required: true;
    };
    /**
     * The size of the dropdown - Small, Medium or Large.
     */
    size: {
        type: () => NeonSize;
        default: NeonSize;
    };
    /**
     * The dropdown color.
     */
    color: {
        type: () => NeonFunctionalColor;
        default: NeonFunctionalColor;
    };
    /**
     * Whether the dropdown button is disabled or not.
     */
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Placement of the dropdown contents.
     */
    placement: {
        type: () => NeonDropdownPlacement;
        default: NeonDropdownPlacement;
    };
    /**
     * Instead of opening on click (default), open on hover.
     */
    openOnHover: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    dropdown: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
        };
        modelValue: {
            type: BooleanConstructor;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null; /**
             * Instead of opening on click (default), open on hover.
             */
        };
        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;
    }>, {
        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")[], import("vue").PublicProps, {
        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;
    }, true, {}, {}, {
        NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            label: {
                type: StringConstructor;
                default: null;
            };
            image: {
                type: StringConstructor; /**
                 * A list of menu items to render in the dropdown menu.
                 */
                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;
            };
            jazziconId: {
                type: StringConstructor;
                default: null;
            };
            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; /**
                 * A list of menu items to render in the dropdown menu.
                 */
                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;
            };
            jazziconId: {
                type: StringConstructor;
                default: null;
            };
            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; /**
                     * Placement of the dropdown contents.
                     */
                }; /**
                 * Placement of the dropdown contents.
                 */
                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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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; /**
                     * Placement of the dropdown contents.
                     */
                }; /**
                 * Placement of the dropdown contents.
                 */
                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;
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null; /**
                         * Instead of opening on click (default), open on hover.
                         */
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => NeonHorizontalPosition;
                        default: 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;
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null; /**
                         * Instead of opening on click (default), open on hover.
                         */
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => NeonHorizontalPosition;
                        default: 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: 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;
                            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;
                            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;
                        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;
                                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;
                                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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                }, {}, {}, {}, 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;
                            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;
                            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;
                    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;
                    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;
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null; /**
                 * Instead of opening on click (default), open on hover.
                 */
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => NeonHorizontalPosition;
                default: 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;
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null; /**
                 * Instead of opening on click (default), open on hover.
                 */
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => NeonHorizontalPosition;
                default: 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: 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;
                    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;
                    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;
                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;
                        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;
                        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>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
        };
        modelValue: {
            type: BooleanConstructor;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null; /**
             * Instead of opening on click (default), open on hover.
             */
        };
        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;
    }>, {
        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;
    }, {}, {}, {}, {
        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;
    }> | null, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
        };
        modelValue: {
            type: BooleanConstructor;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null; /**
             * Instead of opening on click (default), open on hover.
             */
        };
        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;
    }>, {
        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")[], import("vue").PublicProps, {
        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;
    }, true, {}, {}, {
        NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            label: {
                type: StringConstructor;
                default: null;
            };
            image: {
                type: StringConstructor; /**
                 * A list of menu items to render in the dropdown menu.
                 */
                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;
            };
            jazziconId: {
                type: StringConstructor;
                default: null;
            };
            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; /**
                 * A list of menu items to render in the dropdown menu.
                 */
                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;
            };
            jazziconId: {
                type: StringConstructor;
                default: null;
            };
            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; /**
                     * Placement of the dropdown contents.
                     */
                }; /**
                 * Placement of the dropdown contents.
                 */
                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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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; /**
                     * Placement of the dropdown contents.
                     */
                }; /**
                 * Placement of the dropdown contents.
                 */
                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;
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null; /**
                         * Instead of opening on click (default), open on hover.
                         */
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => NeonHorizontalPosition;
                        default: 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;
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null; /**
                         * Instead of opening on click (default), open on hover.
                         */
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => NeonHorizontalPosition;
                        default: 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: 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;
                            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;
                            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;
                        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;
                                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;
                                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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                }, {}, {}, {}, 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;
                            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;
                            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;
                    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;
                    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;
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null; /**
                 * Instead of opening on click (default), open on hover.
                 */
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => NeonHorizontalPosition;
                default: 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;
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null; /**
                 * Instead of opening on click (default), open on hover.
                 */
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => NeonHorizontalPosition;
                default: 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: 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;
                    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;
                    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;
                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;
                        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;
                        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>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
        };
        modelValue: {
            type: BooleanConstructor;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null; /**
             * Instead of opening on click (default), open on hover.
             */
        };
        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;
    }>, {
        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;
    }, {}, {}, {}, {
        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;
    }> | null>;
    items: import("vue").Ref<HTMLLIElement[], HTMLLIElement[]>;
    open: import("vue").Ref<boolean, boolean>;
    highlightedKey: import("vue").Ref<string | null, string | null>;
    highlightedIndex: import("vue").Ref<number, number>;
    attrs: {
        [x: string]: unknown;
    };
    emit: (event: "click", ...args: any[]) => void;
    changeHighlighted: (key: string) => void;
    keyboardHandler: ($event: KeyboardEvent) => void;
    onBlur: () => void;
    onFocus: () => void;
    clickItem: (item: NeonDropdownMenuItem) => void;
    navigateBy: (offset: number, $event: KeyboardEvent) => void;
    onPlacement: (placement: NeonDropdownPlacement) => void;
    NeonHorizontalPosition: typeof NeonHorizontalPosition;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    /**
     * A list of menu items to render in the dropdown menu.
     */
    model: {
        type: () => Array<NeonDropdownMenuItem>;
        required: true;
    };
    /**
     * The size of the dropdown - Small, Medium or Large.
     */
    size: {
        type: () => NeonSize;
        default: NeonSize;
    };
    /**
     * The dropdown color.
     */
    color: {
        type: () => NeonFunctionalColor;
        default: NeonFunctionalColor;
    };
    /**
     * Whether the dropdown button is disabled or not.
     */
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Placement of the dropdown contents.
     */
    placement: {
        type: () => NeonDropdownPlacement;
        default: NeonDropdownPlacement;
    };
    /**
     * Instead of opening on click (default), open on hover.
     */
    openOnHover: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onClick?: ((...args: any[]) => any) | undefined;
}>, {
    color: NeonFunctionalColor;
    disabled: boolean;
    size: NeonSize;
    placement: NeonDropdownPlacement;
    openOnHover: boolean;
}, {}, {
    NeonDropdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        id: {
            type: StringConstructor;
        };
        modelValue: {
            type: BooleanConstructor;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null; /**
             * Instead of opening on click (default), open on hover.
             */
        };
        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;
            required: true;
        };
        label: {
            type: StringConstructor;
            default: null;
        };
        image: {
            type: StringConstructor;
            default: null; /**
             * Instead of opening on click (default), open on hover.
             */
        };
        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; /**
                 * A list of menu items to render in the dropdown menu.
                 */
                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;
            };
            jazziconId: {
                type: StringConstructor;
                default: null;
            };
            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; /**
                 * A list of menu items to render in the dropdown menu.
                 */
                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;
            };
            jazziconId: {
                type: StringConstructor;
                default: null;
            };
            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; /**
                     * Placement of the dropdown contents.
                     */
                }; /**
                 * Placement of the dropdown contents.
                 */
                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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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; /**
                     * Placement of the dropdown contents.
                     */
                }; /**
                 * Placement of the dropdown contents.
                 */
                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;
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null; /**
                         * Instead of opening on click (default), open on hover.
                         */
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => NeonHorizontalPosition;
                        default: 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;
                        default: NeonFunctionalColor;
                    };
                    inverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    alternateColor: {
                        type: () => NeonFunctionalColor;
                        default: null; /**
                         * Instead of opening on click (default), open on hover.
                         */
                    };
                    icon: {
                        type: StringConstructor;
                        default: null;
                    };
                    iconAriaLabel: {
                        type: StringConstructor;
                    };
                    iconPosition: {
                        type: () => NeonHorizontalPosition;
                        default: 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: 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;
                            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;
                            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;
                        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;
                                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;
                                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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                    };
                    /**
                     * emitted when the user clicks on a menu item.
                     * @type {NeonDropdownMenuItem} the menu item the user clicked on.
                     */
                    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;
                            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;
                            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;
                }, {}, {}, {}, 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;
                            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;
                            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;
                    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;
                    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;
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null; /**
                 * Instead of opening on click (default), open on hover.
                 */
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => NeonHorizontalPosition;
                default: 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;
                default: NeonFunctionalColor;
            };
            inverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            alternateColor: {
                type: () => NeonFunctionalColor;
                default: null; /**
                 * Instead of opening on click (default), open on hover.
                 */
            };
            icon: {
                type: StringConstructor;
                default: null;
            };
            iconAriaLabel: {
                type: StringConstructor;
            };
            iconPosition: {
                type: () => NeonHorizontalPosition;
                default: 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: 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;
                    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;
                    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;
                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;
                        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;
                        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>;
    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;
            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;
            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;
        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;
                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;
                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;