@aotearoan/neon 18.2.13 → 19.0.1

package/dist/src/components/user-input/select/NeonSelect.d.ts

@@ -102,7 +102,1587 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: NeonDropdownPlacement;
     };
 }>, {
-    dropdown: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    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;
+        }; /**
+         * Either a single string, indicating the key of the selected option or an array of selected keys in the case
+         * multiple = true.
+         */
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize; /**
+             * The size of the dropdown - Small, Medium or Large.
+             */
+        }; /**
+         * The size of the dropdown - Small, Medium or Large.
+         */
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onDropdown-placement"?: ((...args: any[]) => any) | undefined;
+        "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<NeonDropdownPlacement, NeonDropdownPlacement>;
+        closableUtils: import("vue").Ref<{
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null, import("../../../neon").NeonClosableUtils | {
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null>;
+        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: NeonDropdownPlacement;
+        icon: string;
+        placementContainer: HTMLElement;
+        size: 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;
+                default: boolean;
+            };
+            size: {
+                type: () => NeonSize;
+                default: 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;
+                default: boolean;
+            };
+            size: {
+                type: () => NeonSize;
+                default: 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: 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; /**
+                     * Optional placeholder icon.
+                     */
+                    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; /**
+                     * Optional placeholder icon.
+                     */
+                    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;
+            }; /**
+             * A list of grouped options to render in the select.
+             */
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            iconPosition: {
+                type: () => import("../../../neon").NeonHorizontalPosition;
+                default: import("../../../neon").NeonHorizontalPosition;
+            };
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle; /**
+                 * Allow multi-select.
+                 */
+            }; /**
+             * Allow multi-select.
+             */
+            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;
+            }; /**
+             * A list of grouped options to render in the select.
+             */
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            iconPosition: {
+                type: () => import("../../../neon").NeonHorizontalPosition;
+                default: import("../../../neon").NeonHorizontalPosition;
+            };
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle; /**
+                 * Allow multi-select.
+                 */
+            }; /**
+             * Allow multi-select.
+             */
+            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; /**
+                     * Optional placeholder icon.
+                     */
+                    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; /**
+                     * Optional placeholder icon.
+                     */
+                    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; /**
+                         * Optional placeholder icon.
+                         */
+                        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; /**
+                         * Optional placeholder icon.
+                         */
+                        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;
+        }; /**
+         * Either a single string, indicating the key of the selected option or an array of selected keys in the case
+         * multiple = true.
+         */
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize; /**
+             * The size of the dropdown - Small, Medium or Large.
+             */
+        }; /**
+         * The size of the dropdown - Small, Medium or Large.
+         */
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onDropdown-placement"?: ((...args: any[]) => any) | undefined;
+        "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<NeonDropdownPlacement, NeonDropdownPlacement>;
+        closableUtils: import("vue").Ref<{
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null, import("../../../neon").NeonClosableUtils | {
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null>;
+        onClose: () => void;
+        close: () => void;
+        toggleOpen: () => void;
+        onBlur: () => void;
+        onFocus: () => void;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        label: string;
+        placement: NeonDropdownPlacement;
+        icon: string;
+        placementContainer: HTMLElement;
+        size: 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;
+        }; /**
+         * Either a single string, indicating the key of the selected option or an array of selected keys in the case
+         * multiple = true.
+         */
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize; /**
+             * The size of the dropdown - Small, Medium or Large.
+             */
+        }; /**
+         * The size of the dropdown - Small, Medium or Large.
+         */
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onDropdown-placement"?: ((...args: any[]) => any) | undefined;
+        "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<NeonDropdownPlacement, NeonDropdownPlacement>;
+        closableUtils: import("vue").Ref<{
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null, import("../../../neon").NeonClosableUtils | {
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null>;
+        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: NeonDropdownPlacement;
+        icon: string;
+        placementContainer: HTMLElement;
+        size: 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;
+                default: boolean;
+            };
+            size: {
+                type: () => NeonSize;
+                default: 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;
+                default: boolean;
+            };
+            size: {
+                type: () => NeonSize;
+                default: 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: 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; /**
+                     * Optional placeholder icon.
+                     */
+                    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; /**
+                     * Optional placeholder icon.
+                     */
+                    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;
+            }; /**
+             * A list of grouped options to render in the select.
+             */
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            iconPosition: {
+                type: () => import("../../../neon").NeonHorizontalPosition;
+                default: import("../../../neon").NeonHorizontalPosition;
+            };
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle; /**
+                 * Allow multi-select.
+                 */
+            }; /**
+             * Allow multi-select.
+             */
+            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;
+            }; /**
+             * A list of grouped options to render in the select.
+             */
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            iconPosition: {
+                type: () => import("../../../neon").NeonHorizontalPosition;
+                default: import("../../../neon").NeonHorizontalPosition;
+            };
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle; /**
+                 * Allow multi-select.
+                 */
+            }; /**
+             * Allow multi-select.
+             */
+            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; /**
+                     * Optional placeholder icon.
+                     */
+                    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; /**
+                     * Optional placeholder icon.
+                     */
+                    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; /**
+                         * Optional placeholder icon.
+                         */
+                        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; /**
+                         * Optional placeholder icon.
+                         */
+                        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;
+        }; /**
+         * Either a single string, indicating the key of the selected option or an array of selected keys in the case
+         * multiple = true.
+         */
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize; /**
+             * The size of the dropdown - Small, Medium or Large.
+             */
+        }; /**
+         * The size of the dropdown - Small, Medium or Large.
+         */
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onDropdown-placement"?: ((...args: any[]) => any) | undefined;
+        "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<NeonDropdownPlacement, NeonDropdownPlacement>;
+        closableUtils: import("vue").Ref<{
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null, import("../../../neon").NeonClosableUtils | {
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null>;
+        onClose: () => void;
+        close: () => void;
+        toggleOpen: () => void;
+        onBlur: () => void;
+        onFocus: () => void;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        label: string;
+        placement: NeonDropdownPlacement;
+        icon: string;
+        placementContainer: HTMLElement;
+        size: NeonSize;
+        color: NeonFunctionalColor;
+        image: string;
+        alternateColor: NeonFunctionalColor;
+        imageAlt: string;
+        indicator: boolean;
+        dropdownStyle: import("../../../neon").NeonDropdownStyle;
+        openOnHover: boolean;
+    }> | null>;
     open: import("vue").Ref<boolean, boolean>;
     highlightedKey: import("vue").Ref<string | null, string | null>;
     highlightedIndex: import("vue").Ref<number, number>;
@@ -238,7 +1818,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         imageAlt: {
             type: StringConstructor;
             default: null;
-        };
+        }; /**
+         * Either a single string, indicating the key of the selected option or an array of selected keys in the case
+         * multiple = true.
+         */
         icon: {
             type: StringConstructor;
             default: null;
@@ -253,15 +1836,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         };
         size: {
             type: () => NeonSize;
-            default: NeonSize;
-        };
+            default: NeonSize; /**
+             * The size of the dropdown - Small, Medium or Large.
+             */
+        }; /**
+         * The size of the dropdown - Small, Medium or Large.
+         */
         color: {
             type: () => NeonFunctionalColor;
             default: NeonFunctionalColor;
         };
