npm - @aotearoan/neon - Versions diffs - 23.0.2 → 23.2.0 - Mend

@aotearoan/neon 23.0.2 → 23.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/dist/src/components/layout/page/NeonPage.d.ts CHANGED Viewed

@@ -25,5 +25,1437 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     };
 }>> & Readonly<{}>, {
     pageAlign: NeonPageAlignment;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {
+    NeonAlert: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        dismissible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        duration: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>, {
+        topLeft: import("vue").Ref<{
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[], import("../../../neon").NeonAlertModel[] | {
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[]>;
+        topRight: import("vue").Ref<{
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[], import("../../../neon").NeonAlertModel[] | {
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[]>;
+        bottomLeft: import("vue").Ref<{
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[], import("../../../neon").NeonAlertModel[] | {
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[]>;
+        bottomRight: import("vue").Ref<{
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[], import("../../../neon").NeonAlertModel[] | {
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title?: string | undefined;
+            message?: string | undefined;
+            showIcon?: boolean | undefined;
+            placement?: import("../../../neon").NeonAlertPlacement | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+            primaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+            secondaryAction?: {
+                label: string;
+                callback: () => void;
+            } | undefined;
+        }[]>;
+        top: import("vue").Ref<{
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title: string;
+            placement?: import("../../../neon").NeonVerticalPosition | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+        }[], import("../../../neon").NeonToastModel[] | {
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title: string;
+            placement?: import("../../../neon").NeonVerticalPosition | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+        }[]>;
+        bottom: import("vue").Ref<{
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title: string;
+            placement?: import("../../../neon").NeonVerticalPosition | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+        }[], import("../../../neon").NeonToastModel[] | {
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            title: string;
+            placement?: import("../../../neon").NeonVerticalPosition | undefined;
+            duration?: number | undefined;
+            dismissible?: boolean | undefined;
+        }[]>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        dismissible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        duration: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{}>, {
+        dismissible: boolean;
+        duration: number;
+    }, {}, {
+        NeonAlertContainer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            modelValue: {
+                type: () => import("../../../neon").NeonAlertModel[];
+                required: true;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonAlertPlacement;
+                required: true;
+            };
+        }>, {
+            closeMessage: (id: number) => void;
+            icon: (level: import("../../../neon").NeonAlertLevel) => "info-circle" | "check-circle" | "exclamation-circle" | "times-circle";
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            modelValue: {
+                type: () => import("../../../neon").NeonAlertModel[];
+                required: true;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonAlertPlacement;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: import("../../../neon").NeonFunctionalColor;
+                id: string;
+                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;
+                };
+            }>, {
+                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 | "">;
+                exactRoute: import("vue").ComputedRef<boolean | "">;
+                onClick: () => void;
+                onSpace: () => Promise<void>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                href: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                noStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                outlineStyle: {
+                    type: () => import("../../../neon").NeonOutlineStyle;
+                    default: import("../../../neon").NeonOutlineStyle;
+                };
+                externalIndicator: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+            }>, {
+                href: string;
+                noStyle: boolean;
+                outlineStyle: import("../../../neon").NeonOutlineStyle;
+                externalIndicator: boolean;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: import("../../../neon").NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonToastContainer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            modelValue: {
+                type: () => import("../../../neon").NeonToastModel[];
+                required: true;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonVerticalPosition;
+                required: true;
+            };
+        }>, {
+            closeMessage: (id: number) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            modelValue: {
+                type: () => import("../../../neon").NeonToastModel[];
+                required: true;
+            };
+            placement: {
+                type: () => import("../../../neon").NeonVerticalPosition;
+                required: true;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: import("../../../neon").NeonFunctionalColor;
+                id: string;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    NeonBanner: import("vue").DefineComponent<{}, {
+        onAction: () => void;
+        messages: import("vue").Ref<{
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            message: string;
+            action: {
+                label: string;
+                callback: () => void;
+            };
+        }[], import("../../../neon").NeonBannerModel[] | {
+            id: number;
+            level: import("../../../neon").NeonAlertLevel;
+            key?: string | undefined;
+            message: string;
+            action: {
+                label: string;
+                callback: () => void;
+            };
+        }[]>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+        NeonNote: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+            };
+            color: {
+                type: () => import("../../../neon").NeonFunctionalColor;
+                default: import("../../../neon").NeonFunctionalColor;
+            };
+            closable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            ariaLabelCloseNote: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {
+            iconName: import("vue").ComputedRef<"info-circle" | "check-circle" | "exclamation-circle" | "times-circle" | undefined>;
+            slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            closeNote: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "close-note"[], "close-note", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+            };
+            color: {
+                type: () => import("../../../neon").NeonFunctionalColor;
+                default: import("../../../neon").NeonFunctionalColor;
+            };
+            closable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            icon: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            ariaLabelCloseNote: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{
+            "onClose-note"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            icon: boolean;
+            color: import("../../../neon").NeonFunctionalColor;
+            closable: boolean;
+            ariaLabelCloseNote: 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: () => import("../../../neon").NeonFunctionalColor;
+                    default: import("../../../neon").NeonFunctionalColor;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                alternateColor: {
+                    type: () => import("../../../neon").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 | "" | import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                    default: import("../../../neon").NeonFunctionalColor;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                alternateColor: {
+                    type: () => import("../../../neon").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: import("../../../neon").NeonFunctionalColor;
+                inverse: boolean;
+                alternateColor: import("../../../neon").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; /**
+                         * Page alignment: either left aligned or center aligned.
+                         */
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    color: {
+                        type: () => import("../../../neon").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; /**
+                         * Page alignment: either left aligned or center aligned.
+                         */
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    color: {
+                        type: () => import("../../../neon").NeonFunctionalColor;
+                        default: null;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    expanded: boolean;
+                    color: import("../../../neon").NeonFunctionalColor;
+                    inverse: 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: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: import("../../../neon").NeonFunctionalColor;
+                    id: string;
+                    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;
+                    };
+                }>, {
+                    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 | "">;
+                    exactRoute: import("vue").ComputedRef<boolean | "">;
+                    onClick: () => void;
+                    onSpace: () => Promise<void>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    href: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    noStyle: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    outlineStyle: {
+                        type: () => import("../../../neon").NeonOutlineStyle;
+                        default: import("../../../neon").NeonOutlineStyle;
+                    };
+                    externalIndicator: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{
+                    onClick?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    href: string;
+                    noStyle: boolean;
+                    outlineStyle: import("../../../neon").NeonOutlineStyle;
+                    externalIndicator: boolean;
+                }, {}, {
+                    NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                        name: {
+                            type: StringConstructor;
+                            required: true;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: null;
+                        };
+                        color: {
+                            type: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                            default: null;
+                        };
+                        inverse: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & Readonly<{}>, {
+                        disabled: boolean;
+                        color: import("../../../neon").NeonFunctionalColor;
+                        id: string;
+                        inverse: boolean;
+                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                name: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                color: {
+                    type: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: import("../../../neon").NeonFunctionalColor;
+                id: string;
+                inverse: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonInline: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                gap: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: () => import("../../../neon").NeonSize;
+                };
+                breakpoint: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: () => import("../../../neon").NeonResponsive;
+                };
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                gap: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: () => import("../../../neon").NeonSize;
+                };
+                breakpoint: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: () => import("../../../neon").NeonResponsive;
+                };
+            }>> & Readonly<{}>, {
+                breakpoint: import("../../../neon").NeonSize;
+                gap: import("../../../neon").NeonSize;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            NeonStack: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                gap: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: () => import("../../../neon").NeonSize;
+                };
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                gap: {
+                    type: () => import("../../../neon").NeonSize;
+                    default: () => import("../../../neon").NeonSize;
+                };
+            }>> & Readonly<{}>, {
+                gap: import("../../../neon").NeonSize;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            href: {
+                type: StringConstructor;
+                default: null;
+            };
+            label: {
+                type: StringConstructor;
+                default: null;
+            };
+            size: {
+                type: () => import("../../../neon").NeonButtonSize;
+                default: import("../../../neon").NeonButtonSize;
+            };
+            color: {
+                type: () => import("../../../neon").NeonFunctionalColor;
+                default: import("../../../neon").NeonFunctionalColor;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            alternateColor: {
+                type: () => import("../../../neon").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 | "" | import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                default: import("../../../neon").NeonFunctionalColor;
+            };
+            inverse: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            alternateColor: {
+                type: () => import("../../../neon").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: import("../../../neon").NeonFunctionalColor;
+            inverse: boolean;
+            alternateColor: import("../../../neon").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; /**
+                     * Page alignment: either left aligned or center aligned.
+                     */
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                color: {
+                    type: () => import("../../../neon").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; /**
+                     * Page alignment: either left aligned or center aligned.
+                     */
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                color: {
+                    type: () => import("../../../neon").NeonFunctionalColor;
+                    default: null;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                expanded: boolean;
+                color: import("../../../neon").NeonFunctionalColor;
+                inverse: 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: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                    default: null;
+                };
+                inverse: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                disabled: boolean;
+                color: import("../../../neon").NeonFunctionalColor;
+                id: string;
+                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;
+                };
+            }>, {
+                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 | "">;
+                exactRoute: import("vue").ComputedRef<boolean | "">;
+                onClick: () => void;
+                onSpace: () => Promise<void>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                href: {
+                    type: StringConstructor;
+                    default: null;
+                };
+                noStyle: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                outlineStyle: {
+                    type: () => import("../../../neon").NeonOutlineStyle;
+                    default: import("../../../neon").NeonOutlineStyle;
+                };
+                externalIndicator: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+            }>, {
+                href: string;
+                noStyle: boolean;
+                outlineStyle: import("../../../neon").NeonOutlineStyle;
+                externalIndicator: boolean;
+            }, {}, {
+                NeonIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    name: {
+                        type: StringConstructor;
+                        required: true;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: null;
+                    };
+                    color: {
+                        type: () => import("../../../neon").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: () => import("../../../neon").NeonFunctionalColor;
+                        default: null;
+                    };
+                    inverse: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    disabled: boolean;
+                    color: import("../../../neon").NeonFunctionalColor;
+                    id: string;
+                    inverse: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;