@aotearoan/neon 19.0.2 → 21.0.0

package/dist/src/components/navigation/mobile-menu/NeonMobileMenu.d.ts

@@ -0,0 +1,2630 @@
+import type { NeonMenuItem } from '@/common/models/NeonMenuItem';
+import { NeonFunctionalColor } from '@/common/enums/NeonFunctionalColor';
+/**
+ * <p>
+ *   <strong>NeonMobileMenu</strong> is a menu designed for mobile navigation. It is designed to be placed at the bottom
+ *   of the screen to maximise mobile usability.
+ * </p>
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * The menu configuration. The highlighted 'active' menu is determined by the current Vue route.
+     */
+    menu: {
+        type: () => Array<NeonMenuItem>;
+        required: true;
+    };
+    /**
+     * The menu color.
+     */
+    color: {
+        type: () => NeonFunctionalColor;
+        default: NeonFunctionalColor;
+    };
+}>, {
+    onClick: (key: string) => void;
+    routeMatches: (path: string) => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * The menu configuration. The highlighted 'active' menu is determined by the current Vue route.
+     */
+    menu: {
+        type: () => Array<NeonMenuItem>;
+        required: true;
+    };
+    /**
+     * The menu color.
+     */
+    color: {
+        type: () => NeonFunctionalColor;
+        default: NeonFunctionalColor;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    color: NeonFunctionalColor;
+}, {}, {
+    NeonDropdownMenu: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        model: {
+            type: () => import("../../../neon").NeonDropdownMenuItem[];
+            required: true;
+        };
+        size: {
+            type: () => import("../../../neon").NeonSize;
+            default: import("../../../neon").NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        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;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            dropdownStyle: {
+                type: () => import("../../../neon").NeonDropdownStyle;
+                default: import("../../../neon").NeonDropdownStyle;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonDropdownPlacement;
+                default: import("../../../neon").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;
+            "onButton-ref"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            dropdownButton: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+            dropdownContent: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
+            dropdownPlacement: import("vue").Ref<import("../../../neon").NeonDropdownPlacement, import("../../../neon").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" | "focus" | "blur" | "dropdown-placement" | "button-ref")[], import("vue").PublicProps, {
+            disabled: boolean;
+            label: string;
+            placement: import("../../../neon").NeonDropdownPlacement;
+            icon: string;
+            placementContainer: HTMLElement;
+            size: import("../../../neon").NeonSize;
+            color: NeonFunctionalColor;
+            image: string;
+            alternateColor: NeonFunctionalColor;
+            imageAlt: string;
+            indicator: boolean;
+            dropdownStyle: import("../../../neon").NeonDropdownStyle;
+            openOnHover: boolean;
+        }, true, {}, {}, {
+            NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                image: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                circular: {
+                    type: BooleanConstructor; /**
+                     * Emitted when a user clicks on a menu item.
+                     * @type {string} the key of the menu item clicked.
+                     */
+                    default: boolean;
+                };
+                size: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: import("../../../neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                jazziconId: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                imageAlt: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                svg: import("vue").ComputedRef<string | null>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                image: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                circular: {
+                    type: BooleanConstructor; /**
+                     * Emitted when a user clicks on a menu item.
+                     * @type {string} the key of the menu item clicked.
+                     */
+                    default: boolean;
+                };
+                size: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: import("../../../neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                jazziconId: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                imageAlt: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                label: string;
+                icon: string;
+                size: import("../../../neon").NeonSize;
+                color: NeonFunctionalColor;
+                image: string;
+                circular: boolean;
+                alternateColor: NeonFunctionalColor;
+                jazziconId: string;
+                imageAlt: string;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    icon: import("vue").ComputedRef<string>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: 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;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconPosition: {
+                    type: () => import("../../../neon").NeonHorizontalPosition;
+                    default: import("../../../neon").NeonHorizontalPosition;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                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;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconPosition: {
+                    type: () => import("../../../neon").NeonHorizontalPosition;
+                    default: import("../../../neon").NeonHorizontalPosition;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                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;
+            }>, {
+                outline: boolean;
+                disabled: boolean;
+                label: string;
+                href: string;
+                icon: string;
+                size: import("../../../neon").NeonButtonSize;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+                circular: boolean;
+                alternateColor: NeonFunctionalColor;
+                iconPosition: import("../../../neon").NeonHorizontalPosition;
+                buttonStyle: import("../../../neon").NeonButtonStyle;
+                state: import("../../../neon").NeonState;
+                transparent: 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<{}>, {
+                    disabled: boolean;
+                    expanded: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    icon: import("vue").ComputedRef<string>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: 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;
+                    };
+                }>, {
+                    routerUrl: import("vue").ComputedRef<string | undefined>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    activeRoute: import("vue").ComputedRef<boolean | "">;
+                    exactRoute: import("vue").ComputedRef<boolean | "">;
+                    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;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: 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<{}>, {
+                disabled: boolean;
+                expanded: boolean;
+                color: NeonFunctionalColor;
+                inverse: 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;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            dropdownStyle: {
+                type: () => import("../../../neon").NeonDropdownStyle;
+                default: import("../../../neon").NeonDropdownStyle;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonDropdownPlacement;
+                default: import("../../../neon").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;
+            "onButton-ref"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            dropdownButton: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+            dropdownContent: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
+            dropdownPlacement: import("vue").Ref<import("../../../neon").NeonDropdownPlacement, import("../../../neon").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;
+        }, {}, {}, {}, {
+            disabled: boolean;
+            label: string;
+            placement: import("../../../neon").NeonDropdownPlacement;
+            icon: string;
+            placementContainer: HTMLElement;
+            size: import("../../../neon").NeonSize;
+            color: NeonFunctionalColor;
+            image: string;
+            alternateColor: NeonFunctionalColor;
+            imageAlt: string;
+            indicator: boolean;
+            dropdownStyle: import("../../../neon").NeonDropdownStyle;
+            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;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            dropdownStyle: {
+                type: () => import("../../../neon").NeonDropdownStyle;
+                default: import("../../../neon").NeonDropdownStyle;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonDropdownPlacement;
+                default: import("../../../neon").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;
+            "onButton-ref"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            dropdownButton: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+            dropdownContent: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
+            dropdownPlacement: import("vue").Ref<import("../../../neon").NeonDropdownPlacement, import("../../../neon").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" | "focus" | "blur" | "dropdown-placement" | "button-ref")[], import("vue").PublicProps, {
+            disabled: boolean;
+            label: string;
+            placement: import("../../../neon").NeonDropdownPlacement;
+            icon: string;
+            placementContainer: HTMLElement;
+            size: import("../../../neon").NeonSize;
+            color: NeonFunctionalColor;
+            image: string;
+            alternateColor: NeonFunctionalColor;
+            imageAlt: string;
+            indicator: boolean;
+            dropdownStyle: import("../../../neon").NeonDropdownStyle;
+            openOnHover: boolean;
+        }, true, {}, {}, {
+            NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                image: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                circular: {
+                    type: BooleanConstructor; /**
+                     * Emitted when a user clicks on a menu item.
+                     * @type {string} the key of the menu item clicked.
+                     */
+                    default: boolean;
+                };
+                size: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: import("../../../neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                jazziconId: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                imageAlt: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                svg: import("vue").ComputedRef<string | null>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                image: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                circular: {
+                    type: BooleanConstructor; /**
+                     * Emitted when a user clicks on a menu item.
+                     * @type {string} the key of the menu item clicked.
+                     */
+                    default: boolean;
+                };
+                size: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: import("../../../neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                jazziconId: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                imageAlt: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                label: string;
+                icon: string;
+                size: import("../../../neon").NeonSize;
+                color: NeonFunctionalColor;
+                image: string;
+                circular: boolean;
+                alternateColor: NeonFunctionalColor;
+                jazziconId: string;
+                imageAlt: string;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    icon: import("vue").ComputedRef<string>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: 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;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconPosition: {
+                    type: () => import("../../../neon").NeonHorizontalPosition;
+                    default: import("../../../neon").NeonHorizontalPosition;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                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;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconPosition: {
+                    type: () => import("../../../neon").NeonHorizontalPosition;
+                    default: import("../../../neon").NeonHorizontalPosition;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                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;
+            }>, {
+                outline: boolean;
+                disabled: boolean;
+                label: string;
+                href: string;
+                icon: string;
+                size: import("../../../neon").NeonButtonSize;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+                circular: boolean;
+                alternateColor: NeonFunctionalColor;
+                iconPosition: import("../../../neon").NeonHorizontalPosition;
+                buttonStyle: import("../../../neon").NeonButtonStyle;
+                state: import("../../../neon").NeonState;
+                transparent: 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<{}>, {
+                    disabled: boolean;
+                    expanded: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    icon: import("vue").ComputedRef<string>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: 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;
+                    };
+                }>, {
+                    routerUrl: import("vue").ComputedRef<string | undefined>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    activeRoute: import("vue").ComputedRef<boolean | "">;
+                    exactRoute: import("vue").ComputedRef<boolean | "">;
+                    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;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: 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<{}>, {
+                disabled: boolean;
+                expanded: boolean;
+                color: NeonFunctionalColor;
+                inverse: 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;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            dropdownStyle: {
+                type: () => import("../../../neon").NeonDropdownStyle;
+                default: import("../../../neon").NeonDropdownStyle;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonDropdownPlacement;
+                default: import("../../../neon").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;
+            "onButton-ref"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            dropdownButton: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+            dropdownContent: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
+            dropdownPlacement: import("vue").Ref<import("../../../neon").NeonDropdownPlacement, import("../../../neon").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;
+        }, {}, {}, {}, {
+            disabled: boolean;
+            label: string;
+            placement: import("../../../neon").NeonDropdownPlacement;
+            icon: string;
+            placementContainer: HTMLElement;
+            size: import("../../../neon").NeonSize;
+            color: NeonFunctionalColor;
+            image: string;
+            alternateColor: NeonFunctionalColor;
+            imageAlt: string;
+            indicator: boolean;
+            dropdownStyle: import("../../../neon").NeonDropdownStyle;
+            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" | "button-ref", ...args: any[]) => void;
+        changeHighlighted: (key: string) => void;
+        keyboardHandler: ($event: KeyboardEvent) => void;
+        onBlur: () => void;
+        onFocus: () => void;
+        clickItem: (item: import("../../../neon").NeonDropdownMenuItem) => void;
+        navigateBy: (offset: number, $event: KeyboardEvent) => void;
+        onPlacement: (placement: import("../../../neon").NeonDropdownPlacement) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "button-ref")[], "click" | "button-ref", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        model: {
+            type: () => import("../../../neon").NeonDropdownMenuItem[];
+            required: true;
+        };
+        size: {
+            type: () => import("../../../neon").NeonSize;
+            default: import("../../../neon").NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        "onButton-ref"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        disabled: boolean;
+        size: import("../../../neon").NeonSize;
+        color: NeonFunctionalColor;
+        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;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            dropdownStyle: {
+                type: () => import("../../../neon").NeonDropdownStyle;
+                default: import("../../../neon").NeonDropdownStyle;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonDropdownPlacement;
+                default: import("../../../neon").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<import("../../../neon").NeonDropdownPlacement, import("../../../neon").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" | "focus" | "blur" | "dropdown-placement" | "button-ref")[], "update:modelValue" | "focus" | "blur" | "dropdown-placement" | "button-ref", 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;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            dropdownStyle: {
+                type: () => import("../../../neon").NeonDropdownStyle;
+                default: import("../../../neon").NeonDropdownStyle;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonDropdownPlacement;
+                default: import("../../../neon").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;
+            "onButton-ref"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            disabled: boolean;
+            label: string;
+            placement: import("../../../neon").NeonDropdownPlacement;
+            icon: string;
+            placementContainer: HTMLElement;
+            size: import("../../../neon").NeonSize;
+            color: NeonFunctionalColor;
+            image: string;
+            alternateColor: NeonFunctionalColor;
+            imageAlt: string;
+            indicator: boolean;
+            dropdownStyle: import("../../../neon").NeonDropdownStyle;
+            openOnHover: boolean;
+        }, {}, {
+            NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                image: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                circular: {
+                    type: BooleanConstructor; /**
+                     * Emitted when a user clicks on a menu item.
+                     * @type {string} the key of the menu item clicked.
+                     */
+                    default: boolean;
+                };
+                size: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: import("../../../neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                jazziconId: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                imageAlt: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                svg: import("vue").ComputedRef<string | null>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                image: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                circular: {
+                    type: BooleanConstructor; /**
+                     * Emitted when a user clicks on a menu item.
+                     * @type {string} the key of the menu item clicked.
+                     */
+                    default: boolean;
+                };
+                size: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: import("../../../neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                jazziconId: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                imageAlt: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                label: string;
+                icon: string;
+                size: import("../../../neon").NeonSize;
+                color: NeonFunctionalColor;
+                image: string;
+                circular: boolean;
+                alternateColor: NeonFunctionalColor;
+                jazziconId: string;
+                imageAlt: string;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    icon: import("vue").ComputedRef<string>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: 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;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconPosition: {
+                    type: () => import("../../../neon").NeonHorizontalPosition;
+                    default: import("../../../neon").NeonHorizontalPosition;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                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;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconPosition: {
+                    type: () => import("../../../neon").NeonHorizontalPosition;
+                    default: import("../../../neon").NeonHorizontalPosition;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                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;
+            }>, {
+                outline: boolean;
+                disabled: boolean;
+                label: string;
+                href: string;
+                icon: string;
+                size: import("../../../neon").NeonButtonSize;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+                circular: boolean;
+                alternateColor: NeonFunctionalColor;
+                iconPosition: import("../../../neon").NeonHorizontalPosition;
+                buttonStyle: import("../../../neon").NeonButtonStyle;
+                state: import("../../../neon").NeonState;
+                transparent: 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<{}>, {
+                    disabled: boolean;
+                    expanded: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    icon: import("vue").ComputedRef<string>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: 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;
+                    };
+                }>, {
+                    routerUrl: import("vue").ComputedRef<string | undefined>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    activeRoute: import("vue").ComputedRef<boolean | "">;
+                    exactRoute: import("vue").ComputedRef<boolean | "">;
+                    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;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: 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<{}>, {
+                disabled: boolean;
+                expanded: boolean;
+                color: NeonFunctionalColor;
+                inverse: 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;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            attrs: {
+                [x: string]: unknown;
+            };
+            icon: import("vue").ComputedRef<string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            color: NeonFunctionalColor;
+            inverse: 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;
+            };
+        }>, {
+            routerUrl: import("vue").ComputedRef<string | undefined>;
+            sanitizedAttributes: import("vue").ComputedRef<{
+                [x: string]: unknown;
+            }>;
+            activeRoute: import("vue").ComputedRef<boolean | "">;
+            exactRoute: import("vue").ComputedRef<boolean | "">;
+            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;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                icon: import("vue").ComputedRef<string>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, 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;
+        };
+    }>, {
+        routerUrl: import("vue").ComputedRef<string | undefined>;
+        sanitizedAttributes: import("vue").ComputedRef<{
+            [x: string]: unknown;
+        }>;
+        activeRoute: import("vue").ComputedRef<boolean | "">;
+        exactRoute: import("vue").ComputedRef<boolean | "">;
+        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;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            attrs: {
+                [x: string]: unknown;
+            };
+            icon: import("vue").ComputedRef<string>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            disabled: boolean;
+            color: NeonFunctionalColor;
+            inverse: 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;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        inverse: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        attrs: {
+            [x: string]: unknown;
+        };
+        icon: import("vue").ComputedRef<string>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        inverse: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        disabled: boolean;
+        color: NeonFunctionalColor;
+        inverse: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;