@aotearoan/neon 18.2.13 → 19.0.1

package/dist/src/components/user-input/search/NeonSearch.d.ts

@@ -2,6 +2,7 @@ import { NeonSize } from '@/common/enums/NeonSize';
 import { NeonFunctionalColor } from '@/common/enums/NeonFunctionalColor';
 import type { NeonSearchOption } from '@/common/models/NeonSearchOption';
 import { NeonDropdownPlacement } from '@/common/enums/NeonDropdownPlacement';
+import { NeonInputMode } from '@/common/enums/NeonInputMode';
 /**
  * <p>
  *   The <strong>NeonSearch</strong> component is equivalent to an HTML &lt;input type="search"&gt; element. It is
@@ -61,6 +62,22 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: () => NeonFunctionalColor;
         default: NeonFunctionalColor;
     };
+    /**
+     * The HTML autocomplete mode as specified <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete#values">here</a>.
+     * NOTE: No enum is provided in Neon as some values can be used in combination, please refer to the full list of values in the preceding link.
+     */
+    autocomplete: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The HTML input mode as specified <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/inputmode">here</a>.
+     * This can be used to simplify populating the filter field, e.g. providing the user's country from their address.
+     */
+    inputmode: {
+        type: () => NeonInputMode;
+        default: NeonInputMode;
+    };
     /**
      * Placement of the dropdown contents.
      */
