npm - @aotearoan/neon - Versions diffs - 28.0.2 → 28.1.0 - Mend

@aotearoan/neon 28.0.2 → 28.1.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 (81) hide show

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

@@ -218,6 +218,25 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             duration?: number | undefined;
             dismissible?: boolean | undefined;
         }[]>;
+        dialog: import("vue").Ref<{
+            color?: import("../../../neon").NeonFunctionalColor | undefined;
+            alternateColor?: import("../../../neon").NeonFunctionalColor | undefined;
+            cancelLabel?: string | undefined;
+            confirmLabel?: string | undefined;
+            title: string;
+            question: string;
+            open?: boolean | undefined;
+            opaque?: boolean | undefined;
+        }, import("../../../neon").NeonDialogMessage | {
+            color?: import("../../../neon").NeonFunctionalColor | undefined;
+            alternateColor?: import("../../../neon").NeonFunctionalColor | undefined;
+            cancelLabel?: string | undefined;
+            confirmLabel?: string | undefined;
+            title: string;
+            question: string;
+            open?: boolean | undefined;
+            opaque?: boolean | undefined;
+        }>;
     }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
         dismissible: {
             type: BooleanConstructor;
@@ -335,8 +354,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 sanitizedAttributes: import("vue").ComputedRef<{
                     [x: string]: unknown;
                 }>;
-                activeRoute: import("vue").ComputedRef<boolean | "">;
-                exactRoute: import("vue").ComputedRef<boolean | "">;
+                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<{
@@ -494,6 +513,1030 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 disabled: boolean;
             }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
         }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        NeonDialogContainer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            modelValue: {
+                type: () => import("../../../neon").NeonDialogMessage;
+            };
+        }>, {
+            onButtonClick: (choice: boolean) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            modelValue: {
+                type: () => import("../../../neon").NeonDialogMessage;
+            };
+        }>> & Readonly<{}>, {}, {}, {
+            NeonDialog: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                color: {
+                    type: () => import("../../../neon").NeonFunctionalColor;
+                    default: import("../../../neon").NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => import("../../../neon").NeonFunctionalColor;
+                    default: null;
+                };
+                cancelLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                confirmLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                title: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                question: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                open: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                opaque: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                actions: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
+                cancel: () => void;
+                confirm: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "confirm")[], "cancel" | "confirm", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                color: {
+                    type: () => import("../../../neon").NeonFunctionalColor;
+                    default: import("../../../neon").NeonFunctionalColor;
+                };
+                alternateColor: {
+                    type: () => import("../../../neon").NeonFunctionalColor;
+                    default: null;
+                };
+                cancelLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                confirmLabel: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                title: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                question: {
+                    type: StringConstructor;
+                    required: true;
+                };
+                open: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                opaque: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onCancel?: ((...args: any[]) => any) | undefined;
+                onConfirm?: ((...args: any[]) => any) | undefined;
+            }>, {
+                color: import("../../../neon").NeonFunctionalColor;
+                open: boolean;
+                alternateColor: import("../../../neon").NeonFunctionalColor;
+                cancelLabel: string;
+                confirmLabel: string;
+                opaque: boolean;
+            }, {}, {
+                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;
+                }>, {
+                    color: import("../../../neon").NeonFunctionalColor;
+                    icon: string;
+                    label: string;
+                    inverse: boolean;
+                    disabled: boolean;
+                    href: string;
+                    size: import("../../../neon").NeonButtonSize;
+                    alternateColor: import("../../../neon").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; /**
+                             * 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<{}>, {
+                        color: import("../../../neon").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: () => 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<{}>, {
+                        color: import("../../../neon").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: () => 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<{}>, {
+                            color: import("../../../neon").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>;
+                NeonCard: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    orientation: {
+                        type: () => import("../../../neon").NeonOrientation;
+                        default: import("../../../neon").NeonOrientation;
+                    };
+                    size: {
+                        type: () => import("../../../neon").NeonSize;
+                        default: import("../../../neon").NeonSize;
+                    };
+                    horizontalBorders: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    horizontalBreakpoint: {
+                        type: () => import("../../../neon").NeonResponsive;
+                        default: import("../../../neon").NeonResponsive;
+                    };
+                    noBreak: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {
+                    attrs: {
+                        [x: string]: unknown;
+                    };
+                    NeonOrientation: typeof import("../../../neon").NeonOrientation;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    orientation: {
+                        type: () => import("../../../neon").NeonOrientation;
+                        default: import("../../../neon").NeonOrientation;
+                    };
+                    size: {
+                        type: () => import("../../../neon").NeonSize;
+                        default: import("../../../neon").NeonSize;
+                    };
+                    horizontalBorders: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    horizontalBreakpoint: {
+                        type: () => import("../../../neon").NeonResponsive;
+                        default: import("../../../neon").NeonResponsive;
+                    };
+                    noBreak: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    size: import("../../../neon").NeonSize;
+                    orientation: import("../../../neon").NeonOrientation;
+                    horizontalBorders: boolean;
+                    horizontalBreakpoint: import("../../../neon").NeonResponsive;
+                    noBreak: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonCardBody: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    fullWidth: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    fullWidth: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & Readonly<{}>, {
+                    fullWidth: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                NeonModal: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    open: {
+                        type: BooleanConstructor;
+                        required: true;
+                    };
+                    dismissible: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    opaque: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    showTopNav: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    breakpoint: {
+                        type: () => import("../../../neon").NeonResponsive;
+                        default: import("../../../neon").NeonResponsive;
+                    };
+                    noOffset: {
+                        type: BooleanConstructor;
+                    };
+                }>, {
+                    modal: import("vue").Ref<null, null>;
+                    close: () => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "close"[], "close", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    open: {
+                        type: BooleanConstructor;
+                        required: true;
+                    };
+                    dismissible: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    opaque: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    showTopNav: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    breakpoint: {
+                        type: () => import("../../../neon").NeonResponsive;
+                        default: import("../../../neon").NeonResponsive;
+                    };
+                    noOffset: {
+                        type: BooleanConstructor;
+                    };
+                }>> & Readonly<{
+                    onClose?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    opaque: boolean;
+                    dismissible: boolean;
+                    showTopNav: boolean;
+                    breakpoint: import("../../../neon").NeonResponsive;
+                    noOffset: boolean;
+                }, {}, {
+                    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;
+                    }>, {
+                        color: import("../../../neon").NeonFunctionalColor;
+                        icon: string;
+                        label: string;
+                        inverse: boolean;
+                        disabled: boolean;
+                        href: string;
+                        size: import("../../../neon").NeonButtonSize;
+                        alternateColor: import("../../../neon").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; /**
+                                 * 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<{}>, {
+                            color: import("../../../neon").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: () => 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<{}>, {
+                            color: import("../../../neon").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: () => 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<{}>, {
+                                color: import("../../../neon").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>;
+                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     NeonBanner: import("vue").DefineComponent<{}, {
         onAction: () => void;
@@ -756,8 +1799,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 disabled: boolean;
                 href: string;
                 size: import("../../../neon").NeonButtonSize;
-                outline: boolean;
                 alternateColor: import("../../../neon").NeonFunctionalColor;
+                outline: boolean;
                 iconPosition: import("../../../neon").NeonHorizontalPosition;
                 buttonStyle: import("../../../neon").NeonButtonStyle;
                 buttonType: import("../../../neon").NeonButtonType;
@@ -888,8 +1931,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     sanitizedAttributes: import("vue").ComputedRef<{
                         [x: string]: unknown;
                     }>;
-                    activeRoute: import("vue").ComputedRef<boolean | "">;
-                    exactRoute: import("vue").ComputedRef<boolean | "">;
+                    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<{
@@ -1243,8 +2286,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             disabled: boolean;
             href: string;
             size: import("../../../neon").NeonButtonSize;
-            outline: boolean;
             alternateColor: import("../../../neon").NeonFunctionalColor;
+            outline: boolean;
             iconPosition: import("../../../neon").NeonHorizontalPosition;
             buttonStyle: import("../../../neon").NeonButtonStyle;
             buttonType: import("../../../neon").NeonButtonType;
@@ -1375,8 +2418,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 sanitizedAttributes: import("vue").ComputedRef<{
                     [x: string]: unknown;
                 }>;
-                activeRoute: import("vue").ComputedRef<boolean | "">;
-                exactRoute: import("vue").ComputedRef<boolean | "">;
+                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<{