-        /**
-         * The color of the select.
-         */
         alternateColor: {
             type: () => NeonFunctionalColor;
             default: null;
@@ -269,11 +1853,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         dropdownStyle: {
             type: () => import("../../../neon").NeonDropdownStyle;
             default: import("../../../neon").NeonDropdownStyle;
-        }; /**
-         * emitted when the user changes the selection.
-         * @type {string | string[]} either the selected option's key (single select) or an array of the selected keys
-         * (multi-select).
-         */
+        };
         placement: {
             type: () => NeonDropdownPlacement;
             default: NeonDropdownPlacement;
@@ -325,7 +1905,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         imageAlt: {
             type: StringConstructor;
             default: null;
-        };
+        }; /**
+         * Either a single string, indicating the key of the selected option or an array of selected keys in the case
+         * multiple = true.
+         */
         icon: {
             type: StringConstructor;
             default: null;
@@ -340,15 +1923,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         };
         size: {
             type: () => NeonSize;
-            default: NeonSize;
-        };
+            default: NeonSize; /**
+             * The size of the dropdown - Small, Medium or Large.
+             */
+        }; /**
+         * The size of the dropdown - Small, Medium or Large.
+         */
         color: {
             type: () => NeonFunctionalColor;
             default: NeonFunctionalColor;
         };
-        /**
-         * The color of the select.
-         */
         alternateColor: {
             type: () => NeonFunctionalColor;
             default: null;
@@ -356,11 +1940,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         dropdownStyle: {
             type: () => import("../../../neon").NeonDropdownStyle;
             default: import("../../../neon").NeonDropdownStyle;
-        }; /**
-         * emitted when the user changes the selection.
-         * @type {string | string[]} either the selected option's key (single select) or an array of the selected keys
-         * (multi-select).
-         */
+        };
         placement: {
             type: () => NeonDropdownPlacement;
             default: NeonDropdownPlacement;
@@ -539,9 +2119,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 inverse: boolean;
             }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
         }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-        /**
-         * Display the placeholder as the first option in the select, this is useful as an alternative to a label.
-         */
         NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
             href: {
                 type: StringConstructor;
@@ -565,10 +2142,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             };
             alternateColor: {
                 type: () => NeonFunctionalColor;
-                default: null; /**
-                 * A list of grouped options to render in the select.
-                 */
-            };
+                default: null;
+            }; /**
+             * A list of grouped options to render in the select.
+             */
             icon: {
                 type: StringConstructor;
                 default: null;
@@ -579,8 +2156,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             };
             buttonStyle: {
                 type: () => import("../../../neon").NeonButtonStyle;
-                default: import("../../../neon").NeonButtonStyle;
-            };
+                default: import("../../../neon").NeonButtonStyle; /**
+                 * Allow multi-select.
+                 */
+            }; /**
+             * Allow multi-select.
+             */
             state: {
                 type: () => import("../../../neon").NeonState;
                 default: import("../../../neon").NeonState;
@@ -659,10 +2240,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             };
             alternateColor: {
                 type: () => NeonFunctionalColor;
-                default: null; /**
-                 * A list of grouped options to render in the select.
-                 */
-            };
+                default: null;
+            }; /**
+             * A list of grouped options to render in the select.
+             */
             icon: {
                 type: StringConstructor;
                 default: null;
@@ -673,8 +2254,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             };
             buttonStyle: {
                 type: () => import("../../../neon").NeonButtonStyle;
-                default: import("../../../neon").NeonButtonStyle;
-            };
+                default: import("../../../neon").NeonButtonStyle; /**
+                 * Allow multi-select.
+                 */
+            }; /**
+             * Allow multi-select.
+             */
             state: {
                 type: () => import("../../../neon").NeonState;
                 default: import("../../../neon").NeonState;