@aotearoan/neon 28.5.0 → 28.6.0

package/dist/src/components/presentation/avatar/NeonAvatar.d.ts

@@ -0,0 +1,1806 @@
+import { NeonFunctionalColor } from '@/model/common/color/NeonFunctionalColor';
+import { NeonBadgeSize } from '@/model/presentation/badge/NeonBadgeSize';
+/**
+ * An avatar component that displays either an image or initials in a circular badge.
+ * When displaying initials, it generates a consistent color based on the provided name.
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /**
+     * The URL of the avatar image to display
+     */
+    imageUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * The name to generate initials from (takes first letter of first name and first letter of last name)
+     */
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * The size of the avatar
+     */
+    size: {
+        type: () => NeonBadgeSize;
+        default: NeonBadgeSize;
+    };
+    /**
+     * If true, render the avatar as a circle, if false render as square
+     */
+    circular: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * The color of the avatar
+     */
+    color: {
+        type: () => NeonFunctionalColor;
+        default: undefined;
+    };
+}>, {
+    initials: import("vue").ComputedRef<string>;
+    avatarColor: import("vue").ComputedRef<NeonFunctionalColor>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * The URL of the avatar image to display
+     */
+    imageUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * The name to generate initials from (takes first letter of first name and first letter of last name)
+     */
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /**
+     * The size of the avatar
+     */
+    size: {
+        type: () => NeonBadgeSize;
+        default: NeonBadgeSize;
+    };
+    /**
+     * If true, render the avatar as a circle, if false render as square
+     */
+    circular: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * The color of the avatar
+     */
+    color: {
+        type: () => NeonFunctionalColor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    name: string;
+    color: NeonFunctionalColor;
+    size: NeonBadgeSize;
+    circular: boolean;
+    imageUrl: string;
+}, {}, {
+    NeonBadge: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        label: {
+            type: StringConstructor;
+            default: null;
+        };
+        image: {
+            type: StringConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        circular: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonBadgeSize;
+            default: NeonBadgeSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        editable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        accept: {
+            type: StringConstructor;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        jazziconId: {
+            type: StringConstructor;
+            default: null;
+        };
+        imageAlt: {
+            type: StringConstructor;
+            default: string;
+        };
+        editButtonTitle: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, {
+        emit: (event: "change-image", ...args: any[]) => void;
+        svg: import("vue").ComputedRef<string | null>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change-image"[], "change-image", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        label: {
+            type: StringConstructor;
+            default: null;
+        };
+        image: {
+            type: StringConstructor;
+            default: null;
+        };
+        icon: {
+            type: StringConstructor;
+            default: null;
+        };
+        circular: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: {
+            type: () => NeonBadgeSize;
+            default: NeonBadgeSize;
+        };
+        color: {
+            type: () => NeonFunctionalColor;
+            default: NeonFunctionalColor;
+        };
+        alternateColor: {
+            type: () => NeonFunctionalColor;
+            default: null;
+        };
+        editable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        accept: {
+            type: StringConstructor;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        jazziconId: {
+            type: StringConstructor;
+            default: null;
+        };
+        imageAlt: {
+            type: StringConstructor;
+            default: string;
+        };
+        editButtonTitle: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{
+        "onChange-image"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        color: NeonFunctionalColor;
+        icon: string;
+        label: string;
+        disabled: boolean;
+        image: string;
+        size: NeonBadgeSize;
+        alternateColor: NeonFunctionalColor;
+        circular: boolean;
+        accept: string;
+        editable: boolean;
+        jazziconId: string;
+        imageAlt: string;
+        editButtonTitle: string;
+    }, {}, {
+        NeonFile: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            directUpload: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            accept: {
+                type: StringConstructor;
+                default: null;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            size: {
+                type: () => import("@/neon").NeonSize;
+                default: import("@/neon").NeonSize;
+            };
+            state: {
+                type: () => import("@/neon").NeonState;
+                default: import("@/neon").NeonState;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            buttonStyle: {
+                type: () => import("@/neon").NeonButtonStyle;
+                default: import("@/neon").NeonButtonStyle;
+            };
+            circular: {
+                type: BooleanConstructor;
+                default: null;
+            };
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            title: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            fileInput: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                modelValue: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                type: {
+                    type: () => import("@/neon").NeonInputType;
+                    default: import("@/neon").NeonInputType;
+                };
+                placeholder: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => import("@/neon").NeonSize;
+                    default: import("@/neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                inputmode: {
+                    type: () => import("@/neon").NeonInputMode;
+                    default: import("@/neon").NeonInputMode;
+                };
+                autocomplete: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                state: {
+                    type: () => import("@/neon").NeonState;
+                    default: import("@/neon").NeonState;
+                };
+                rows: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconReadonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                hideIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                tabindex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateHighlight: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxlength: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                maxlengthLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                debounce: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onFocus?: ((...args: any[]) => any) | undefined;
+                onBlur?: ((...args: any[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                "onIcon-click"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                focused: import("vue").Ref<boolean, boolean>;
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                iconName: import("vue").ComputedRef<string | undefined>;
+                iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                computedPlaceholder: import("vue").ComputedRef<string>;
+                counterLabel: import("vue").ComputedRef<string | null>;
+                focus: () => void;
+                click: () => void;
+                onFocus: () => void;
+                onBlur: () => void;
+                iconClicked: ($event: Event) => void;
+                changeValue: (event: InputEvent) => void;
+                onKeyDown: (event: KeyboardEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], import("vue").PublicProps, {
+                color: NeonFunctionalColor;
+                icon: string;
+                type: import("@/neon").NeonInputType;
+                id: string;
+                disabled: boolean;
+                size: import("@/neon").NeonSize;
+                placeholder: string;
+                tabindex: number;
+                inputmode: import("@/neon").NeonInputMode;
+                modelValue: string;
+                state: import("@/neon").NeonState;
+                autocomplete: string;
+                rows: number;
+                iconReadonly: boolean;
+                hideIcon: boolean;
+                stateHighlight: boolean;
+                stateIcon: boolean;
+                maxlength: number;
+                maxlengthLabel: string;
+                debounce: number;
+            }, true, {}, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    icon: import("vue").ComputedRef<string | undefined>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    color: NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                modelValue: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                type: {
+                    type: () => import("@/neon").NeonInputType;
+                    default: import("@/neon").NeonInputType;
+                };
+                placeholder: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => import("@/neon").NeonSize;
+                    default: import("@/neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                inputmode: {
+                    type: () => import("@/neon").NeonInputMode;
+                    default: import("@/neon").NeonInputMode;
+                };
+                autocomplete: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                state: {
+                    type: () => import("@/neon").NeonState;
+                    default: import("@/neon").NeonState;
+                };
+                rows: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconReadonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                hideIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                tabindex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateHighlight: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxlength: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                maxlengthLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                debounce: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onFocus?: ((...args: any[]) => any) | undefined;
+                onBlur?: ((...args: any[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                "onIcon-click"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                focused: import("vue").Ref<boolean, boolean>;
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                iconName: import("vue").ComputedRef<string | undefined>;
+                iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                computedPlaceholder: import("vue").ComputedRef<string>;
+                counterLabel: import("vue").ComputedRef<string | null>;
+                focus: () => void;
+                click: () => void;
+                onFocus: () => void;
+                onBlur: () => void;
+                iconClicked: ($event: Event) => void;
+                changeValue: (event: InputEvent) => void;
+                onKeyDown: (event: KeyboardEvent) => void;
+            }, {}, {}, {}, {
+                color: NeonFunctionalColor;
+                icon: string;
+                type: import("@/neon").NeonInputType;
+                id: string;
+                disabled: boolean;
+                size: import("@/neon").NeonSize;
+                placeholder: string;
+                tabindex: number;
+                inputmode: import("@/neon").NeonInputMode;
+                modelValue: string;
+                state: import("@/neon").NeonState;
+                autocomplete: string;
+                rows: number;
+                iconReadonly: boolean;
+                hideIcon: boolean;
+                stateHighlight: boolean;
+                stateIcon: boolean;
+                maxlength: number;
+                maxlengthLabel: string;
+                debounce: number;
+            }> | null, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                modelValue: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                type: {
+                    type: () => import("@/neon").NeonInputType;
+                    default: import("@/neon").NeonInputType;
+                };
+                placeholder: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => import("@/neon").NeonSize;
+                    default: import("@/neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                inputmode: {
+                    type: () => import("@/neon").NeonInputMode;
+                    default: import("@/neon").NeonInputMode;
+                };
+                autocomplete: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                state: {
+                    type: () => import("@/neon").NeonState;
+                    default: import("@/neon").NeonState;
+                };
+                rows: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconReadonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                hideIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                tabindex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateHighlight: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxlength: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                maxlengthLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                debounce: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onFocus?: ((...args: any[]) => any) | undefined;
+                onBlur?: ((...args: any[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                "onIcon-click"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                focused: import("vue").Ref<boolean, boolean>;
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                iconName: import("vue").ComputedRef<string | undefined>;
+                iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                computedPlaceholder: import("vue").ComputedRef<string>;
+                counterLabel: import("vue").ComputedRef<string | null>;
+                focus: () => void;
+                click: () => void;
+                onFocus: () => void;
+                onBlur: () => void;
+                iconClicked: ($event: Event) => void;
+                changeValue: (event: InputEvent) => void;
+                onKeyDown: (event: KeyboardEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], import("vue").PublicProps, {
+                color: NeonFunctionalColor;
+                icon: string;
+                type: import("@/neon").NeonInputType;
+                id: string;
+                disabled: boolean;
+                size: import("@/neon").NeonSize;
+                placeholder: string;
+                tabindex: number;
+                inputmode: import("@/neon").NeonInputMode;
+                modelValue: string;
+                state: import("@/neon").NeonState;
+                autocomplete: string;
+                rows: number;
+                iconReadonly: boolean;
+                hideIcon: boolean;
+                stateHighlight: boolean;
+                stateIcon: boolean;
+                maxlength: number;
+                maxlengthLabel: string;
+                debounce: number;
+            }, true, {}, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    icon: import("vue").ComputedRef<string | undefined>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    color: NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                modelValue: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                type: {
+                    type: () => import("@/neon").NeonInputType;
+                    default: import("@/neon").NeonInputType;
+                };
+                placeholder: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => import("@/neon").NeonSize;
+                    default: import("@/neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                inputmode: {
+                    type: () => import("@/neon").NeonInputMode;
+                    default: import("@/neon").NeonInputMode;
+                };
+                autocomplete: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                state: {
+                    type: () => import("@/neon").NeonState;
+                    default: import("@/neon").NeonState;
+                };
+                rows: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconReadonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                hideIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                tabindex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateHighlight: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxlength: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                maxlengthLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                debounce: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onFocus?: ((...args: any[]) => any) | undefined;
+                onBlur?: ((...args: any[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                "onIcon-click"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                focused: import("vue").Ref<boolean, boolean>;
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                iconName: import("vue").ComputedRef<string | undefined>;
+                iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                computedPlaceholder: import("vue").ComputedRef<string>;
+                counterLabel: import("vue").ComputedRef<string | null>;
+                focus: () => void;
+                click: () => void;
+                onFocus: () => void;
+                onBlur: () => void;
+                iconClicked: ($event: Event) => void;
+                changeValue: (event: InputEvent) => void;
+                onKeyDown: (event: KeyboardEvent) => void;
+            }, {}, {}, {}, {
+                color: NeonFunctionalColor;
+                icon: string;
+                type: import("@/neon").NeonInputType;
+                id: string;
+                disabled: boolean;
+                size: import("@/neon").NeonSize;
+                placeholder: string;
+                tabindex: number;
+                inputmode: import("@/neon").NeonInputMode;
+                modelValue: string;
+                state: import("@/neon").NeonState;
+                autocomplete: string;
+                rows: number;
+                iconReadonly: boolean;
+                hideIcon: boolean;
+                stateHighlight: boolean;
+                stateIcon: boolean;
+                maxlength: number;
+                maxlengthLabel: string;
+                debounce: number;
+            }> | null>;
+            files: import("vue").Ref<{
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            }[], File[] | {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            }[]>;
+            fileList: import("vue").ComputedRef<{
+                key: string;
+                label: string;
+            }[]>;
+            fileInputModel: import("vue").Ref<string, string>;
+            remove: (filename: string) => void;
+            clearAll: () => void;
+            openFileDialog: () => void;
+            onInput: (event: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            directUpload: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            accept: {
+                type: StringConstructor;
+                default: null;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            size: {
+                type: () => import("@/neon").NeonSize;
+                default: import("@/neon").NeonSize;
+            };
+            state: {
+                type: () => import("@/neon").NeonState;
+                default: import("@/neon").NeonState;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: NeonFunctionalColor;
+            };
+            buttonStyle: {
+                type: () => import("@/neon").NeonButtonStyle;
+                default: import("@/neon").NeonButtonStyle;
+            };
+            circular: {
+                type: BooleanConstructor;
+                default: null;
+            };
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            icon: {
+                type: StringConstructor;
+                default: null;
+            };
+            title: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            color: NeonFunctionalColor;
+            icon: string;
+            label: string;
+            id: string;
+            disabled: boolean;
+            title: string;
+            size: import("@/neon").NeonSize;
+            buttonStyle: import("@/neon").NeonButtonStyle;
+            state: import("@/neon").NeonState;
+            circular: boolean;
+            directUpload: boolean;
+            multiple: boolean;
+            accept: string;
+        }, {}, {
+            NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                href: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                label: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => import("@/neon").NeonButtonSize;
+                    default: import("@/neon").NeonButtonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                alternateColor: {
+                    type: () => NeonFunctionalColor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconAriaLabel: {
+                    type: StringConstructor;
+                };
+                iconPosition: {
+                    type: () => import("@/neon").NeonHorizontalPosition;
+                    default: import("@/neon").NeonHorizontalPosition;
+                };
+                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;
+            }>, {
+                color: NeonFunctionalColor;
+                icon: string;
+                label: string;
+                inverse: boolean;
+                disabled: boolean;
+                href: string;
+                size: import("@/neon").NeonButtonSize;
+                alternateColor: NeonFunctionalColor;
+                outline: boolean;
+                iconPosition: import("@/neon").NeonHorizontalPosition;
+                buttonStyle: import("@/neon").NeonButtonStyle;
+                buttonType: import("@/neon").NeonButtonType;
+                state: import("@/neon").NeonState;
+                transparent: boolean;
+                circular: boolean;
+                fullWidth: boolean;
+                indicator: boolean;
+                indicatorExpanded: boolean;
+            }, {}, {
+                NeonExpansionIndicator: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    expanded: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    expanded: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                }>> & Readonly<{}>, {
+                    color: NeonFunctionalColor;
+                    inverse: boolean;
+                    disabled: boolean;
+                    expanded: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    icon: import("vue").ComputedRef<string | undefined>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    color: NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    href: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    noStyle: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    outlineStyle: {
+                        type: () => import("@/neon").NeonOutlineStyle;
+                        default: import("@/neon").NeonOutlineStyle;
+                    };
+                    externalIndicator: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    neonLink: import("vue").Ref<HTMLAnchorElement | null, HTMLAnchorElement | null>;
+                    routerUrl: import("vue").ComputedRef<string | undefined>;
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    activeRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+                    exactRoute: import("vue").ComputedRef<boolean | "" | undefined>;
+                    onClick: () => void;
+                    onSpace: () => Promise<void>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    href: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    noStyle: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    outlineStyle: {
+                        type: () => import("@/neon").NeonOutlineStyle;
+                        default: import("@/neon").NeonOutlineStyle;
+                    };
+                    externalIndicator: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{
+                    onClick?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    href: string;
+                    noStyle: boolean;
+                    outlineStyle: import("@/neon").NeonOutlineStyle;
+                    externalIndicator: boolean;
+                }, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>, {
+                        sanitizedAttributes: import("vue").ComputedRef<{
+                            [x: string]: unknown;
+                        }>;
+                        icon: import("vue").ComputedRef<string | undefined>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        color: NeonFunctionalColor;
+                        id: string;
+                        inverse: boolean;
+                        disabled: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>; /**
+             * The size of the avatar
+             */
+            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;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                inputmode: {
+                    type: () => import("@/neon").NeonInputMode;
+                    default: import("@/neon").NeonInputMode;
+                };
+                autocomplete: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                state: {
+                    type: () => import("@/neon").NeonState;
+                    default: import("@/neon").NeonState;
+                };
+                rows: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconReadonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                hideIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                tabindex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateHighlight: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxlength: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                maxlengthLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                debounce: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+            }>, {
+                neonInput: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+                focused: import("vue").Ref<boolean, boolean>;
+                sanitizedAttributes: import("vue").ComputedRef<{
+                    [x: string]: unknown;
+                }>;
+                iconVisible: import("vue").ComputedRef<string | boolean | undefined>;
+                iconName: import("vue").ComputedRef<string | undefined>;
+                iconColor: import("vue").ComputedRef<NeonFunctionalColor>;
+                computedPlaceholder: import("vue").ComputedRef<string>;
+                counterLabel: import("vue").ComputedRef<string | null>;
+                focus: () => void;
+                click: () => void;
+                onFocus: () => void;
+                onBlur: () => void;
+                iconClicked: ($event: Event) => void;
+                changeValue: (event: InputEvent) => void;
+                onKeyDown: (event: KeyboardEvent) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "blur" | "focus" | "icon-click")[], "update:modelValue" | "blur" | "focus" | "icon-click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                modelValue: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                type: {
+                    type: () => import("@/neon").NeonInputType;
+                    default: import("@/neon").NeonInputType;
+                };
+                placeholder: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                size: {
+                    type: () => import("@/neon").NeonSize;
+                    default: import("@/neon").NeonSize;
+                };
+                color: {
+                    type: () => NeonFunctionalColor;
+                    default: NeonFunctionalColor;
+                };
+                inputmode: {
+                    type: () => import("@/neon").NeonInputMode;
+                    default: import("@/neon").NeonInputMode;
+                };
+                autocomplete: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                state: {
+                    type: () => import("@/neon").NeonState;
+                    default: import("@/neon").NeonState;
+                };
+                rows: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                icon: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                iconReadonly: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                hideIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                tabindex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateHighlight: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                stateIcon: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                maxlength: {
+                    type: NumberConstructor;
+                    default: null;
+                };
+                maxlengthLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                debounce: {
+                    type: NumberConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onFocus?: ((...args: any[]) => any) | undefined;
+                onBlur?: ((...args: any[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+                "onIcon-click"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                color: NeonFunctionalColor;
+                icon: string;
+                type: import("@/neon").NeonInputType;
+                id: string;
+                disabled: boolean;
+                size: import("@/neon").NeonSize;
+                placeholder: string;
+                tabindex: number;
+                inputmode: import("@/neon").NeonInputMode;
+                modelValue: string;
+                state: import("@/neon").NeonState;
+                autocomplete: string;
+                rows: number;
+                iconReadonly: boolean;
+                hideIcon: boolean;
+                stateHighlight: boolean;
+                stateIcon: boolean;
+                maxlength: number;
+                maxlengthLabel: string;
+                debounce: number;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    icon: import("vue").ComputedRef<string | undefined>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    color: NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                modelValue: {
+                    type: () => import("@/neon").NeonListItem[];
+                    required: true;
+                };
+                size: {
+                    type: () => 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, ("update:modelValue" | "close")[], "update:modelValue" | "close", 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;
+            }>, {
+                color: NeonFunctionalColor;
+                disabled: boolean;
+                size: import("@/neon").NeonSize;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    sanitizedAttributes: import("vue").ComputedRef<{
+                        [x: string]: unknown;
+                    }>;
+                    icon: import("vue").ComputedRef<string | undefined>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    color: NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>, {
+            sanitizedAttributes: import("vue").ComputedRef<{
+                [x: string]: unknown;
+            }>;
+            icon: import("vue").ComputedRef<string | undefined>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            id: {
+                type: StringConstructor;
+                default: null;
+            };
+            color: {
+                type: () => NeonFunctionalColor;
+                default: null;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{}>, {
+            color: NeonFunctionalColor;
+            id: string;
+            inverse: boolean;
+            disabled: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;