@aotearoan/neon 22.1.2 → 22.3.0

package/dist/src/components/presentation/badge/NeonBadge.d.ts

@@ -53,6 +53,21 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: () => NeonFunctionalColor;
         default: null;
     };
+    /**
+     * Allow editing of the image. This will place an image file lookup button on top of the image allowing the user to
+     * choose a new image to upload.
+     */
+    editable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Accept string for the filetype to support selecting.
+     */
+    accept: {
+        type: StringConstructor;
+        default: string;
+    };
     /**
      * Display the badge in the disable style
      */
@@ -74,9 +89,17 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: StringConstructor;
         default: string;
     };
+    /**
+     * Title for the file upload button in edit mode.
+     */
+    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<{
     /**
      * The two character <em>initials</em> to display on the badge.
      */
@@ -126,6 +149,21 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: () => NeonFunctionalColor;
         default: null;
     };
+    /**
+     * Allow editing of the image. This will place an image file lookup button on top of the image allowing the user to
+     * choose a new image to upload.
+     */
+    editable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Accept string for the filetype to support selecting.
+     */
+    accept: {
+        type: StringConstructor;
+        default: string;
+    };
     /**
      * Display the badge in the disable style
      */
@@ -147,18 +185,1478 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: StringConstructor;
         default: string;
     };
-}>> & Readonly<{}>, {
+    /**
+     * Title for the file upload button in edit mode.
+     */
+    editButtonTitle: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onChange-image"?: ((...args: any[]) => any) | undefined;
+}>, {
     disabled: boolean;
     label: string;
     icon: string;
     size: NeonBadgeSize;
     color: NeonFunctionalColor;
     image: string;
-    circular: boolean;
     alternateColor: NeonFunctionalColor;
+    circular: boolean;
+    accept: string;
+    editable: boolean;
     jazziconId: string;
     imageAlt: string;
+    editButtonTitle: string;
 }, {}, {
+    NeonFile: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        directUpload: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        accept: {
+            type: StringConstructor;
+            default: null;
+        };
+        id: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => import("../../../neon").NeonSize;
+            default: import("../../../neon").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;
+        };
+    }>, {
+        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: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize; /**
+                 * If true, render the badge as a circle, instead of a square.
+                 */
+            };
+            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: import("../../../neon").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;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                icon: import("vue").ComputedRef<string>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        } & 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: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize; /**
+                 * If true, render the badge as a circle, instead of a square.
+                 */
+            };
+            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: import("../../../neon").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: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize; /**
+                 * If true, render the badge as a circle, instead of a square.
+                 */
+            };
+            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: import("../../../neon").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;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                icon: import("vue").ComputedRef<string>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        } & 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: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize; /**
+                 * If true, render the badge as a circle, instead of a square.
+                 */
+            };
+            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: import("../../../neon").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;
+            label: string;
+        }[]>;
+        fileInputModel: import("vue").Ref<string, string>;
+        remove: (filename: string) => void;
+        clearAll: () => void;
+        openFileDialog: () => void;
+        onInput: (event: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        directUpload: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        accept: {
+            type: StringConstructor;
+            default: null;
+        };
+        id: {
+            type: StringConstructor;
+            default: null;
+        };
+        size: {
+            type: () => import("../../../neon").NeonSize;
+            default: import("../../../neon").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: import("../../../neon").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;
+            };
+            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;
+            };
+            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;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                icon: import("vue").ComputedRef<string>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                href: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                noStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                outlineStyle: {
+                    type: () => import("../../../neon").NeonOutlineStyle;
+                    default: import("../../../neon").NeonOutlineStyle;
+                };
+                externalIndicator: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                routerUrl: import("vue").ComputedRef<string | undefined>;
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                activeRoute: import("vue").ComputedRef<boolean | "">;
+                exactRoute: import("vue").ComputedRef<boolean | "">;
+                onClick: () => void;
+                onSpace: () => Promise<void>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                href: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                noStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                outlineStyle: {
+                    type: () => import("../../../neon").NeonOutlineStyle;
+                    default: import("../../../neon").NeonOutlineStyle;
+                };
+                externalIndicator: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+            }>, {
+                href: string;
+                noStyle: boolean;
+                outlineStyle: import("../../../neon").NeonOutlineStyle;
+                externalIndicator: boolean;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    icon: import("vue").ComputedRef<string>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: NeonFunctionalColor;
+                    inverse: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        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: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize; /**
+                 * If true, render the badge as a circle, instead of a square.
+                 */
+            };
+            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: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize; /**
+                 * If true, render the badge as a circle, instead of a square.
+                 */
+            };
+            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: import("../../../neon").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;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                icon: import("vue").ComputedRef<string>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            modelValue: {
+                type: () => import("../../../neon").NeonListItem[];
+                required: true;
+            };
+            size: {
+                type: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").NeonSize;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            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: () => import("../../../neon").NeonSize;
+                default: import("../../../neon").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: import("../../../neon").NeonSize;
+            color: NeonFunctionalColor;
+        }, {}, {
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                icon: import("vue").ComputedRef<string>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: NeonFunctionalColor;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
         name: {
             type: StringConstructor;