@aotearoan/neon 28.1.2 → 28.3.0

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

@@ -0,0 +1,3288 @@
+import { NeonNumberUtils } from '@/utils/common/number/NeonNumberUtils';
+import { NeonSize } from '@/model/common/size/NeonSize';
+import { NeonFunctionalColor } from '@/model/common/color/NeonFunctionalColor';
+/**
+ * A search filter component consisting of a button and a dropdown with a search input. The button either displays the
+ * search label or the current search text.
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * The filter text
+     */
+    modelValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * The count of results matching the current search string. NOTE: This is not the count for the search based on the
+     * model value but rather the count based on the current search string in the dropdown. This allows the component
+     * to display the matching count to the user BEFORE they trigger the CTA to update the search string & refresh the
+     * actual data.
+     */
+    searchCount: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /**
+     * The button & dropdown label when nothing is selected.
+     */
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The search input placeholder text.
+     */
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The color of the component.
+     */
+    color: {
+        type: () => NeonFunctionalColor;
+        default: () => NeonFunctionalColor;
+    };
+    /**
+     * The size of the dropdown button.
+     */
+    size: {
+        type: () => NeonSize;
+        default: () => NeonSize;
+    };
+    /**
+     * The disabled state of the buttons.
+     */
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Button title when items are selected.
+     */
+    editTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Clear button title.
+     */
+    clearTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The close CTA label.
+     */
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+     * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+     * There is one placeholder: {count} - the count of items matching this filter.
+     */
+    showLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {
+    open: import("vue").Ref<boolean, boolean>;
+    search: import("vue").Ref<string, string>;
+    computedLabel: import("vue").ComputedRef<string>;
+    computedShowLabel: import("vue").ComputedRef<string>;
+    isDirty: import("vue").ComputedRef<boolean>;
+    onOpen: () => void;
+    onClose: () => void;
+    onSearchChange: (newValue: string) => void;
+    onSearchClear: () => void;
+    updateSearch: (newValue: string) => void;
+    formatNumber: typeof NeonNumberUtils.formatNumber;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "close" | "onSearch")[], "update:modelValue" | "close" | "onSearch", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * The filter text
+     */
+    modelValue: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * The count of results matching the current search string. NOTE: This is not the count for the search based on the
+     * model value but rather the count based on the current search string in the dropdown. This allows the component
+     * to display the matching count to the user BEFORE they trigger the CTA to update the search string & refresh the
+     * actual data.
+     */
+    searchCount: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /**
+     * The button & dropdown label when nothing is selected.
+     */
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The search input placeholder text.
+     */
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The color of the component.
+     */
+    color: {
+        type: () => NeonFunctionalColor;
+        default: () => NeonFunctionalColor;
+    };
+    /**
+     * The size of the dropdown button.
+     */
+    size: {
+        type: () => NeonSize;
+        default: () => NeonSize;
+    };
+    /**
+     * The disabled state of the buttons.
+     */
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Button title when items are selected.
+     */
+    editTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Clear button title.
+     */
+    clearTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The close CTA label.
+     */
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+     * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+     * There is one placeholder: {count} - the count of items matching this filter.
+     */
+    showLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+    onOnSearch?: ((...args: any[]) => any) | undefined;
+}>, {
+    color: NeonFunctionalColor;
+    label: string;
+    disabled: boolean;
+    size: NeonSize;
+    placeholder: string;
+    editTitle: string;
+    clearTitle: string;
+    closeLabel: string;
+    showLabel: string;
+}, {}, {
+    NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        href: {
+            type: StringConstructor;
+            default: null;
+        };
+        label: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => import("../../../neon").NeonButtonSize;
+            default: import("../../../neon").NeonButtonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inverse: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconAriaLabel: {
+            type: StringConstructor;
+        };
+        iconPosition: {
+            type: () => import("../../../neon").NeonHorizontalPosition;
+            default: import("../../../neon").NeonHorizontalPosition;
+        }; /**
+         * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+         * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+         * There is one placeholder: {count} - the count of items matching this filter.
+         */
+        buttonStyle: {
+            type: () => import("../../../neon").NeonButtonStyle;
+            default: import("../../../neon").NeonButtonStyle;
+        };
+        buttonType: {
+            type: () => import("../../../neon").NeonButtonType;
+            default: import("../../../neon").NeonButtonType;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        transparent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        outline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        circular: {
+            type: BooleanConstructor;
+            default: null;
+        };
+        fullWidth: {
+            type: BooleanConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        indicatorExpanded: {
+            type: BooleanConstructor;
+            default: null;
+        };
+    }>, {
+        iconName: import("vue").ComputedRef<string>;
+        classes: import("vue").ComputedRef<(string | false | {
+            [x: string]: boolean | "" | NeonFunctionalColor;
+            'neon-button--text-transparent': boolean;
+            'neon-button--disabled': boolean;
+            'neon-button--inverse': boolean;
+            'neon-button--circular': boolean;
+            'neon-button--no-outline': boolean;
+            'neon-button--full-width': boolean;
+            'neon-button--with-icon neon-button--icon-only': boolean | "";
+            'neon-button--with-icon neon-button--icon-left': boolean | "";
+            'neon-button--with-icon neon-button--icon-right': boolean | "";
+        })[]>;
+        button: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        attrs: {
+            [x: string]: unknown;
+        };
+        sanitizedAttributes: import("vue").ComputedRef<{
+            [x: string]: unknown;
+        }>;
+        clickLink: () => void | undefined;
+        clickButton: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        href: {
+            type: StringConstructor;
+            default: null;
+        };
+        label: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => import("../../../neon").NeonButtonSize;
+            default: import("../../../neon").NeonButtonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inverse: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconAriaLabel: {
+            type: StringConstructor;
+        };
+        iconPosition: {
+            type: () => import("../../../neon").NeonHorizontalPosition;
+            default: import("../../../neon").NeonHorizontalPosition;
+        }; /**
+         * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+         * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+         * There is one placeholder: {count} - the count of items matching this filter.
+         */
+        buttonStyle: {
+            type: () => import("../../../neon").NeonButtonStyle;
+            default: import("../../../neon").NeonButtonStyle;
+        };
+        buttonType: {
+            type: () => import("../../../neon").NeonButtonType;
+            default: import("../../../neon").NeonButtonType;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        transparent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        outline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        circular: {
+            type: BooleanConstructor;
+            default: null;
+        };
+        fullWidth: {
+            type: BooleanConstructor;
+            default: null;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        indicatorExpanded: {
+            type: BooleanConstructor;
+            default: null;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+    }>, {
+        color: NeonFunctionalColor;
+        icon: string;
+        label: string;
+        inverse: boolean;
+        disabled: boolean;
+        href: string;
+        size: import("../../../neon").NeonButtonSize;
+        alternateColor: NeonFunctionalColor;
+        outline: boolean;
+        iconPosition: import("../../../neon").NeonHorizontalPosition;
+        buttonStyle: import("../../../neon").NeonButtonStyle;
+        buttonType: import("../../../neon").NeonButtonType;
+        state: import("../../../neon").NeonState;
+        transparent: boolean;
+        circular: boolean;
+        fullWidth: boolean;
+        indicator: boolean;
+        indicatorExpanded: boolean;
+    }, {}, {
+        NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            expanded: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            expanded: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+        }>> & Readonly<{}>, {
+            color: NeonFunctionalColor;
+            inverse: boolean;
+            disabled: boolean;
+            expanded: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>; /**
+         * The count of results matching the current search string. NOTE: This is not the count for the search based on the
+         * model value but rather the count based on the current search string in the dropdown. This allows the component
+         * to display the matching count to the user BEFORE they trigger the CTA to update the search string & refresh the
+         * actual data.
+         */
+        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            sanitizedAttributes: import("vue").ComputedRef<{
+                [x: string]: unknown;
+            }>;
+            icon: import("vue").ComputedRef<string | undefined>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            color: NeonFunctionalColor;
+            id: string;
+            inverse: boolean;
+            disabled: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            href: {
+                type: StringConstructor;
+                default: null;
+            };
+            noStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            outlineStyle: {
+                type: () => import("../../../neon").NeonOutlineStyle;
+                default: import("../../../neon").NeonOutlineStyle;
+            };
+            externalIndicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            neonLink: import("vue").Ref<HTMLAnchorElement | null, HTMLAnchorElement | null>;
+            routerUrl: import("vue").ComputedRef<string | undefined>;
+            sanitizedAttributes: import("vue").ComputedRef<{
+                [x: string]: unknown;
+            }>;
+            activeRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+            exactRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+            onClick: () => void;
+            onSpace: () => Promise<void>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            href: {
+                type: StringConstructor;
+                default: null;
+            };
+            noStyle: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            outlineStyle: {
+                type: () => import("../../../neon").NeonOutlineStyle;
+                default: import("../../../neon").NeonOutlineStyle;
+            };
+            externalIndicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+        }>, {
+            href: string;
+            noStyle: boolean;
+            outlineStyle: import("../../../neon").NeonOutlineStyle;
+            externalIndicator: boolean;
+        }, {}, {
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                icon: import("vue").ComputedRef<string | undefined>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                color: NeonFunctionalColor;
+                id: string;
+                inverse: boolean;
+                disabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    NeonDropdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        label: {
+            type: StringConstructor;
+            default: null;
+        };
+        image: {
+            type: StringConstructor;
+            default: null;
+        };
+        imageAlt: {
+            type: StringConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconAriaLabel: {
+            type: StringConstructor;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => import("../../../neon").NeonDropdownPlacement;
+            default: import("../../../neon").NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        dropdownButton: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        dropdownContent: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
+        dropdownPlacement: import("vue").Ref<import("../../../neon").NeonDropdownPlacement, import("../../../neon").NeonDropdownPlacement>;
+        closableUtils: import("vue").Ref<{
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null, import("../../../neon").NeonClosableUtils | {
+            open: () => void;
+            destroy: () => void;
+            escapeKeyListener: (event: KeyboardEvent) => void;
+            close: () => void;
+        } | null>;
+        isButtonStyle: import("vue").ComputedRef<boolean>;
+        onClose: () => void;
+        close: () => void;
+        toggleOpen: () => void;
+        onBlur: () => void;
+        onFocus: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "dropdown-placement")[], "update:modelValue" | "blur" | "focus" | "dropdown-placement", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        label: {
+            type: StringConstructor;
+            default: null;
+        };
+        image: {
+            type: StringConstructor;
+            default: null;
+        };
+        imageAlt: {
+            type: StringConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconAriaLabel: {
+            type: StringConstructor;
+        };
+        indicator: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        dropdownStyle: {
+            type: () => import("../../../neon").NeonDropdownStyle;
+            default: import("../../../neon").NeonDropdownStyle;
+        };
+        placement: {
+            type: () => import("../../../neon").NeonDropdownPlacement;
+            default: import("../../../neon").NeonDropdownPlacement;
+        };
+        placementContainer: {
+            type: () => HTMLElement;
+            default: null;
+        };
+        openOnHover: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onDropdown-placement"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        color: NeonFunctionalColor;
+        icon: string;
+        label: string;
+        disabled: boolean;
+        image: string;
+        size: NeonSize;
+        placement: import("../../../neon").NeonDropdownPlacement;
+        alternateColor: NeonFunctionalColor;
+        indicator: boolean;
+        imageAlt: string;
+        dropdownStyle: import("../../../neon").NeonDropdownStyle;
+        placementContainer: HTMLElement;
+        openOnHover: boolean;
+    }, {}, {
+        NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            image: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            circular: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonBadgeSize;
+                default: import("../../../neon").NeonBadgeSize; /**
+                 * The color of the component.
+                 */
+            }; /**
+             * The color of the component.
+             */
+            color: {
+                type: () => NeonFunctionalColor;
+                /**
+                 * The size of the dropdown button.
+                 */
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            jazziconId: {
+                type: StringConstructor;
+                default: null;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: string;
+            };
+            editButtonTitle: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            emit: (event: "change-image", ...args: any[]) => void;
+            svg: import("vue").ComputedRef<string | null>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change-image"[], "change-image", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            image: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            circular: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            size: {
+                type: () => import("../../../neon").NeonBadgeSize;
+                default: import("../../../neon").NeonBadgeSize; /**
+                 * The color of the component.
+                 */
+            }; /**
+             * The color of the component.
+             */
+            color: {
+                type: () => NeonFunctionalColor;
+                /**
+                 * The size of the dropdown button.
+                 */
+                default: NeonFunctionalColor;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            editable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            jazziconId: {
+                type: StringConstructor;
+                default: null;
+            };
+            imageAlt: {
+                type: StringConstructor;
+                default: string;
+            };
+            editButtonTitle: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            "onChange-image"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            color: NeonFunctionalColor;
+            icon: string;
+            label: string;
+            disabled: boolean;
+            image: string;
+            size: import("../../../neon").NeonBadgeSize;
+            alternateColor: NeonFunctionalColor;
+            circular: boolean;
+            accept: string;
+            editable: boolean;
+            jazziconId: string;
+            imageAlt: string;
+            editButtonTitle: string;
+        }, {}, {
+            NeonFile: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                directUpload: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                multiple: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                accept: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => NeonSize;
+                    default: NeonSize; /**
+                     * The color of the component.
+                     */
+                }; /**
+                 * The color of the component.
+                 */
+                state: {
+                    type: () => import("../../../neon").NeonState;
+                    default: import("../../../neon").NeonState;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                circular: {
+                    type: BooleanConstructor;
+                    default: null;
+                };
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                title: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {
+                fileInput: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    modelValue: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    type: {
+                        type: () => import("../../../neon").NeonInputType;
+                        default: import("../../../neon").NeonInputType;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inputmode: {
+                        type: () => import("../../../neon").NeonInputMode;
+                        default: import("../../../neon").NeonInputMode;
+                    };
+                    autocomplete: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    rows: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconReadonly: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    hideIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    tabindex: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateHighlight: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    maxlength: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    maxlengthLabel: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    counterLabel: import("vue").ComputedRef<string | null>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: InputEvent) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], import("vue").PublicProps, {
+                    color: NeonFunctionalColor;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    id: string;
+                    disabled: boolean;
+                    size: NeonSize;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                    maxlengthLabel: string;
+                    debounce: number;
+                }, true, {}, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        icon: import("vue").ComputedRef<string | undefined>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        color: NeonFunctionalColor;
+                        id: string;
+                        inverse: boolean;
+                        disabled: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    modelValue: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    type: {
+                        type: () => import("../../../neon").NeonInputType;
+                        default: import("../../../neon").NeonInputType;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inputmode: {
+                        type: () => import("../../../neon").NeonInputMode;
+                        default: import("../../../neon").NeonInputMode;
+                    };
+                    autocomplete: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    rows: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconReadonly: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    hideIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    tabindex: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateHighlight: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    maxlength: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    maxlengthLabel: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    counterLabel: import("vue").ComputedRef<string | null>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: InputEvent) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, {
+                    color: NeonFunctionalColor;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    id: string;
+                    disabled: boolean;
+                    size: NeonSize;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                    maxlengthLabel: string;
+                    debounce: number;
+                }> | null, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    modelValue: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    type: {
+                        type: () => import("../../../neon").NeonInputType;
+                        default: import("../../../neon").NeonInputType;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inputmode: {
+                        type: () => import("../../../neon").NeonInputMode;
+                        default: import("../../../neon").NeonInputMode;
+                    };
+                    autocomplete: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    rows: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconReadonly: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    hideIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    tabindex: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateHighlight: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    maxlength: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    maxlengthLabel: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    counterLabel: import("vue").ComputedRef<string | null>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: InputEvent) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], import("vue").PublicProps, {
+                    color: NeonFunctionalColor;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    id: string;
+                    disabled: boolean;
+                    size: NeonSize;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                    maxlengthLabel: string;
+                    debounce: number;
+                }, true, {}, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        icon: import("vue").ComputedRef<string | undefined>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        color: NeonFunctionalColor;
+                        id: string;
+                        inverse: boolean;
+                        disabled: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    modelValue: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    type: {
+                        type: () => import("../../../neon").NeonInputType;
+                        default: import("../../../neon").NeonInputType;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inputmode: {
+                        type: () => import("../../../neon").NeonInputMode;
+                        default: import("../../../neon").NeonInputMode;
+                    };
+                    autocomplete: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    rows: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconReadonly: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    hideIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    tabindex: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateHighlight: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    maxlength: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    maxlengthLabel: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    counterLabel: import("vue").ComputedRef<string | null>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: InputEvent) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, {
+                    color: NeonFunctionalColor;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    id: string;
+                    disabled: boolean;
+                    size: NeonSize;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                    maxlengthLabel: string;
+                    debounce: number;
+                }> | null>;
+                files: import("vue").Ref<{
+                    readonly lastModified: number;
+                    readonly name: string;
+                    readonly webkitRelativePath: string;
+                    readonly size: number;
+                    readonly type: string;
+                    arrayBuffer: () => Promise<ArrayBuffer>;
+                    slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+                    stream: () => ReadableStream<Uint8Array>;
+                    text: () => Promise<string>;
+                }[], File[] | {
+                    readonly lastModified: number;
+                    readonly name: string;
+                    readonly webkitRelativePath: string;
+                    readonly size: number;
+                    readonly type: string;
+                    arrayBuffer: () => Promise<ArrayBuffer>;
+                    slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+                    stream: () => ReadableStream<Uint8Array>;
+                    text: () => Promise<string>;
+                }[]>;
+                fileList: import("vue").ComputedRef<{
+                    key: string;
+                    label: string;
+                }[]>;
+                fileInputModel: import("vue").Ref<string, string>;
+                remove: (filename: string) => void;
+                clearAll: () => void;
+                openFileDialog: () => void;
+                onInput: (event: Event) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                directUpload: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                multiple: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                accept: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => NeonSize;
+                    default: NeonSize; /**
+                     * The color of the component.
+                     */
+                }; /**
+                 * The color of the component.
+                 */
+                state: {
+                    type: () => import("../../../neon").NeonState;
+                    default: import("../../../neon").NeonState;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                buttonStyle: {
+                    type: () => import("../../../neon").NeonButtonStyle;
+                    default: import("../../../neon").NeonButtonStyle;
+                };
+                circular: {
+                    type: BooleanConstructor;
+                    default: null;
+                };
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                title: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                color: NeonFunctionalColor;
+                icon: string;
+                label: string;
+                id: string;
+                disabled: boolean;
+                title: string;
+                size: NeonSize;
+                buttonStyle: import("../../../neon").NeonButtonStyle;
+                state: import("../../../neon").NeonState;
+                circular: boolean;
+                directUpload: boolean;
+                multiple: boolean;
+                accept: string;
+            }, {}, {
+                NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    href: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    label: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => import("../../../neon").NeonButtonSize;
+                        default: import("../../../neon").NeonButtonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    alternateColor: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconAriaLabel: {
+                        type: StringConstructor;
+                    };
+                    iconPosition: {
+                        type: () => import("../../../neon").NeonHorizontalPosition;
+                        default: import("../../../neon").NeonHorizontalPosition;
+                    }; /**
+                     * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+                     * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+                     * There is one placeholder: {count} - the count of items matching this filter.
+                     */
+                    buttonStyle: {
+                        type: () => import("../../../neon").NeonButtonStyle;
+                        default: import("../../../neon").NeonButtonStyle;
+                    };
+                    buttonType: {
+                        type: () => import("../../../neon").NeonButtonType;
+                        default: import("../../../neon").NeonButtonType;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    transparent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    outline: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    circular: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                    fullWidth: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                    indicator: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    indicatorExpanded: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                }>, {
+                    iconName: import("vue").ComputedRef<string>;
+                    classes: import("vue").ComputedRef<(string | false | {
+                        [x: string]: boolean | "" | NeonFunctionalColor;
+                        'neon-button--text-transparent': boolean;
+                        'neon-button--disabled': boolean;
+                        'neon-button--inverse': boolean;
+                        'neon-button--circular': boolean;
+                        'neon-button--no-outline': boolean;
+                        'neon-button--full-width': boolean;
+                        'neon-button--with-icon neon-button--icon-only': boolean | "";
+                        'neon-button--with-icon neon-button--icon-left': boolean | "";
+                        'neon-button--with-icon neon-button--icon-right': boolean | "";
+                    })[]>;
+                    button: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    clickLink: () => void | undefined;
+                    clickButton: () => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    href: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    label: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => import("../../../neon").NeonButtonSize;
+                        default: import("../../../neon").NeonButtonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    alternateColor: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconAriaLabel: {
+                        type: StringConstructor;
+                    };
+                    iconPosition: {
+                        type: () => import("../../../neon").NeonHorizontalPosition;
+                        default: import("../../../neon").NeonHorizontalPosition;
+                    }; /**
+                     * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+                     * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+                     * There is one placeholder: {count} - the count of items matching this filter.
+                     */
+                    buttonStyle: {
+                        type: () => import("../../../neon").NeonButtonStyle;
+                        default: import("../../../neon").NeonButtonStyle;
+                    };
+                    buttonType: {
+                        type: () => import("../../../neon").NeonButtonType;
+                        default: import("../../../neon").NeonButtonType;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    transparent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    outline: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    circular: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                    fullWidth: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                    indicator: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    indicatorExpanded: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                }>> & Readonly<{
+                    onClick?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    color: NeonFunctionalColor;
+                    icon: string;
+                    label: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                    href: string;
+                    size: import("../../../neon").NeonButtonSize;
+                    alternateColor: NeonFunctionalColor;
+                    outline: boolean;
+                    iconPosition: import("../../../neon").NeonHorizontalPosition;
+                    buttonStyle: import("../../../neon").NeonButtonStyle;
+                    buttonType: import("../../../neon").NeonButtonType;
+                    state: import("../../../neon").NeonState;
+                    transparent: boolean;
+                    circular: boolean;
+                    fullWidth: boolean;
+                    indicator: boolean;
+                    indicatorExpanded: boolean;
+                }, {}, {
+                    NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        expanded: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        expanded: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                    }>> & Readonly<{}>, {
+                        color: NeonFunctionalColor;
+                        inverse: boolean;
+                        disabled: boolean;
+                        expanded: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>; /**
+                     * The count of results matching the current search string. NOTE: This is not the count for the search based on the
+                     * model value but rather the count based on the current search string in the dropdown. This allows the component
+                     * to display the matching count to the user BEFORE they trigger the CTA to update the search string & refresh the
+                     * actual data.
+                     */
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        icon: import("vue").ComputedRef<string | undefined>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        color: NeonFunctionalColor;
+                        id: string;
+                        inverse: boolean;
+                        disabled: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                    NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        href: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        noStyle: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        outlineStyle: {
+                            type: () => import("../../../neon").NeonOutlineStyle;
+                            default: import("../../../neon").NeonOutlineStyle;
+                        };
+                        externalIndicator: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        neonLink: import("vue").Ref<HTMLAnchorElement | null, HTMLAnchorElement | null>;
+                        routerUrl: import("vue").ComputedRef<string | undefined>;
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        activeRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+                        exactRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+                        onClick: () => void;
+                        onSpace: () => Promise<void>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        href: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        noStyle: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        outlineStyle: {
+                            type: () => import("../../../neon").NeonOutlineStyle;
+                            default: import("../../../neon").NeonOutlineStyle;
+                        };
+                        externalIndicator: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{
+                        onClick?: ((...args: any[]) => any) | undefined;
+                    }>, {
+                        href: string;
+                        noStyle: boolean;
+                        outlineStyle: import("../../../neon").NeonOutlineStyle;
+                        externalIndicator: boolean;
+                    }, {}, {
+                        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                            name: {
+                                type: StringConstructor;
+                                required: true;
+                            };
+                            id: {
+                                type: StringConstructor;
+                                default: null;
+                            };
+                            color: {
+                                type: () => NeonFunctionalColor;
+                                default: null;
+                            };
+                            inverse: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            disabled: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                        }>, {
+                            sanitizedAttributes: import("vue").ComputedRef<{
+                                [x: string]: unknown;
+                            }>;
+                            icon: import("vue").ComputedRef<string | undefined>;
+                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                            name: {
+                                type: StringConstructor;
+                                required: true;
+                            };
+                            id: {
+                                type: StringConstructor;
+                                default: null;
+                            };
+                            color: {
+                                type: () => NeonFunctionalColor;
+                                default: null;
+                            };
+                            inverse: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            disabled: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                        }>> & Readonly<{}>, {
+                            color: NeonFunctionalColor;
+                            id: string;
+                            inverse: boolean;
+                            disabled: boolean;
+                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    modelValue: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    type: {
+                        type: () => import("../../../neon").NeonInputType;
+                        default: import("../../../neon").NeonInputType;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inputmode: {
+                        type: () => import("../../../neon").NeonInputMode;
+                        default: import("../../../neon").NeonInputMode;
+                    };
+                    autocomplete: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    rows: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconReadonly: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    hideIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    tabindex: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateHighlight: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    maxlength: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    maxlengthLabel: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    counterLabel: import("vue").ComputedRef<string | null>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: InputEvent) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], "update:modelValue" | "blur" | "focus" | "icon-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    modelValue: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    type: {
+                        type: () => import("../../../neon").NeonInputType;
+                        default: import("../../../neon").NeonInputType;
+                    };
+                    placeholder: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    inputmode: {
+                        type: () => import("../../../neon").NeonInputMode;
+                        default: import("../../../neon").NeonInputMode;
+                    };
+                    autocomplete: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    rows: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    icon: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    iconReadonly: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    hideIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    tabindex: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateHighlight: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    stateIcon: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    maxlength: {
+                        type: NumberConstructor;
+                        default: null;
+                    };
+                    maxlengthLabel: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    color: NeonFunctionalColor;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    id: string;
+                    disabled: boolean;
+                    size: NeonSize;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                    maxlengthLabel: string;
+                    debounce: number;
+                }, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        icon: import("vue").ComputedRef<string | undefined>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        color: NeonFunctionalColor;
+                        id: string;
+                        inverse: boolean;
+                        disabled: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    modelValue: {
+                        type: () => import("../../../neon").NeonListItem[];
+                        required: true;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    remove: (key: string) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "close")[], "update:modelValue" | "close", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    modelValue: {
+                        type: () => import("../../../neon").NeonListItem[];
+                        required: true;
+                    };
+                    size: {
+                        type: () => NeonSize;
+                        default: NeonSize;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: NeonFunctionalColor;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    onClose?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    color: NeonFunctionalColor;
+                    disabled: boolean;
+                    size: NeonSize;
+                }, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        icon: import("vue").ComputedRef<string | undefined>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        color: NeonFunctionalColor;
+                        id: string;
+                        inverse: boolean;
+                        disabled: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                icon: import("vue").ComputedRef<string | undefined>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                color: NeonFunctionalColor;
+                id: string;
+                inverse: boolean;
+                disabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            href: {
+                type: StringConstructor;
+                default: null;
+            };
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            size: {
+                type: () => import("../../../neon").NeonButtonSize;
+                default: import("../../../neon").NeonButtonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            iconAriaLabel: {
+                type: StringConstructor;
+            };
+            iconPosition: {
+                type: () => import("../../../neon").NeonHorizontalPosition;
+                default: import("../../../neon").NeonHorizontalPosition;
+            }; /**
+             * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+             * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+             * There is one placeholder: {count} - the count of items matching this filter.
+             */
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle;
+            };
+            buttonType: {
+                type: () => import("../../../neon").NeonButtonType;
+                default: import("../../../neon").NeonButtonType;
+            };
+            state: {
+                type: () => import("../../../neon").NeonState;
+                default: import("../../../neon").NeonState;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transparent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            outline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            circular: {
+                type: BooleanConstructor;
+                default: null;
+            };
+            fullWidth: {
+                type: BooleanConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            indicatorExpanded: {
+                type: BooleanConstructor;
+                default: null;
+            };
+        }>, {
+            iconName: import("vue").ComputedRef<string>;
+            classes: import("vue").ComputedRef<(string | false | {
+                [x: string]: boolean | "" | NeonFunctionalColor;
+                'neon-button--text-transparent': boolean;
+                'neon-button--disabled': boolean;
+                'neon-button--inverse': boolean;
+                'neon-button--circular': boolean;
+                'neon-button--no-outline': boolean;
+                'neon-button--full-width': boolean;
+                'neon-button--with-icon neon-button--icon-only': boolean | "";
+                'neon-button--with-icon neon-button--icon-left': boolean | "";
+                'neon-button--with-icon neon-button--icon-right': boolean | "";
+            })[]>;
+            button: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+            attrs: {
+                [x: string]: unknown;
+            };
+            sanitizedAttributes: import("vue").ComputedRef<{
+                [x: string]: unknown;
+            }>;
+            clickLink: () => void | undefined;
+            clickButton: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            href: {
+                type: StringConstructor;
+                default: null;
+            };
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            size: {
+                type: () => import("../../../neon").NeonButtonSize;
+                default: import("../../../neon").NeonButtonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            iconAriaLabel: {
+                type: StringConstructor;
+            };
+            iconPosition: {
+                type: () => import("../../../neon").NeonHorizontalPosition;
+                default: import("../../../neon").NeonHorizontalPosition;
+            }; /**
+             * The show 'n' items CTA label. This should adhere to the vue-i18n pluralization format
+             * e.g. 'Show {count} items | Show {count} item | Show {count} items'.
+             * There is one placeholder: {count} - the count of items matching this filter.
+             */
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle;
+            };
+            buttonType: {
+                type: () => import("../../../neon").NeonButtonType;
+                default: import("../../../neon").NeonButtonType;
+            };
+            state: {
+                type: () => import("../../../neon").NeonState;
+                default: import("../../../neon").NeonState;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transparent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            outline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            circular: {
+                type: BooleanConstructor;
+                default: null;
+            };
+            fullWidth: {
+                type: BooleanConstructor;
+                default: null;
+            };
+            indicator: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            indicatorExpanded: {
+                type: BooleanConstructor;
+                default: null;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+        }>, {
+            color: NeonFunctionalColor;
+            icon: string;
+            label: string;
+            inverse: boolean;
+            disabled: boolean;
+            href: string;
+            size: import("../../../neon").NeonButtonSize;
+            alternateColor: NeonFunctionalColor;
+            outline: boolean;
+            iconPosition: import("../../../neon").NeonHorizontalPosition;
+            buttonStyle: import("../../../neon").NeonButtonStyle;
+            buttonType: import("../../../neon").NeonButtonType;
+            state: import("../../../neon").NeonState;
+            transparent: boolean;
+            circular: boolean;
+            fullWidth: boolean;
+            indicator: boolean;
+            indicatorExpanded: boolean;
+        }, {}, {
+            NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                expanded: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                expanded: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+            }>> & Readonly<{}>, {
+                color: NeonFunctionalColor;
+                inverse: boolean;
+                disabled: boolean;
+                expanded: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>; /**
+             * The count of results matching the current search string. NOTE: This is not the count for the search based on the
+             * model value but rather the count based on the current search string in the dropdown. This allows the component
+             * to display the matching count to the user BEFORE they trigger the CTA to update the search string & refresh the
+             * actual data.
+             */
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                icon: import("vue").ComputedRef<string | undefined>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                color: NeonFunctionalColor;
+                id: string;
+                inverse: boolean;
+                disabled: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                href: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                noStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                outlineStyle: {
+                    type: () => import("../../../neon").NeonOutlineStyle;
+                    default: import("../../../neon").NeonOutlineStyle;
+                };
+                externalIndicator: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                neonLink: import("vue").Ref<HTMLAnchorElement | null, HTMLAnchorElement | null>;
+                routerUrl: import("vue").ComputedRef<string | undefined>;
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                activeRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+                exactRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+                onClick: () => void;
+                onSpace: () => Promise<void>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                href: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                noStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                outlineStyle: {
+                    type: () => import("../../../neon").NeonOutlineStyle;
+                    default: import("../../../neon").NeonOutlineStyle;
+                };
+                externalIndicator: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+            }>, {
+                href: string;
+                noStyle: boolean;
+                outlineStyle: import("../../../neon").NeonOutlineStyle;
+                externalIndicator: boolean;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    icon: import("vue").ComputedRef<string | undefined>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    color: NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            expanded: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            expanded: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+        }>> & Readonly<{}>, {
+            color: NeonFunctionalColor;
+            inverse: boolean;
+            disabled: boolean;
+            expanded: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    NeonFieldGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        indicatorStyle: {
+            type: () => import("../../../neon").NeonInputIndicatorStyle;
+            default: import("../../../neon").NeonInputIndicatorStyle;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor; /**
+             * The filter text
+             */
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        indicatorStyle: {
+            type: () => import("../../../neon").NeonInputIndicatorStyle;
+            default: import("../../../neon").NeonInputIndicatorStyle;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor; /**
+             * The filter text
+             */
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, {
+        color: NeonFunctionalColor;
+        disabled: boolean;
+        indicatorStyle: import("../../../neon").NeonInputIndicatorStyle;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    NeonInput: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor;
+            default: null;
+        };
+        modelValue: {
+            type: StringConstructor;
+            default: null;
+        };
+        type: {
+            type: () => import("../../../neon").NeonInputType;
+            default: import("../../../neon").NeonInputType;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inputmode: {
+            type: () => import("../../../neon").NeonInputMode;
+            default: import("../../../neon").NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        rows: {
+            type: NumberConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconReadonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tabindex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateHighlight: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxlength: {
+            type: NumberConstructor;
+            default: null;
+        };
+        maxlengthLabel: {
+            type: StringConstructor;
+            default: string;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+    }>, {
+        neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        focused: import("vue").Ref<boolean, boolean>;
+        sanitizedAttributes: import("vue").ComputedRef<{
+            [x: string]: unknown;
+        }>;
+        iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+        iconName: import("vue").ComputedRef<string | undefined>;
+        iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+        computedPlaceholder: import("vue").ComputedRef<string>;
+        counterLabel: import("vue").ComputedRef<string | null>;
+        focus: () => void;
+        click: () => void;
+        onFocus: () => void;
+        onBlur: () => void;
+        iconClicked: ($event: Event) => void;
+        changeValue: (event: InputEvent) => void;
+        onKeyDown: (event: KeyboardEvent) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], "update:modelValue" | "blur" | "focus" | "icon-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        id: {
+            type: StringConstructor;
+            default: null;
+        };
+        modelValue: {
+            type: StringConstructor;
+            default: null;
+        };
+        type: {
+            type: () => import("../../../neon").NeonInputType;
+            default: import("../../../neon").NeonInputType;
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => NeonSize;
+            default: NeonSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        inputmode: {
+            type: () => import("../../../neon").NeonInputMode;
+            default: import("../../../neon").NeonInputMode;
+        };
+        autocomplete: {
+            type: StringConstructor;
+            default: string;
+        };
+        state: {
+            type: () => import("../../../neon").NeonState;
+            default: import("../../../neon").NeonState;
+        };
+        rows: {
+            type: NumberConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        iconReadonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hideIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        tabindex: {
+            type: NumberConstructor;
+            default: number;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateHighlight: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        stateIcon: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxlength: {
+            type: NumberConstructor;
+            default: null;
+        };
+        maxlengthLabel: {
+            type: StringConstructor;
+            default: string;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: undefined;
+        };
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onBlur?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        "onIcon-click"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        color: NeonFunctionalColor;
+        icon: string;
+        type: import("../../../neon").NeonInputType;
+        id: string;
+        disabled: boolean;
+        size: NeonSize;
+        placeholder: string;
+        tabindex: number;
+        inputmode: import("../../../neon").NeonInputMode;
+        modelValue: string;
+        state: import("../../../neon").NeonState;
+        autocomplete: string;
+        rows: number;
+        iconReadonly: boolean;
+        hideIcon: boolean;
+        stateHighlight: boolean;
+        stateIcon: boolean;
+        maxlength: number;
+        maxlengthLabel: string;
+        debounce: number;
+    }, {}, {
+        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            sanitizedAttributes: import("vue").ComputedRef<{
+                [x: string]: unknown;
+            }>;
+            icon: import("vue").ComputedRef<string | undefined>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            color: NeonFunctionalColor;
+            id: string;
+            inverse: boolean;
+            disabled: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    NeonStack: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        gap: {
+            type: () => import("../../../neon").NeonLayoutSize;
+            default: () => import("../../../neon").NeonLayoutSize;
+        };
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        gap: {
+            type: () => import("../../../neon").NeonLayoutSize;
+            default: () => import("../../../neon").NeonLayoutSize;
+        };
+    }>> & Readonly<{}>, {
+        gap: import("../../../neon").NeonLayoutSize;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;