@aotearoan/neon 22.1.2 → 22.3.0

package/dist/src/components/user-input/date-picker/NeonDatePicker.d.ts

@@ -577,13 +577,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         size: import("../../../neon").NeonButtonSize;
         color: NeonFunctionalColor;
         inverse: boolean;
-        circular: boolean;
         alternateColor: NeonFunctionalColor;
         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;
@@ -963,8 +963,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         color: NeonFunctionalColor;
         image: string;
         alternateColor: NeonFunctionalColor;
-        imageAlt: string;
         indicator: boolean;
+        imageAlt: string;
         dropdownStyle: import("../../../neon").NeonDropdownStyle;
         openOnHover: boolean;
     }, {}, {
@@ -997,10 +997,20 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 type: () => NeonFunctionalColor;
                 default: null;
             };
-            disabled: {
+            editable: {
                 type: BooleanConstructor;
                 default: boolean;
             };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            }; /**
+             * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
+             */
             jazziconId: {
                 type: StringConstructor;
                 default: null;
@@ -1009,9 +1019,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 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, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change-image"[], "change-image", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
             label: {
                 type: StringConstructor;
                 default: null;
@@ -1040,10 +1055,20 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 type: () => NeonFunctionalColor;
                 default: null;
             };
-            disabled: {
+            editable: {
                 type: BooleanConstructor;
                 default: boolean;
             };
+            accept: {
+                type: StringConstructor;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            }; /**
+             * Maximum allowed date value in the <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
+             */
             jazziconId: {
                 type: StringConstructor;
                 default: null;
@@ -1052,242 +1077,1800 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 type: StringConstructor;
                 default: string;
             };
-        }>> & Readonly<{}>, {
+            editButtonTitle: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            "onChange-image"?: ((...args: any[]) => any) | undefined;
+        }>, {
             disabled: boolean;
             label: string;
             icon: string;
             size: import("../../../neon").NeonBadgeSize;
             color: NeonFunctionalColor;
             image: string;
-            circular: boolean;
             alternateColor: NeonFunctionalColor;
+            circular: boolean;
+            accept: string;
+            editable: boolean;
             jazziconId: string;
             imageAlt: string;
+            editButtonTitle: string;
         }, {}, {
-            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-                name: {
-                    type: StringConstructor;
-                    required: true; /**
-                     * Id for the date picker button.
-                     */
-                }; /**
-                 * Id for the date picker button.
-                 */
-                color: {
-                    type: () => NeonFunctionalColor;
-                    default: null;
+            NeonFile: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
                 };
-                inverse: {
+                directUpload: {
                     type: BooleanConstructor;
                     default: boolean;
                 };
-                disabled: {
+                multiple: {
                     type: BooleanConstructor;
-                    default: boolean; /**
-                     * Disable date picker
-                     */
-                }; /**
-                 * Disable date picker
-                 */
-            }>, {
-                attrs: {
-                    [x: string]: unknown;
+                    default: boolean;
                 };
-                icon: import("vue").ComputedRef<string>;
-            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-                name: {
+                accept: {
                     type: StringConstructor;
-                    required: true; /**
+                    default: null;
+                };
+                id: {
+                    /**
                      * Id for the date picker button.
                      */
-                }; /**
-                 * Id for the date picker button.
-                 */
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => NeonSize;
+                    default: NeonSize;
+                };
+                state: {
+                    type: () => import("../../../neon").NeonState;
+                    default: import("../../../neon").NeonState;
+                };
                 color: {
                     type: () => NeonFunctionalColor;
-                    default: null;
+                    default: NeonFunctionalColor;
                 };
-                inverse: {
+                circular: {
                     type: BooleanConstructor;
-                    default: boolean;
+                    default: null;
                 };
-                disabled: {
-                    type: BooleanConstructor;
-                    default: boolean; /**
-                     * Disable date picker
-                     */
-                }; /**
-                 * Disable date picker
-                 */
-            }>> & Readonly<{}>, {
-                disabled: boolean;
-                color: NeonFunctionalColor;
-                inverse: boolean;
-            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-        NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-            href: {
-                type: StringConstructor;
-                default: null;
-            };
-            label: {
-                type: StringConstructor;
-                default: null;
-            };
-            size: {
-                type: () => import("../../../neon").NeonButtonSize;
-                default: import("../../../neon").NeonButtonSize;
-            };
-            color: {
-                type: () => NeonFunctionalColor;
-                default: NeonFunctionalColor;
-            };
-            inverse: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            alternateColor: {
-                type: () => NeonFunctionalColor;
-                default: null;
-            };
-            icon: {
-                type: StringConstructor;
-                default: null;
-            };
-            iconAriaLabel: {
-                type: StringConstructor;
-            };
-            iconPosition: {
-                type: () => import("../../../neon").NeonHorizontalPosition;
-                default: import("../../../neon").NeonHorizontalPosition;
-            };
-            buttonStyle: {
-                type: () => import("../../../neon").NeonButtonStyle;
-                default: import("../../../neon").NeonButtonStyle;
-            };
-            buttonType: {
-                type: () => import("../../../neon").NeonButtonType;
-                default: import("../../../neon").NeonButtonType; /**
-                 * The placement of the dropdown calendar popup.
-                 */
-            };
-            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;
-            };
-            buttonStyle: {
-                type: () => import("../../../neon").NeonButtonStyle;
-                default: import("../../../neon").NeonButtonStyle;
-            };
-            buttonType: {
-                type: () => import("../../../neon").NeonButtonType;
-                default: import("../../../neon").NeonButtonType; /**
-                 * The placement of the dropdown calendar popup.
-                 */
-            };
-            state: {
-                type: () => import("../../../neon").NeonState;
-                default: import("../../../neon").NeonState;
-            };
-            disabled: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            transparent: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            outline: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
+                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;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: Event) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "icon-click")[], import("vue").PublicProps, {
+                    disabled: boolean;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    debounce: number;
+                    size: NeonSize;
+                    color: NeonFunctionalColor;
+                    id: string;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                }, true, {}, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        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;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: Event) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, {
+                    disabled: boolean;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    debounce: number;
+                    size: NeonSize;
+                    color: NeonFunctionalColor;
+                    id: string;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                }> | null, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        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;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: Event) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "icon-click")[], import("vue").PublicProps, {
+                    disabled: boolean;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    debounce: number;
+                    size: NeonSize;
+                    color: NeonFunctionalColor;
+                    id: string;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: number;
+                }, true, {}, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    id: {
+                        type: StringConstructor;
+                        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;
+                    };
+                    debounce: {
+                        type: NumberConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onFocus?: ((...args: any[]) => any) | undefined;
+                    onBlur?: ((...args: any[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                    "onIcon-click"?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                    focused: import("vue").Ref<boolean, boolean>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                    iconName: import("vue").ComputedRef<string | undefined>;
+                    iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                    computedPlaceholder: import("vue").ComputedRef<string>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: Event) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, {
+                    disabled: boolean;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    debounce: number;
+                    size: NeonSize;
+                    color: NeonFunctionalColor;
+                    id: string;
+                    placeholder: string;
+                    tabindex: number;
+                    inputmode: import("../../../neon").NeonInputMode;
+                    modelValue: string;
+                    state: import("../../../neon").NeonState;
+                    autocomplete: string;
+                    rows: number;
+                    iconReadonly: boolean;
+                    hideIcon: boolean;
+                    stateHighlight: boolean;
+                    stateIcon: boolean;
+                    maxlength: 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; /**
+                     * Disabled dates, a list of <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format
+                     * dates for which to disable selection.
+                     */
+                    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: {
+                    /**
+                     * Id for the date picker button.
+                     */
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => NeonSize;
+                    default: NeonSize;
+                };
+                state: {
+                    type: () => import("../../../neon").NeonState;
+                    default: import("../../../neon").NeonState;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                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;
+            }>, {
+                disabled: boolean;
+                label: string;
+                title: string;
+                icon: string;
+                size: NeonSize;
+                color: NeonFunctionalColor;
+                id: string;
+                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;
+                    };
+                    buttonStyle: {
+                        type: () => import("../../../neon").NeonButtonStyle;
+                        default: import("../../../neon").NeonButtonStyle;
+                    };
+                    buttonType: {
+                        type: () => import("../../../neon").NeonButtonType;
+                        default: import("../../../neon").NeonButtonType; /**
+                         * The placement of the dropdown calendar popup.
+                         */
+                    };
+                    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;
+                    };
+                    buttonStyle: {
+                        type: () => import("../../../neon").NeonButtonStyle;
+                        default: import("../../../neon").NeonButtonStyle;
+                    };
+                    buttonType: {
+                        type: () => import("../../../neon").NeonButtonType;
+                        default: import("../../../neon").NeonButtonType; /**
+                         * The placement of the dropdown calendar popup.
+                         */
+                    };
+                    state: {
+                        type: () => import("../../../neon").NeonState;
+                        default: import("../../../neon").NeonState;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    transparent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    outline: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    circular: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                    fullWidth: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                    indicator: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    indicatorExpanded: {
+                        type: BooleanConstructor;
+                        default: null;
+                    };
+                }>> & Readonly<{
+                    onClick?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    outline: boolean;
+                    disabled: boolean;
+                    label: string;
+                    href: string;
+                    icon: string;
+                    size: import("../../../neon").NeonButtonSize;
+                    color: NeonFunctionalColor;
+                    inverse: boolean;
+                    alternateColor: NeonFunctionalColor;
+                    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<{}>, {
+                        disabled: boolean;
+                        expanded: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                    NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        href: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        noStyle: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        outlineStyle: {
+                            type: () => import("../../../neon").NeonOutlineStyle;
+                            default: import("../../../neon").NeonOutlineStyle;
+                        };
+                        externalIndicator: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        routerUrl: import("vue").ComputedRef<string | undefined>;
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        activeRoute: import("vue").ComputedRef<boolean | "">;
+                        exactRoute: import("vue").ComputedRef<boolean | "">;
+                        onClick: () => void;
+                        onSpace: () => Promise<void>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        href: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        noStyle: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        outlineStyle: {
+                            type: () => import("../../../neon").NeonOutlineStyle;
+                            default: import("../../../neon").NeonOutlineStyle;
+                        };
+                        externalIndicator: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{
+                        onClick?: ((...args: any[]) => any) | undefined;
+                    }>, {
+                        href: string;
+                        noStyle: boolean;
+                        outlineStyle: import("../../../neon").NeonOutlineStyle;
+                        externalIndicator: boolean;
+                    }, {}, {
+                        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                            name: {
+                                type: StringConstructor;
+                                required: true; /**
+                                 * Id for the date picker button.
+                                 */
+                            }; /**
+                             * Id for the date picker button.
+                             */
+                            color: {
+                                type: () => NeonFunctionalColor;
+                                default: null;
+                            };
+                            inverse: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            disabled: {
+                                type: BooleanConstructor;
+                                default: boolean; /**
+                                 * Disable date picker
+                                 */
+                            }; /**
+                             * Disable date picker
+                             */
+                        }>, {
+                            attrs: {
+                                [x: string]: unknown;
+                            };
+                            icon: import("vue").ComputedRef<string>;
+                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                            name: {
+                                type: StringConstructor;
+                                required: true; /**
+                                 * Id for the date picker button.
+                                 */
+                            }; /**
+                             * Id for the date picker button.
+                             */
+                            color: {
+                                type: () => NeonFunctionalColor;
+                                default: null;
+                            };
+                            inverse: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            disabled: {
+                                type: BooleanConstructor;
+                                default: boolean; /**
+                                 * Disable date picker
+                                 */
+                            }; /**
+                             * Disable date picker
+                             */
+                        }>> & Readonly<{}>, {
+                            disabled: boolean;
+                            color: NeonFunctionalColor;
+                            inverse: boolean;
+                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                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;
+                    };
+                    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>;
+                    focus: () => void;
+                    click: () => void;
+                    onFocus: () => void;
+                    onBlur: () => void;
+                    iconClicked: ($event: Event) => void;
+                    changeValue: (event: Event) => void;
+                    onKeyDown: (event: KeyboardEvent) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "icon-click")[], "update:modelValue" | "focus" | "blur" | "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;
+                    };
+                    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;
+                }>, {
+                    disabled: boolean;
+                    icon: string;
+                    type: import("../../../neon").NeonInputType;
+                    debounce: number;
+                    size: NeonSize;
+                    color: NeonFunctionalColor;
+                    id: string;
+                    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;
+                }, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: 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;
+                    };
+                }>, {
+                    /**
+                     * The selected date. A date string in the
+                     * <a href="https://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO 8601</a> format.
+                     */
+                    remove: (key: string) => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "update:modelValue")[], "close" | "update:modelValue", 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;
+                }>, {
+                    disabled: boolean;
+                    size: NeonSize;
+                    color: NeonFunctionalColor;
+                }, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>, {
+                        attrs: {
+                            [x: string]: unknown;
+                        };
+                        icon: import("vue").ComputedRef<string>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true; /**
+                             * Id for the date picker button.
+                             */
+                        }; /**
+                         * Id for the date picker button.
+                         */
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean; /**
+                             * Disable date picker
+                             */
+                        }; /**
+                         * Disable date picker
+                         */
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: NeonFunctionalColor;
+                        inverse: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true; /**
+                     * Id for the date picker button.
+                     */
+                }; /**
+                 * Id for the date picker button.
+                 */
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean; /**
+                     * Disable date picker
+                     */
+                }; /**
+                 * Disable date picker
+                 */
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                icon: import("vue").ComputedRef<string>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true; /**
+                     * Id for the date picker button.
+                     */
+                }; /**
+                 * Id for the date picker button.
+                 */
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean; /**
+                     * Disable date picker
+                     */
+                }; /**
+                 * Disable date picker
+                 */
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            href: {
+                type: StringConstructor;
+                default: null;
+            };
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            size: {
+                type: () => import("../../../neon").NeonButtonSize;
+                default: import("../../../neon").NeonButtonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            alternateColor: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            iconAriaLabel: {
+                type: StringConstructor;
+            };
+            iconPosition: {
+                type: () => import("../../../neon").NeonHorizontalPosition;
+                default: import("../../../neon").NeonHorizontalPosition;
+            };
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle;
+            };
+            buttonType: {
+                type: () => import("../../../neon").NeonButtonType;
+                default: import("../../../neon").NeonButtonType; /**
+                 * The placement of the dropdown calendar popup.
+                 */
+            };
+            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;
+            };
+            buttonStyle: {
+                type: () => import("../../../neon").NeonButtonStyle;
+                default: import("../../../neon").NeonButtonStyle;
+            };
+            buttonType: {
+                type: () => import("../../../neon").NeonButtonType;
+                default: import("../../../neon").NeonButtonType; /**
+                 * The placement of the dropdown calendar popup.
+                 */
+            };
+            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;
@@ -1315,13 +2898,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             size: import("../../../neon").NeonButtonSize;
             color: NeonFunctionalColor;
             inverse: boolean;
-            circular: boolean;
             alternateColor: NeonFunctionalColor;
             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;