npm - @aotearoan/neon - Versions diffs - 28.0.3 → 28.1.1 - Mend

@aotearoan/neon 28.0.3 → 28.1.1

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 (74) hide show

package/dist/src/components/feedback/alert/NeonAlert.d.ts CHANGED Viewed

@@ -3,6 +3,7 @@ import type { NeonAlertModel } from '@/model/feedback/alert/NeonAlertModel';
 import type { NeonToastModel } from '@/model/feedback/toast/NeonToastModel';
 import { NeonAlertPlacement } from '@/model/feedback/alert/NeonAlertPlacement';
 import { NeonVerticalPosition } from '@/model/common/position/NeonVerticalPosition';
+import type { NeonDialogMessage } from '@/model/feedback/dialog/NeonDialogMessage';
 /**
  * NeonAlert is a component for presenting temporary notifications to the user. Place the component once inside your app
  * and use <strong>NeonAlertService</strong> to send events to the component.
@@ -206,6 +207,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;
+    }, 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<{
     /**
      * Whether alert messages are dismissible by clicking on them. This can also be set per alert message.
@@ -483,5 +503,1023 @@ 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: () => NeonDialogMessage;
+        };
+    }>, {
+        onButtonClick: (choice: boolean) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: () => 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;
+                        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;
+                        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;
+                }; /**
+                 * Whether alert messages are dismissible by clicking on them. This can also be set per alert message.
+                 */
+                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;
+                            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;
+                            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>;
 export default _default;