@@ -69,7 +86,2172 @@ 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;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor; /**
+             * emitted when the user types in filter box.
+             * @type {string} the current filter criteria. This can be used by the application to filter the displayed options.
+             */
+            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;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                }; /**
+                 * The color of the search.
+                 */
+                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;
+            };
+            /**
+             * Disable the search
+             */
+            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;
+            };
+            /**
+             * Disable the search
+             */
+            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;
+                }; /**
+                 * The color of the search.
+                 */
+                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;
+                    }; /**
+                     * The color of the search.
+                     */
+                    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: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor; /**
+             * emitted when the user types in filter box.
+             * @type {string} the current filter criteria. This can be used by the application to filter the displayed options.
+             */
+            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;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor; /**
+             * emitted when the user types in filter box.
+             * @type {string} the current filter criteria. This can be used by the application to filter the displayed options.
+             */
+            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;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                }; /**
+                 * The color of the search.
+                 */
+                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;
+            };
+            /**
+             * Disable the search
+             */
+            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;
+            };
+            /**
+             * Disable the search
+             */
+            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;
+                }; /**
+                 * The color of the search.
+                 */
+                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;
+                    }; /**
+                     * The color of the search.
+                     */
+                    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: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => NeonDropdownPlacement;
+            default: NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor; /**
+             * emitted when the user types in filter box.
+             * @type {string} the current filter criteria. This can be used by the application to filter the displayed options.
+             */
+            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>;
+    searchInput: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor; /**
+             * <p>
+             *   The <strong>NeonSearch</strong> component is equivalent to an HTML &lt;input type="search"&gt; element. It is
+             *   useful as an alternative to <em>NeonSelect</em> to provide filtered results when the universe of results is very
+             *   large and/or the results need to be requested from a server side API.
+             * </p>
+             * <p><strong>NeonSearch</strong> provides input chips in the case the search allows multiple selection.</p>
+             */
+            default: null;
+        };
+        modelValue: {
+            type: StringConstructor;
+            default: null;
+        };
+        type: {
+            type: () => import("../../../neon").NeonInputType;
+            default: import("../../../neon").NeonInputType;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inputmode: {
+            type: () => NeonInputMode;
+            default: NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        rows: {
+            type: NumberConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconReadonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tabindex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        /**
+         * Placement of the dropdown contents.
+         */
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateHighlight: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxlength: {
+            type: NumberConstructor;
+            default: null;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onIcon-click"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        focused: import("vue").Ref<boolean, boolean>;
+        sanitizedAttributes: import("vue").ComputedRef<{
+            [x: string]: unknown;
+        }>;
+        iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+        iconName: import("vue").ComputedRef<string | undefined>;
+        iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+        computedPlaceholder: import("vue").ComputedRef<string>;
+        focus: () => void;
+        click: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        iconClicked: ($event: Event) => void;
+        changeValue: (event: Event) => void;
+        onKeyDown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "icon-click")[], import("vue").PublicProps, {
+        disabled: boolean;
+        icon: string;
+        type: import("../../../neon").NeonInputType;
+        debounce: number;
+        size: NeonSize;
+        color: NeonFunctionalColor;
+        id: string;
+        placeholder: string;
+        tabindex: number;
+        inputmode: NeonInputMode;
+        modelValue: string;
+        state: import("../../../neon").NeonState;
+        autocomplete: string;
+        rows: number;
+        iconReadonly: boolean;
+        hideIcon: boolean;
+        stateHighlight: boolean;
+        stateIcon: boolean;
+        maxlength: number;
+    }, true, {}, {}, {
+        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;
+            }; /**
+             * The color of the search.
+             */
+            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>;
+    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor; /**
+             * <p>
+             *   The <strong>NeonSearch</strong> component is equivalent to an HTML &lt;input type="search"&gt; element. It is
+             *   useful as an alternative to <em>NeonSelect</em> to provide filtered results when the universe of results is very
+             *   large and/or the results need to be requested from a server side API.
+             * </p>
+             * <p><strong>NeonSearch</strong> provides input chips in the case the search allows multiple selection.</p>
+             */
+            default: null;
+        };
+        modelValue: {
+            type: StringConstructor;
+            default: null;
+        };
+        type: {
+            type: () => import("../../../neon").NeonInputType;
+            default: import("../../../neon").NeonInputType;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inputmode: {
+            type: () => NeonInputMode;
+            default: NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        rows: {
+            type: NumberConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconReadonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tabindex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        /**
+         * Placement of the dropdown contents.
+         */
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateHighlight: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxlength: {
+            type: NumberConstructor;
+            default: null;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onIcon-click"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        focused: import("vue").Ref<boolean, boolean>;
+        sanitizedAttributes: import("vue").ComputedRef<{
+            [x: string]: unknown;
+        }>;
+        iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+        iconName: import("vue").ComputedRef<string | undefined>;
+        iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+        computedPlaceholder: import("vue").ComputedRef<string>;
+        focus: () => void;
+        click: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        iconClicked: ($event: Event) => void;
+        changeValue: (event: Event) => void;
+        onKeyDown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        icon: string;
+        type: import("../../../neon").NeonInputType;
+        debounce: number;
+        size: NeonSize;
+        color: NeonFunctionalColor;
+        id: string;
+        placeholder: string;
+        tabindex: number;
+        inputmode: NeonInputMode;
+        modelValue: string;
+        state: import("../../../neon").NeonState;
+        autocomplete: string;
+        rows: number;
+        iconReadonly: boolean;
+        hideIcon: boolean;
+        stateHighlight: boolean;
+        stateIcon: boolean;
+        maxlength: number;
+    }> | null, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor; /**
+             * <p>
+             *   The <strong>NeonSearch</strong> component is equivalent to an HTML &lt;input type="search"&gt; element. It is
+             *   useful as an alternative to <em>NeonSelect</em> to provide filtered results when the universe of results is very
+             *   large and/or the results need to be requested from a server side API.
+             * </p>
+             * <p><strong>NeonSearch</strong> provides input chips in the case the search allows multiple selection.</p>
+             */
+            default: null;
+        };
+        modelValue: {
+            type: StringConstructor;
+            default: null;
+        };
+        type: {
+            type: () => import("../../../neon").NeonInputType;
+            default: import("../../../neon").NeonInputType;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inputmode: {
+            type: () => NeonInputMode;
+            default: NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        rows: {
+            type: NumberConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconReadonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tabindex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        /**
+         * Placement of the dropdown contents.
+         */
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateHighlight: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxlength: {
+            type: NumberConstructor;
+            default: null;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onIcon-click"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        focused: import("vue").Ref<boolean, boolean>;
+        sanitizedAttributes: import("vue").ComputedRef<{
+            [x: string]: unknown;
+        }>;
+        iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+        iconName: import("vue").ComputedRef<string | undefined>;
+        iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+        computedPlaceholder: import("vue").ComputedRef<string>;
+        focus: () => void;
+        click: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        iconClicked: ($event: Event) => void;
+        changeValue: (event: Event) => void;
+        onKeyDown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "icon-click")[], import("vue").PublicProps, {
+        disabled: boolean;
+        icon: string;
+        type: import("../../../neon").NeonInputType;
+        debounce: number;
+        size: NeonSize;
+        color: NeonFunctionalColor;
+        id: string;
+        placeholder: string;
+        tabindex: number;
+        inputmode: NeonInputMode;
+        modelValue: string;
+        state: import("../../../neon").NeonState;
+        autocomplete: string;
+        rows: number;
+        iconReadonly: boolean;
+        hideIcon: boolean;
+        stateHighlight: boolean;
+        stateIcon: boolean;
+        maxlength: number;
+    }, true, {}, {}, {
+        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;
+            }; /**
+             * The color of the search.
+             */
+            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>;
+    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor; /**
+             * <p>
+             *   The <strong>NeonSearch</strong> component is equivalent to an HTML &lt;input type="search"&gt; element. It is
+             *   useful as an alternative to <em>NeonSelect</em> to provide filtered results when the universe of results is very
+             *   large and/or the results need to be requested from a server side API.
+             * </p>
+             * <p><strong>NeonSearch</strong> provides input chips in the case the search allows multiple selection.</p>
+             */
+            default: null;
+        };
+        modelValue: {
+            type: StringConstructor;
+            default: null;
+        };
+        type: {
+            type: () => import("../../../neon").NeonInputType;
+            default: import("../../../neon").NeonInputType;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inputmode: {
+            type: () => NeonInputMode;
+            default: NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        rows: {
+            type: NumberConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconReadonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tabindex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        /**
+         * Placement of the dropdown contents.
+         */
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateHighlight: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxlength: {
+            type: NumberConstructor;
+            default: null;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onIcon-click"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        focused: import("vue").Ref<boolean, boolean>;
+        sanitizedAttributes: import("vue").ComputedRef<{
+            [x: string]: unknown;
+        }>;
+        iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+        iconName: import("vue").ComputedRef<string | undefined>;
+        iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+        computedPlaceholder: import("vue").ComputedRef<string>;
+        focus: () => void;
+        click: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        iconClicked: ($event: Event) => void;
+        changeValue: (event: Event) => void;
+        onKeyDown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        icon: string;
+        type: import("../../../neon").NeonInputType;
+        debounce: number;
+        size: NeonSize;
+        color: NeonFunctionalColor;
+        id: string;
+        placeholder: string;
+        tabindex: number;
+        inputmode: NeonInputMode;
+        modelValue: string;
+        state: import("../../../neon").NeonState;
+        autocomplete: string;
+        rows: number;
+        iconReadonly: boolean;
+        hideIcon: boolean;
+        stateHighlight: boolean;
+        stateIcon: boolean;
+        maxlength: number;
+    }> | null>;
     open: import("vue").Ref<boolean, boolean>;
     highlightedKey: import("vue").Ref<string | null, string | null>;
     filter: import("vue").Ref<string, string>;
@@ -135,6 +2317,22 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: () => NeonFunctionalColor;
         default: NeonFunctionalColor;
     };
+    /**
+     * The HTML autocomplete mode as specified <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete#values">here</a>.
+     * NOTE: No enum is provided in Neon as some values can be used in combination, please refer to the full list of values in the preceding link.
+     */
+    autocomplete: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The HTML input mode as specified <a href="https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/inputmode">here</a>.
+     * This can be used to simplify populating the filter field, e.g. providing the user's country from their address.
+     */
+    inputmode: {
+        type: () => NeonInputMode;
+        default: NeonInputMode;
+    };
     /**
      * Placement of the dropdown contents.
      */
@@ -150,6 +2348,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     placement: NeonDropdownPlacement;
     size: NeonSize;
     color: NeonFunctionalColor;
+    inputmode: NeonInputMode;
+    autocomplete: string;
     multiple: boolean;
 }, {}, {
     NeonChip: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
@@ -243,7 +2443,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         }>, {
             attrs: {
                 [x: string]: unknown;
-            };
+            }; /**
+             * The color of the search.
+             */
             icon: import("vue").ComputedRef<string>;
         }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
             name: {
@@ -275,9 +2477,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         modelValue: {
             type: BooleanConstructor;
             required: true;
-        }; /**
-         * The list of search results.
-         */
+        };
         label: {
             type: StringConstructor;
             default: null;
@@ -295,9 +2495,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: null;
         };
         indicator: {
-            /**
-             * Placement of the dropdown contents.
-             */
             type: BooleanConstructor;
             default: boolean;
         };
@@ -330,7 +2527,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: null;
         };
         openOnHover: {
-            type: BooleanConstructor;
+            type: BooleanConstructor; /**
+             * emitted when the user types in filter box.
+             * @type {string} the current filter criteria. This can be used by the application to filter the displayed options.
+             */
             default: boolean;
         };
     }>, {
@@ -360,9 +2560,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         modelValue: {
             type: BooleanConstructor;
             required: true;
-        }; /**
-         * The list of search results.
-         */
+        };
         label: {
             type: StringConstructor;
             default: null;
@@ -380,9 +2578,6 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: null;
         };
         indicator: {
-            /**
-             * Placement of the dropdown contents.
-             */
             type: BooleanConstructor;
             default: boolean;
         };
@@ -415,7 +2610,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: null;
         };
         openOnHover: {
-            type: BooleanConstructor;
+            type: BooleanConstructor; /**
+             * emitted when the user types in filter box.
+             * @type {string} the current filter criteria. This can be used by the application to filter the displayed options.
+             */
             default: boolean;
         };
     }>> & Readonly<{
@@ -555,7 +2753,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             }>, {
                 attrs: {
                     [x: string]: unknown;
-                };
+                }; /**
+                 * The color of the search.
+                 */
                 icon: import("vue").ComputedRef<string>;
             }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                 name: {
@@ -609,6 +2809,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 type: StringConstructor;
                 default: null;
             };
+            /**
+             * Disable the search
+             */
             iconPosition: {
                 type: () => import("../../../neon").NeonHorizontalPosition;
                 default: import("../../../neon").NeonHorizontalPosition;
@@ -701,6 +2904,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 type: StringConstructor;
                 default: null;
             };
+            /**
+             * Disable the search
+             */
             iconPosition: {
                 type: () => import("../../../neon").NeonHorizontalPosition;
                 default: import("../../../neon").NeonHorizontalPosition;
@@ -822,7 +3028,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             }>, {
                 attrs: {
                     [x: string]: unknown;
-                };
+                }; /**
+                 * The color of the search.
+                 */
                 icon: import("vue").ComputedRef<string>;
             }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                 name: {
@@ -917,7 +3125,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 }>, {
                     attrs: {
                         [x: string]: unknown;
-                    };
+                    }; /**
+                     * The color of the search.
+                     */
                     icon: import("vue").ComputedRef<string>;
                 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                     name: {
@@ -1004,7 +3214,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }>, {
         attrs: {
             [x: string]: unknown;
-        };
+        }; /**
+         * The color of the search.
+         */
         icon: import("vue").ComputedRef<string>;
     }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
         name: {
@@ -1030,7 +3242,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     NeonInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
         id: {
-            type: StringConstructor;
+            type: StringConstructor; /**
+             * <p>
+             *   The <strong>NeonSearch</strong> component is equivalent to an HTML &lt;input type="search"&gt; element. It is
+             *   useful as an alternative to <em>NeonSelect</em> to provide filtered results when the universe of results is very
+             *   large and/or the results need to be requested from a server side API.
+             * </p>
+             * <p><strong>NeonSearch</strong> provides input chips in the case the search allows multiple selection.</p>
+             */
             default: null;
         };
         modelValue: {
@@ -1054,8 +3273,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: NeonFunctionalColor;
         };
         inputmode: {
-            type: () => import("../../../neon").NeonInputMode;
-            default: import("../../../neon").NeonInputMode;
+            type: () => NeonInputMode;
+            default: NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
         };
         state: {
             type: () => import("../../../neon").NeonState;
@@ -1081,6 +3304,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: NumberConstructor;
             default: number;
         };
+        /**
+         * Placement of the dropdown contents.
+         */
         disabled: {
             type: BooleanConstructor;
             default: boolean;
@@ -1120,7 +3346,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         onKeyDown: (event: KeyboardEvent) => void;
     }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "icon-click")[], "update:modelValue" | "focus" | "blur" | "icon-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
         id: {
-            type: StringConstructor;
+            type: StringConstructor; /**
+             * <p>
+             *   The <strong>NeonSearch</strong> component is equivalent to an HTML &lt;input type="search"&gt; element. It is
+             *   useful as an alternative to <em>NeonSelect</em> to provide filtered results when the universe of results is very
+             *   large and/or the results need to be requested from a server side API.
+             * </p>
+             * <p><strong>NeonSearch</strong> provides input chips in the case the search allows multiple selection.</p>
+             */
             default: null;
         };
         modelValue: {
@@ -1144,8 +3377,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: NeonFunctionalColor;
         };
         inputmode: {
-            type: () => import("../../../neon").NeonInputMode;
-            default: import("../../../neon").NeonInputMode;
+            type: () => NeonInputMode;
+            default: NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
         };
         state: {
             type: () => import("../../../neon").NeonState;
@@ -1171,6 +3408,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             type: NumberConstructor;
             default: number;
         };
+        /**
+         * Placement of the dropdown contents.
+         */
         disabled: {
             type: BooleanConstructor;
             default: boolean;
@@ -1206,9 +3446,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         id: string;
         placeholder: string;
         tabindex: number;
-        inputmode: import("../../../neon").NeonInputMode;
+        inputmode: NeonInputMode;
         modelValue: string;
         state: import("../../../neon").NeonState;
+        autocomplete: string;
         rows: number;
         iconReadonly: boolean;
         hideIcon: boolean;
@@ -1236,7 +3477,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         }>, {
             attrs: {
                 [x: string]: unknown;
-            };
+            }; /**
+             * The color of the search.
+             */
             icon: import("vue").ComputedRef<string>;
         }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
             name: {