@frollo/frollo-web-ui 9.0.1 → 9.0.2

package/index.d.ts

@@ -1,10 +1,10 @@
 import * as vue from 'vue';
-import { PropType, ComponentInternalInstance, Component, ComponentCustomProps, Plugin } from 'vue';
+import { PropType, ComputedRef, ShallowReactive, Component, DefineComponent, ComponentCustomProps, Plugin } from 'vue';
 import * as vee_validate from 'vee-validate';
 import { RuleExpression } from 'vee-validate';
 export { Form as FwForm } from 'vee-validate';
-import * as _vue_shared from '@vue/shared';
-import * as lodash from 'lodash';
+import * as vue_chartjs_dist_types from 'vue-chartjs/dist/types';
+import * as vue_chartjs_dist_typedCharts from 'vue-chartjs/dist/typedCharts';
 import * as chart_js_dist_types_utils from 'chart.js/dist/types/utils';
 import * as chart_js from 'chart.js';
 
@@ -26,7 +26,7 @@ declare interface FwInputProps {
     required?: boolean;
 }
 
-declare const __default__$d: vue.DefineComponent<{
+declare const __default__$c: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The input v-model
      */
@@ -124,15 +124,14 @@ declare const __default__$d: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    inputBaseClass: vue.Ref<string>;
-    inputValue: vue.WritableComputedRef<string>;
-    onInput: (e: Event) => void;
+}>, {
+    inputBaseClass: vue.Ref<string, string>;
+    inputValue: vue.WritableComputedRef<string, string>;
     onFocus: (e: FocusEvent) => void;
     onBlur: (e: FocusEvent) => void;
     primaryFade5: string;
     colorErrorTextFade5: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "input" | "focus" | "blur")[], "update:modelValue" | "input" | "focus" | "blur", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur")[], "update:modelValue" | "focus" | "blur", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The input v-model
      */
@@ -230,12 +229,11 @@ declare const __default__$d: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-    onInput?: ((...args: any[]) => any) | undefined;
     onFocus?: ((...args: any[]) => any) | undefined;
     onBlur?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     modelValue: string;
     type: FwInputType;
     required: boolean;
@@ -243,7 +241,367 @@ declare const __default__$d: vue.DefineComponent<{
     tabindex: string;
     rounded: boolean;
     enableErrors: boolean;
-}, {}>;
+}, {}, {
+    InputField: {
+        new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, {
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            modelValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            validateOnMount: boolean;
+            standalone: boolean;
+            modelModifiers: any;
+            rules: vee_validate.RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, {}, {}, {}, {
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            modelValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            validateOnMount: boolean;
+            standalone: boolean;
+            modelModifiers: any;
+            rules: vee_validate.RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
+        as: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: any;
+        };
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        rules: {
+            type: PropType<vee_validate.RuleExpression<unknown>>;
+            default: any;
+        };
+        validateOnMount: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        validateOnBlur: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnChange: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnInput: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnModelUpdate: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        bails: {
+            type: BooleanConstructor;
+            default: () => boolean;
+        };
+        label: {
+            type: StringConstructor;
+            default: any;
+        };
+        uncheckedValue: {
+            type: any;
+            default: any;
+        };
+        modelValue: {
+            type: any;
+            default: symbol;
+        };
+        modelModifiers: {
+            type: any;
+            default: () => {};
+        };
+        'onUpdate:modelValue': {
+            type: PropType<(e: any) => unknown>;
+            default: any;
+        };
+        standalone: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keepValue: {
+            type: BooleanConstructor;
+            default: any;
+        };
+    }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | {
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
+        label: string;
+        as: string | Record<string, any>;
+        bails: boolean;
+        uncheckedValue: any;
+        modelValue: any;
+        validateOnInput: boolean;
+        validateOnChange: boolean;
+        validateOnBlur: boolean;
+        validateOnModelUpdate: boolean;
+        validateOnMount: boolean;
+        standalone: boolean;
+        modelModifiers: any;
+        rules: vee_validate.RuleExpression<unknown>;
+        'onUpdate:modelValue': (e: any) => unknown;
+        keepValue: boolean;
+    }, {}, string, {}, {}, {}, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+        value: vue.UnwrapRef<vee_validate.FieldContext["value"]>;
+        meta: vue.UnwrapRef<vee_validate.FieldContext["meta"]>;
+        errors: vue.UnwrapRef<vee_validate.FieldContext["errors"]>;
+        errorMessage: vue.UnwrapRef<vee_validate.FieldContext["errorMessage"]>;
+        setErrors: vee_validate.FieldContext["setErrors"];
+        setTouched: vee_validate.FieldContext["setTouched"];
+        reset: vee_validate.FieldContext["resetField"];
+        validate: vee_validate.FieldContext["validate"];
+        setValue: vee_validate.FieldContext["setValue"];
+        handleChange: vee_validate.FieldContext["handleChange"];
+        $slots: {
+            default: (arg: vee_validate.FieldSlotProps<any>) => vue.VNode[];
+        };
+    });
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare interface FwCheckboxProps {
     name: string;
@@ -255,7 +613,7 @@ declare interface FwCheckboxProps {
     isChecked?: boolean;
 }
 
-declare const __default__$c: vue.DefineComponent<{
+declare const __default__$b: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The name of the checkbox input field.
      * Multiple checkboxes can use the same name with a unique value.
@@ -305,11 +663,11 @@ declare const __default__$c: vue.DefineComponent<{
         required: false;
         default: undefined;
     };
-}, {
+}>, {
     uuid: string;
     primaryFade5: string;
     colorErrorTextFade5: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The name of the checkbox input field.
      * Multiple checkboxes can use the same name with a unique value.
@@ -359,10 +717,370 @@ declare const __default__$c: vue.DefineComponent<{
         required: false;
         default: undefined;
     };
-}>>, {
+}>> & Readonly<{}>, {
     enableErrors: boolean;
     isChecked: boolean;
-}, {}>;
+}, {}, {
+    InputField: {
+        new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, {
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            modelValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            validateOnMount: boolean;
+            standalone: boolean;
+            modelModifiers: any;
+            rules: vee_validate.RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, {}, {}, {}, {
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            modelValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            validateOnMount: boolean;
+            standalone: boolean;
+            modelModifiers: any;
+            rules: vee_validate.RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
+        as: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: any;
+        };
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        rules: {
+            type: PropType<vee_validate.RuleExpression<unknown>>;
+            default: any;
+        };
+        validateOnMount: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        validateOnBlur: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnChange: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnInput: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnModelUpdate: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        bails: {
+            type: BooleanConstructor;
+            default: () => boolean;
+        };
+        label: {
+            type: StringConstructor;
+            default: any;
+        };
+        uncheckedValue: {
+            type: any;
+            default: any;
+        };
+        modelValue: {
+            type: any;
+            default: symbol;
+        };
+        modelModifiers: {
+            type: any;
+            default: () => {};
+        };
+        'onUpdate:modelValue': {
+            type: PropType<(e: any) => unknown>;
+            default: any;
+        };
+        standalone: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keepValue: {
+            type: BooleanConstructor;
+            default: any;
+        };
+    }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | {
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
+        label: string;
+        as: string | Record<string, any>;
+        bails: boolean;
+        uncheckedValue: any;
+        modelValue: any;
+        validateOnInput: boolean;
+        validateOnChange: boolean;
+        validateOnBlur: boolean;
+        validateOnModelUpdate: boolean;
+        validateOnMount: boolean;
+        standalone: boolean;
+        modelModifiers: any;
+        rules: vee_validate.RuleExpression<unknown>;
+        'onUpdate:modelValue': (e: any) => unknown;
+        keepValue: boolean;
+    }, {}, string, {}, {}, {}, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+        value: vue.UnwrapRef<vee_validate.FieldContext["value"]>;
+        meta: vue.UnwrapRef<vee_validate.FieldContext["meta"]>;
+        errors: vue.UnwrapRef<vee_validate.FieldContext["errors"]>;
+        errorMessage: vue.UnwrapRef<vee_validate.FieldContext["errorMessage"]>;
+        setErrors: vee_validate.FieldContext["setErrors"];
+        setTouched: vee_validate.FieldContext["setTouched"];
+        reset: vee_validate.FieldContext["resetField"];
+        validate: vee_validate.FieldContext["validate"];
+        setValue: vee_validate.FieldContext["setValue"];
+        handleChange: vee_validate.FieldContext["handleChange"];
+        $slots: {
+            default: (arg: vee_validate.FieldSlotProps<any>) => vue.VNode[];
+        };
+    });
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare interface FwDropdownOption {
     label: string;
@@ -381,7 +1099,7 @@ declare interface FwDropdownProps {
     required?: boolean;
 }
 
-declare const __default__$b: vue.DefineComponent<{
+declare const __default__$a: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The select v-model
      */
@@ -444,27 +1162,32 @@ declare const __default__$b: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
+}>, {
     menuButtonClass: string;
     menuClass: string;
     menuItemClass: string;
     menuItemActiveClass: (option: FwDropdownOption) => "fw-dropdown--open" | "bg-none";
-    errors: vue.Ref<string[]>;
-    errorMessage: vue.Ref<string | undefined>;
+    errors: vue.Ref<string[], string[]>;
+    errorMessage: vue.Ref<string | undefined, string | undefined>;
     meta: vee_validate.FieldMeta<unknown>;
-    fieldVal: vue.Ref<unknown>;
-    isOpen: vue.Ref<boolean>;
-    selectValue: vue.WritableComputedRef<string | undefined>;
+    fieldVal: vue.Ref<unknown, unknown>;
+    isOpen: vue.Ref<boolean, boolean>;
+    selectValue: vue.WritableComputedRef<string | undefined, string | undefined>;
     selectOption: (option: FwDropdownOption) => void;
     selectedOption: vue.Ref<{
         label: string;
         value: string;
         image_url?: string | undefined;
         description?: string | undefined;
+    } | null, FwDropdownOption | {
+        label: string;
+        value: string;
+        image_url?: string | undefined;
+        description?: string | undefined;
     } | null>;
     primaryFade5: string;
     colorErrorTextFade5: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The select v-model
      */
@@ -527,13 +1250,16 @@ declare const __default__$b: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
+    required: boolean;
     placeholder: string;
     enableErrors: boolean;
-    required: boolean;
-}, {}>;
+}, {}, {
+    ChevronDownSvg: VueConstructor<Vue>;
+    FwImage: vue.ComponentOptions;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare interface FwSwitchProps {
     name: string;
@@ -542,9 +1268,10 @@ declare interface FwSwitchProps {
     hint?: string;
     enableErrors?: boolean;
     isChecked?: boolean;
+    modelValue?: boolean;
 }
 
-declare const _default$i: vue.DefineComponent<{
+declare const _default$j: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The name of the switch input field.
      * Multiple switches can use the same name with a unique value.
@@ -579,6 +1306,11 @@ declare const _default$i: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    /** v-model If provided, it is the source of truth. */
+    modelValue: {
+        type: BooleanConstructor;
+        required: false;
+    };
     /**
      * Progmatically set the checked state of the input.
      * Used outside a FwForm element
@@ -588,11 +1320,12 @@ declare const _default$i: vue.DefineComponent<{
         required: false;
         default: boolean;
     };
-}, {
-    isSwitched: vue.Ref<boolean>;
-    toggleSwitch: () => void;
-    uuid: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "change"[], "change", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, {
+    checked: vue.ComputedRef<boolean>;
+    onNativeChange: (e: Event) => void;
+    inputId: string;
+    resolvedValue: vue.ComputedRef<string>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:modelValue" | "update:isChecked")[], "change" | "update:modelValue" | "update:isChecked", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The name of the switch input field.
      * Multiple switches can use the same name with a unique value.
@@ -627,6 +1360,11 @@ declare const _default$i: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    /** v-model If provided, it is the source of truth. */
+    modelValue: {
+        type: BooleanConstructor;
+        required: false;
+    };
     /**
      * Progmatically set the checked state of the input.
      * Used outside a FwForm element
@@ -636,14 +1374,377 @@ declare const _default$i: vue.DefineComponent<{
         required: false;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onChange?: ((...args: any[]) => any) | undefined;
-}, {
+    "onUpdate:isChecked"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: boolean;
     enableErrors: boolean;
     isChecked: boolean;
-}, {}>;
+}, {}, {
+    InputField: {
+        new (...args: any[]): vue.CreateComponentPublicInstance<Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, {
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            modelValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            validateOnMount: boolean;
+            standalone: boolean;
+            modelModifiers: any;
+            rules: vee_validate.RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<vue.ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<vee_validate.RuleExpression<unknown>>;
+                default: any;
+            };
+            validateOnMount: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            validateOnBlur: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnChange: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnInput: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            validateOnModelUpdate: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            bails: {
+                type: BooleanConstructor;
+                default: () => boolean;
+            };
+            label: {
+                type: StringConstructor;
+                default: any;
+            };
+            uncheckedValue: {
+                type: any;
+                default: any;
+            };
+            modelValue: {
+                type: any;
+                default: symbol;
+            };
+            modelModifiers: {
+                type: any;
+                default: () => {};
+            };
+            "onUpdate:modelValue": {
+                type: PropType<(e: any) => unknown>;
+                default: any;
+            };
+            standalone: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            keepValue: {
+                type: BooleanConstructor;
+                default: any;
+            };
+        }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, {}, {}, {}, {
+            label: string;
+            as: string | Record<string, any>;
+            bails: boolean;
+            uncheckedValue: any;
+            modelValue: any;
+            validateOnInput: boolean;
+            validateOnChange: boolean;
+            validateOnBlur: boolean;
+            validateOnModelUpdate: boolean;
+            validateOnMount: boolean;
+            standalone: boolean;
+            modelModifiers: any;
+            rules: vee_validate.RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & vue.ComponentOptionsBase<Readonly<vue.ExtractPropTypes<{
+        as: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: any;
+        };
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        rules: {
+            type: PropType<vee_validate.RuleExpression<unknown>>;
+            default: any;
+        };
+        validateOnMount: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        validateOnBlur: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnChange: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnInput: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        validateOnModelUpdate: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        bails: {
+            type: BooleanConstructor;
+            default: () => boolean;
+        };
+        label: {
+            type: StringConstructor;
+            default: any;
+        };
+        uncheckedValue: {
+            type: any;
+            default: any;
+        };
+        modelValue: {
+            type: any;
+            default: symbol;
+        };
+        modelModifiers: {
+            type: any;
+            default: () => {};
+        };
+        'onUpdate:modelValue': {
+            type: PropType<(e: any) => unknown>;
+            default: any;
+        };
+        standalone: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        keepValue: {
+            type: BooleanConstructor;
+            default: any;
+        };
+    }>>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }> | vue.Slot<any> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[] | {
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, {
+        label: string;
+        as: string | Record<string, any>;
+        bails: boolean;
+        uncheckedValue: any;
+        modelValue: any;
+        validateOnInput: boolean;
+        validateOnChange: boolean;
+        validateOnBlur: boolean;
+        validateOnModelUpdate: boolean;
+        validateOnMount: boolean;
+        standalone: boolean;
+        modelModifiers: any;
+        rules: vee_validate.RuleExpression<unknown>;
+        'onUpdate:modelValue': (e: any) => unknown;
+        keepValue: boolean;
+    }, {}, string, {}, {}, {}, string, vue.ComponentProvideOptions> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new () => {
+        value: vue.UnwrapRef<vee_validate.FieldContext["value"]>;
+        meta: vue.UnwrapRef<vee_validate.FieldContext["meta"]>;
+        errors: vue.UnwrapRef<vee_validate.FieldContext["errors"]>;
+        errorMessage: vue.UnwrapRef<vee_validate.FieldContext["errorMessage"]>;
+        setErrors: vee_validate.FieldContext["setErrors"];
+        setTouched: vee_validate.FieldContext["setTouched"];
+        reset: vee_validate.FieldContext["resetField"];
+        validate: vee_validate.FieldContext["validate"];
+        setValue: vee_validate.FieldContext["setValue"];
+        handleChange: vee_validate.FieldContext["handleChange"];
+        $slots: {
+            default: (arg: vee_validate.FieldSlotProps<any>) => vue.VNode[];
+        };
+    });
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$a: vue.DefineComponent<{
+declare const __default__$9: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The header title of the card
      */
@@ -680,11 +1781,11 @@ declare const __default__$a: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
+}>, {
     componentName: vue.ComputedRef<"router-link" | "a" | "div">;
-    linkClass: vue.Ref<string>;
+    linkClass: string;
     cardHeaderBg: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The header title of the card
      */
@@ -721,10 +1822,10 @@ declare const __default__$a: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>>, {
+}>> & Readonly<{}>, {
     slotPadding: boolean;
     isBordered: boolean;
-}, {}>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 type ButtonVariantName = 'primary' | 'secondary' | 'tertiary' | 'quaternary' | 'error' | 'success' | 'link' | 'text' | 'transparent' | 'gradient';
 declare interface ButtonDefinition {
@@ -754,7 +1855,7 @@ declare interface FwButtonProps {
     external?: boolean;
 }
 
-declare const _default$h: vue.DefineComponent<{
+declare const _default$i: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The label text of the button.
      * Overrides the default slot content.
@@ -825,6 +1926,7 @@ declare const _default$h: vue.DefineComponent<{
      */
     external: {
         type: BooleanConstructor;
+        default: boolean;
     };
     /**
      * Whether the button selected state is active
@@ -839,8 +1941,7 @@ declare const _default$h: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    baseClass: vue.Ref<string>;
+}>, {
     textColorClass: vue.ComputedRef<string>;
     bgColorClass: vue.ComputedRef<string>;
     sizeClass: vue.ComputedRef<string>;
@@ -867,7 +1968,8 @@ declare const _default$h: vue.DefineComponent<{
         spacing: string;
         size: string;
     }>;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("click" | "mouseover" | "mouseout" | "focusin" | "focusout")[], "click" | "mouseover" | "mouseout" | "focusin" | "focusout", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    rootClasses: vue.ComputedRef<string[]>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("click" | "mouseover" | "mouseout" | "focusin" | "focusout")[], "click" | "mouseover" | "mouseout" | "focusin" | "focusout", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The label text of the button.
      * Overrides the default slot content.
@@ -938,6 +2040,7 @@ declare const _default$h: vue.DefineComponent<{
      */
     external: {
         type: BooleanConstructor;
+        default: boolean;
     };
     /**
      * Whether the button selected state is active
@@ -952,13 +2055,13 @@ declare const _default$h: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     onClick?: ((...args: any[]) => any) | undefined;
     onMouseover?: ((...args: any[]) => any) | undefined;
     onMouseout?: ((...args: any[]) => any) | undefined;
     onFocusin?: ((...args: any[]) => any) | undefined;
     onFocusout?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     size: ButtonSize;
     variant: ButtonVariantName;
     buttonType: ButtonTypeAttribute;
@@ -968,11 +2071,13 @@ declare const _default$h: vue.DefineComponent<{
     external: boolean;
     selected: boolean;
     disabled: boolean;
-}, {}>;
+}, {}, {
+    LoadingSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 type AlertVariantName = 'success' | 'error';
 
-declare const _default$g: vue.DefineComponent<{
+declare const _default$h: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The colour variant of the alert element.
      * Accepts 'success', 'error'
@@ -989,10 +2094,12 @@ declare const _default$g: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
+}>, {
+    visible: vue.Ref<boolean, boolean>;
     bgClass: vue.ComputedRef<"bg-brand-error-bg" | "bg-brand-success-bg">;
-    defaultScale: vue.Ref<string>;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    IconComp: vue.ComputedRef<any>;
+    iconClass: vue.ComputedRef<"text-brand-success-text" | "text-brand-error-text">;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The colour variant of the alert element.
      * Accepts 'success', 'error'
@@ -1009,9 +2116,12 @@ declare const _default$g: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>>, {
+}>> & Readonly<{}>, {
     disableIcon: boolean;
-}, {}>;
+}, {}, {
+    CheckSvg: VueConstructor<Vue>;
+    AlertSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare interface NavMenuItem {
     to?: string | object;
@@ -1032,7 +2142,7 @@ declare interface FwNavigationMenuProps {
     transparent?: boolean;
 }
 
-declare const _default$f: vue.DefineComponent<{
+declare const _default$g: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * An array of menu items
      * `{ to?: string | object; href?: string; label: string; external?: boolean; }`
@@ -1088,12 +2198,12 @@ declare const _default$f: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    mobileMenuClass: vue.Ref<string>;
-    isMobileMenuOpen: vue.Ref<boolean>;
+}>, {
+    mobileMenuClass: vue.Ref<string, string>;
+    isMobileMenuOpen: vue.Ref<boolean, boolean>;
     toggleMobileMenu: () => boolean;
     actionClicked: () => void;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "action"[], "action", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "action"[], "action", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * An array of menu items
      * `{ to?: string | object; href?: string; label: string; external?: boolean; }`
@@ -1149,24 +2259,38 @@ declare const _default$f: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     onAction?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     containerClass: string;
     menuEnabled: boolean;
     authenticated: boolean;
     transparent: boolean;
-}, {}>;
+}, {}, {
+    FwButton: vue.ComponentOptions;
+    FwPopover: vue.ComponentOptions;
+    UserSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare interface TabsState {
-    tabs: ComponentInternalInstance[] | null;
-    active: number;
+declare type TabRecord = {
+    uid: number;
+    label: string;
+    index: number;
+};
+declare type TabsApi = {
+    active: ComputedRef<number>;
+    registerTabs: (uid: number, label: string) => number;
+    unregisterTabs: (uid: number) => void;
+    tabs: ShallowReactive<TabRecord[]>;
+};
+declare interface FwTabProps {
+    label: string;
 }
 declare interface FwTabsProps {
     modelValue: number;
 }
 
-declare const _default$e: vue.DefineComponent<{
+declare const _default$f: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The active tab v-model
      */
@@ -1174,10 +2298,11 @@ declare const _default$e: vue.DefineComponent<{
         type: NumberConstructor;
         required: true;
     };
-}, {
-    state: TabsState;
-    selectTab: (tab: number) => void;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, {
+    tabs: vue.ShallowReactive<TabRecord[]>;
+    active: vue.ComputedRef<number>;
+    selectTab: (index: number) => void;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The active tab v-model
      */
@@ -1185,11 +2310,13 @@ declare const _default$e: vue.DefineComponent<{
         type: NumberConstructor;
         required: true;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {}, {}>;
+}>, {}, {}, {
+    FwButton: vue.ComponentOptions;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$d: vue.DefineComponent<{
+declare const _default$e: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The label of the tab component used as the button panel label
      */
@@ -1197,13 +2324,9 @@ declare const _default$d: vue.DefineComponent<{
         type: StringConstructor;
         required: true;
     };
-}, {
+}>, {
     isActive: vue.ComputedRef<boolean>;
-    index: vue.ComputedRef<number | undefined>;
-    props: _vue_shared.LooseRequired<{
-        readonly label: string;
-    } & {}>;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The label of the tab component used as the button panel label
      */
@@ -1211,7 +2334,7 @@ declare const _default$d: vue.DefineComponent<{
         type: StringConstructor;
         required: true;
     };
-}>>, {}, {}>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare interface FwCardProps {
     title?: string;
@@ -1264,16 +2387,35 @@ declare interface FwTagProps {
     variant?: TagVariantName;
 }
 
-declare type FwTableItem = Record<string, string | number>;
-declare type FwTableFormatFunction = (value: string | number | object) => string;
+declare type FwTableItemValue = string | number | boolean | object;
+declare type FwTableItem = Record<string, FwTableItemValue>;
+declare type FwTableFormatFunction = (value: FwTableItemValue, row?: FwTableItem) => string;
 declare type FwTableSortFunction = (items: FwTableItem[], columnName: string, sortDirection?: FwTableSort) => FwTableItem[] | undefined;
 declare type FwTableSort = 'asc' | 'desc';
+declare type FwTableCellComponentProps = Record<string, unknown> | ((ctx: {
+    value: FwTableItemValue;
+    row: FwTableItem;
+    column: string;
+}) => Record<string, unknown>);
+declare type FwTableCellComponentHandlers = Record<string, (...args: unknown[]) => void> | ((ctx: {
+    value: FwTableItemValue;
+    row: FwTableItem;
+    column: string;
+}) => Record<string, (...args: unknown[]) => void>);
 declare type FwTableItemOptions = Record<string, {
     formatter?: FwTableFormatFunction;
     isSortable?: boolean;
     disabled?: boolean;
     initSortOrder?: FwTableSort;
     sort?: FwTableSortFunction;
+    /** opt-in for v-html rendering */
+    html?: boolean;
+    /** render a Vue component inside the cell */
+    component?: Component;
+    /** props for the component (static or per-row) */
+    componentProps?: FwTableCellComponentProps;
+    /** optional event handlers/listeners for the component */
+    componentEventHandlers?: FwTableCellComponentHandlers;
 }>;
 declare interface FwTableProps {
     items: FwTableItem[];
@@ -1284,6 +2426,20 @@ declare interface FwTableProps {
     enablePagination?: boolean;
     totalAmount?: number;
     pageSize?: number;
+    rowKey?: string | ((row: FwTableItem) => string | number);
+}
+declare interface FwTableColumnMeta {
+    key: string;
+    disabled: boolean;
+    sortable: boolean;
+    initSortOrder: FwTableSort;
+    sortFn?: FwTableSortFunction;
+    html: boolean;
+    format: (val: FwTableItemValue, row?: FwTableItem) => FwTableItemValue;
+    component?: Component;
+    componentProps?: FwTableCellComponentProps;
+    componentEventHandlers?: FwTableCellComponentHandlers;
+    isActiveSort: boolean;
 }
 
 declare interface FwAccordionProps {
@@ -1427,7 +2583,7 @@ declare interface FwMediaPickerProps {
     editHeaderText?: string;
 }
 
-declare const __default__$9: vue.DefineComponent<{
+declare const __default__$8: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The modal's v-model. Controls the visibility of the modal.
      */
@@ -1549,12 +2705,12 @@ declare const __default__$9: vue.DefineComponent<{
     bannerUrl: {
         type: StringConstructor;
     };
-}, {
+}>, {
     isOpen: vue.ComputedRef<boolean>;
     uuid: `${string}-${string}-${string}-${string}-${string}`;
-    isMounted: vue.Ref<boolean>;
+    isMounted: vue.Ref<boolean, boolean>;
     modalBgColour: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("cancel" | "confirm")[], "cancel" | "confirm", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("cancel" | "confirm")[], "cancel" | "confirm", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The modal's v-model. Controls the visibility of the modal.
      */
@@ -1676,10 +2832,10 @@ declare const __default__$9: vue.DefineComponent<{
     bannerUrl: {
         type: StringConstructor;
     };
-}>> & {
+}>> & Readonly<{
     onCancel?: ((...args: any[]) => any) | undefined;
     onConfirm?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     cancelButtonType: ButtonVariantName | undefined;
     confirmButtonType: ButtonVariantName | undefined;
     modelValue: boolean;
@@ -1692,9 +2848,13 @@ declare const __default__$9: vue.DefineComponent<{
     confirmLoading: boolean;
     padding: boolean;
     showCloseButton: boolean;
-}, {}>;
+}, {}, {
+    FwButton: vue.ComponentOptions;
+    XMarkSvg: VueConstructor<Vue>;
+    FwImage: vue.ComponentOptions;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$c: vue.DefineComponent<{
+declare const _default$d: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * An array of menu progress steps.
      * `{ label: string; position: number; subSteps: number; }`
@@ -1717,9 +2877,9 @@ declare const _default$c: vue.DefineComponent<{
         type: NumberConstructor;
         required: true;
     };
-}, {
+}>, {
     calculatedProgressBar: (step: ProgressBarStep) => string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * An array of menu progress steps.
      * `{ label: string; position: number; subSteps: number; }`
@@ -1742,9 +2902,11 @@ declare const _default$c: vue.DefineComponent<{
         type: NumberConstructor;
         required: true;
     };
-}>>, {}, {}>;
+}>> & Readonly<{}>, {}, {}, {
+    CheckSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$8: vue.DefineComponent<{
+declare const __default__$7: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The label text of the tag.
      * Overrides the default slot content.
@@ -1775,15 +2937,18 @@ declare const __default__$8: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    baseClass: vue.Ref<string>;
+}>, {
+    visible: vue.Ref<boolean, boolean>;
+    baseClass: string;
     textColorClass: vue.ComputedRef<string>;
     bgColorClass: vue.ComputedRef<string>;
     sizeClass: vue.ComputedRef<string>;
     iconSizeClass: vue.ComputedRef<string>;
     iconButtonType: vue.ComputedRef<ButtonVariantName | undefined>;
     primaryFade5: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "dismissed"[], "dismissed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    onDismiss: () => void;
+    rootClasses: vue.ComputedRef<string[]>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "dismissed"[], "dismissed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The label text of the tag.
      * Overrides the default slot content.
@@ -1814,15 +2979,18 @@ declare const __default__$8: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     onDismissed?: ((...args: any[]) => any) | undefined;
-}, {
-    size: TagSize;
+}>, {
     variant: TagVariantName;
+    size: TagSize;
     dismissable: boolean;
-}, {}>;
+}, {}, {
+    FwButton: vue.ComponentOptions;
+    XMarkSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$7: vue.DefineComponent<{
+declare const __default__$6: vue.DefineComponent<vue.ExtractPropTypes<{
     items: {
         type: PropType<FwTableProps["items"]>;
         required: true;
@@ -1856,23 +3024,30 @@ declare const __default__$7: vue.DefineComponent<{
     pageSize: {
         type: NumberConstructor;
     };
-}, {
-    columns: vue.ComputedRef<string[]>;
-    sortBy: vue.Ref<string>;
-    sortDirection: vue.Ref<FwTableSort>;
-    sortColumn: (column: string, isAction?: boolean) => void;
-    sortedData: vue.ComputedRef<FwTableItem[] | undefined>;
-    currentSortedColumn: vue.Ref<string>;
-    sortedIcon: (sortDir: string, column: string) => boolean;
-    formattedText: (row: FwTableItem, column: string) => string | number;
-    isColumnSortable: (column: string) => boolean | undefined;
-    isDisabled: (column: string) => boolean;
+    /**
+     * Optional stable row key. If omitted, falls back to index-based key.
+     */
+    rowKey: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: false;
+    };
+}>, {
+    colMeta: vue.ComputedRef<FwTableColumnMeta[]>;
+    sortBy: vue.Ref<string, string>;
+    sortDirection: vue.Ref<FwTableSort, FwTableSort>;
+    currentSortedColumn: vue.Ref<string, string>;
+    onSort: (column: string, isAction?: boolean) => void;
+    displayRows: vue.ComputedRef<FwTableItem[]>;
     rowClicked: (row: FwTableItem) => void;
     bgHoverColor: string;
-    currentPage: vue.Ref<number>;
-    maxPageAmount: vue.Ref<number | undefined>;
+    currentPage: vue.Ref<number, number>;
+    maxPageAmount: vue.Ref<number | undefined, number | undefined>;
     pageArrowClick: (next: boolean) => void;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("rowClicked" | "columnSorted" | "pageChanged")[], "rowClicked" | "columnSorted" | "pageChanged", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    getRowKey: (row: FwTableItem, index?: number) => any;
+    skeletonRowCount: vue.ComputedRef<number>;
+    getComponentProps: (col: FwTableColumnMeta, row: FwTableItem) => Record<string, unknown>;
+    getComponentHandlers: (col: FwTableColumnMeta, row: FwTableItem) => Record<string, (...args: unknown[]) => void>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("rowClicked" | "columnSorted" | "pageChanged")[], "rowClicked" | "columnSorted" | "pageChanged", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     items: {
         type: PropType<FwTableProps["items"]>;
         required: true;
@@ -1906,21 +3081,35 @@ declare const __default__$7: vue.DefineComponent<{
     pageSize: {
         type: NumberConstructor;
     };
-}>> & {
+    /**
+     * Optional stable row key. If omitted, falls back to index-based key.
+     */
+    rowKey: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: false;
+    };
+}>> & Readonly<{
     onRowClicked?: ((...args: any[]) => any) | undefined;
     onColumnSorted?: ((...args: any[]) => any) | undefined;
     onPageChanged?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     loading: boolean;
     clickableRows: boolean;
     enablePagination: boolean;
-}, {}>;
+}, {}, {
+    FwLoadingBar: vue.ComponentOptions;
+    FwButton: vue.ComponentOptions;
+    ArrowDownSvg: VueConstructor<Vue>;
+    ArrowSortSvg: VueConstructor<Vue>;
+    ChevronLeftSvg: VueConstructor<Vue>;
+    ChevronRightSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$b: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
+declare const _default$c: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$a: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
+declare const _default$b: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$6: vue.DefineComponent<{
+declare const __default__$5: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The header title of the accordion
      */
@@ -1975,14 +3164,14 @@ declare const __default__$6: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    isOpen: vue.Ref<boolean>;
+}>, {
+    isOpen: vue.Ref<boolean, boolean>;
     beforeEnter: (el: Element) => void;
     enter: (el: Element) => void;
     beforeLeave: (el: Element) => void;
     leave: (el: Element) => void;
     bgHoverColor: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "toggled"[], "toggled", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "toggled"[], "toggled", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The header title of the accordion
      */
@@ -2037,18 +3226,20 @@ declare const __default__$6: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     onToggled?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     titleClass: string;
     isOpened: boolean;
     iconPositionStart: boolean;
     headerClass: string;
     borderStyle: string;
     secondary: boolean;
-}, {}>;
+}, {}, {
+    ChevronDownSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$5: vue.DefineComponent<{
+declare const __default__$4: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The src attribute of the image
      */
@@ -2092,11 +3283,24 @@ declare const __default__$5: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    fwImageRef: vue.Ref<null>;
+}>, {
+    fwImageRef: vue.Ref<HTMLElement | null, HTMLElement | null>;
+    imgRef: vue.Ref<HTMLImageElement | null, HTMLImageElement | null>;
+    status: vue.Ref<"idle" | "loading" | "loaded" | "error", "idle" | "loading" | "loaded" | "error">;
     isBackground: vue.ComputedRef<boolean>;
+    rootClasses: vue.ComputedRef<{
+        'fw-image--background': boolean;
+        'rounded-full': boolean;
+        'fw-image--loaded': boolean;
+        'fw-image--error-state': boolean;
+    }>;
     colorErrorTextFade5: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("click" | "mouseover" | "mouseout")[], "click" | "mouseover" | "mouseout", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    onStart: () => void;
+    onLoad: () => void;
+    onError: () => void;
+    handleLoad: () => void;
+    handleError: () => void;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("click" | "mouseover" | "mouseout")[], "click" | "mouseover" | "mouseout", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The src attribute of the image
      */
@@ -2140,25 +3344,42 @@ declare const __default__$5: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     onClick?: ((...args: any[]) => any) | undefined;
     onMouseover?: ((...args: any[]) => any) | undefined;
     onMouseout?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     type: "native" | "background" | undefined;
     rounded: boolean;
     threshold: number;
     enableErrors: boolean;
-}, {}>;
+}, {}, {
+    FwLoadingBar: vue.ComponentOptions;
+    FileExclamationSvg: VueConstructor<Vue>;
+}, {
+    lazyload: vue.Directive<Element, {
+        src?: string;
+        type?: "native" | "background";
+        threshold?: number;
+        rootMargin?: string;
+        onStart?: () => void;
+        onLoad?: () => void;
+        onError?: () => void;
+    } | undefined>;
+}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$4: vue.DefineComponent<{}, {
-    primaryFade5: string;
-    primaryFade20: string;
-}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
+declare const _default$a: vue.DefineComponent<{}, {
+    barVars: vue.ComputedRef<{
+        '--fw-bar-light': string;
+        '--fw-bar-dark': string;
+    }>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$9: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
+declare const _default$9: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    FwLoadingBar: vue.ComponentOptions;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$8: vue.DefineComponent<{
+declare const _default$8: vue.DefineComponent<vue.ExtractPropTypes<{
     columns: {
         type: NumberConstructor;
         default: number;
@@ -2167,9 +3388,12 @@ declare const _default$8: vue.DefineComponent<{
         type: NumberConstructor;
         default: number;
     };
-}, {
-    tableClass: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, {
+    wrapperClass: string;
+    colList: vue.ComputedRef<number[]>;
+    rowList: vue.ComputedRef<number[]>;
+    cellWidth: (r: number, c: number) => string;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     columns: {
         type: NumberConstructor;
         default: number;
@@ -2178,14 +3402,23 @@ declare const _default$8: vue.DefineComponent<{
         type: NumberConstructor;
         default: number;
     };
-}>>, {
+}>> & Readonly<{}>, {
     columns: number;
     rows: number;
-}, {}>;
+}, {}, {
+    FwLoadingBar: vue.ComponentOptions;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$7: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
+declare const _default$7: vue.DefineComponent<{}, {
+    barVars: vue.ComputedRef<{
+        '--fw-bar-light': string;
+        '--fw-bar-dark': string;
+    }>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    FwLoadingBar: vue.ComponentOptions;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$6: vue.DefineComponent<{
+declare const _default$6: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The toast's v-model. Controls the visibility of the toast.
      */
@@ -2230,25 +3463,16 @@ declare const _default$6: vue.DefineComponent<{
         type: NumberConstructor;
         default: number;
     };
-}, {
+}>, {
+    isMounted: vue.Ref<boolean, boolean>;
+    isOpen: vue.WritableComputedRef<boolean, boolean>;
+    uuid: `${string}-${string}-${string}-${string}-${string}`;
     containerEl: vue.ComputedRef<string>;
     baseClass: string;
-    typeClasses: vue.Ref<{
-        success: string;
-        error: string;
-        warning: string;
-    }>;
-    svgComponent: vue.Ref<{
-        success: string;
-        error: string;
-        warning: string;
-    }>;
-    isOpen: vue.WritableComputedRef<vue.Ref<boolean>>;
-    uuid: string;
-    isMounted: vue.Ref<boolean>;
-    mountContainer: vue.Ref<boolean>;
-    isLeftRightorCenter: vue.ComputedRef<"Right" | "Left" | "Center">;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "dismissed")[], "update:modelValue" | "dismissed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    typeClasses: ToastTypes;
+    svgComponent: ToastTypes;
+    transitionName: vue.ComputedRef<"toastSlideInRight" | "toastSlideInLeft" | "toastSlideInCenter">;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "dismissed")[], "update:modelValue" | "dismissed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The toast's v-model. Controls the visibility of the toast.
      */
@@ -2293,18 +3517,22 @@ declare const _default$6: vue.DefineComponent<{
         type: NumberConstructor;
         default: number;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onDismissed?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     modelValue: boolean;
     type: ToastType;
     position: ToastPosition;
     element: string;
     timeout: number;
-}, {}>;
+}, {}, {
+    SolidCheckSvg: VueConstructor<Vue>;
+    SolidXMarkSvg: VueConstructor<Vue>;
+    ErrorFilledSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$5: vue.DefineComponent<{
+declare const _default$5: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The transaction title of the card
      */
@@ -2332,7 +3560,7 @@ declare const _default$5: vue.DefineComponent<{
         type: StringConstructor;
         required: false;
     };
-}, unknown, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The transaction title of the card
      */
@@ -2360,9 +3588,12 @@ declare const _default$5: vue.DefineComponent<{
         type: StringConstructor;
         required: false;
     };
-}>>, {}, {}>;
+}>> & Readonly<{}>, {}, {}, {
+    FwCard: vue.ComponentOptions;
+    FwImage: vue.ComponentOptions;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$4: vue.DefineComponent<{
+declare const _default$4: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * Controls the sidebar menu open/close state
      */
@@ -2406,11 +3637,14 @@ declare const _default$4: vue.DefineComponent<{
         default: string;
         validator: (value: string) => boolean;
     };
-}, {
+}>, {
     baseClass: string;
-    isMenuOpen: vue.WritableComputedRef<boolean>;
+    isMenuOpen: vue.WritableComputedRef<boolean, boolean>;
     toggleMenu: () => void;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("toggled" | "update:modelValue")[], "toggled" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    enabledItems: vue.ComputedRef<FwSidebarMenuItem[]>;
+    hasItems: vue.ComputedRef<boolean>;
+    widthClass: vue.ComputedRef<string>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("toggled" | "update:modelValue")[], "toggled" | "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * Controls the sidebar menu open/close state
      */
@@ -2454,18 +3688,21 @@ declare const _default$4: vue.DefineComponent<{
         default: string;
         validator: (value: string) => boolean;
     };
-}>> & {
+}>> & Readonly<{
     onToggled?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     toggleButtonVariant: ButtonVariantName | undefined;
     modelValue: boolean;
     toggleButtonClass: string;
     openWidth: string;
     closedWidth: string;
-}, {}>;
+}, {}, {
+    FwButton: vue.ComponentOptions;
+    ChevronRightSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$3: vue.DefineComponent<{
+declare const __default__$3: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The drawer's v-model. Controls the visibility of the drawer.
      */
@@ -2542,16 +3779,16 @@ declare const __default__$3: vue.DefineComponent<{
         default: string;
         validator: (value: string) => boolean;
     };
-}, {
+}>, {
     baseDrawerClass: string;
     drawerFooterClass: string;
-    isOpen: vue.WritableComputedRef<boolean>;
+    isOpen: vue.WritableComputedRef<boolean, boolean>;
     uuid: string;
-    isMounted: vue.Ref<boolean>;
+    isMounted: vue.Ref<boolean, boolean>;
     onConfirmed: () => void;
     onCancelled: () => void;
     drawerBgColour: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "cancel" | "confirm")[], "update:modelValue" | "cancel" | "confirm", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "cancel" | "confirm")[], "update:modelValue" | "cancel" | "confirm", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The drawer's v-model. Controls the visibility of the drawer.
      */
@@ -2628,11 +3865,11 @@ declare const __default__$3: vue.DefineComponent<{
         default: string;
         validator: (value: string) => boolean;
     };
-}>> & {
+}>> & Readonly<{
     onCancel?: ((...args: any[]) => any) | undefined;
     onConfirm?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     cancelButtonType: ButtonVariantName | undefined;
     confirmButtonType: ButtonVariantName | undefined;
     modelValue: boolean;
@@ -2642,351 +3879,90 @@ declare const __default__$3: vue.DefineComponent<{
     showConfirm: boolean;
     cancelButtonText: string;
     confirmButtonText: string;
-}, {}>;
+}, {}, {
+    FwButton: vue.ComponentOptions;
+    XMarkSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$2: vue.DefineComponent<{
-    /**
-     * The header heading of the list.
-     */
+declare const __default__$2: vue.DefineComponent<vue.ExtractPropTypes<{
     heading: {
         type: StringConstructor;
     };
-    /**
-     * The list items of the table items.
-     */
     items: {
         type: PropType<FwProviderListProps["items"]>;
         required: true;
     };
-    /**
-     * The table header title.
-     */
     tableHeaderName: {
         type: StringConstructor;
         default: string;
     };
-    /**
-     * The placeholder text for the search input.
-     */
     searchPlaceholder: {
         type: StringConstructor;
         default: string;
     };
-    /**
-     * The label text for the search input.
-     */
     searchLabel: {
         type: StringConstructor;
         default: string;
     };
-    /**
-     * The label text for the status filter dropdown.
-     */
     statusFilterLabel: {
         type: StringConstructor;
         default: string;
     };
-}, {
-    options: FwTableItemOptions;
+}>, {
+    options: vue.ComputedRef<FwTableItemOptions | undefined>;
     sortedTableItems: vue.ComputedRef<FwTableItem[]>;
-    searchFilterModel: vue.Ref<string>;
-    statusFilterModel: vue.Ref<string>;
+    searchFilterModel: vue.Ref<string, string>;
+    statusFilterModel: vue.Ref<"supported" | "outage" | "all", "supported" | "outage" | "all">;
     primaryFade5: string;
     primaryFade20: string;
     primaryFade40: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "changed"[], "changed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    /**
-     * The header heading of the list.
-     */
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "changed"[], "changed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     heading: {
         type: StringConstructor;
     };
-    /**
-     * The list items of the table items.
-     */
     items: {
         type: PropType<FwProviderListProps["items"]>;
         required: true;
     };
-    /**
-     * The table header title.
-     */
     tableHeaderName: {
         type: StringConstructor;
         default: string;
     };
-    /**
-     * The placeholder text for the search input.
-     */
     searchPlaceholder: {
         type: StringConstructor;
         default: string;
     };
-    /**
-     * The label text for the search input.
-     */
     searchLabel: {
         type: StringConstructor;
         default: string;
     };
-    /**
-     * The label text for the status filter dropdown.
-     */
     statusFilterLabel: {
         type: StringConstructor;
         default: string;
     };
-}>> & {
+}>> & Readonly<{
     onChanged?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     tableHeaderName: string;
     searchPlaceholder: string;
     searchLabel: string;
     statusFilterLabel: string;
-}, {}>;
+}, {}, {
+    FwTable: vue.ComponentOptions;
+    FwInput: vue.ComponentOptions;
+    FwDropdown: vue.ComponentOptions;
+    FwButton: vue.ComponentOptions;
+    FwTableHead: vue.ComponentOptions;
+    FwTableRow: vue.ComponentOptions;
+    FwTag: vue.ComponentOptions;
+    SearchSvg: VueConstructor<Vue>;
+    SolidCheckSvg: VueConstructor<Vue>;
+    SolidXMarkSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const __default__$1: vue.DefineComponent<{
-    /**
-     * The date-picker v-model
-     */
-    modelValue: {
-        type: PropType<FwDatePickerModel>;
-        default: null;
-    };
-    /**
-     * The name of the input field. Must be unique per form.
-     */
-    name: {
-        type: StringConstructor;
-        required: true;
-    };
-    /**
-     * Label for the input. Also renders to an aria-label attribute
-     */
-    label: {
-        type: StringConstructor;
-    };
-    /**
-     * The placeholder text of the input
-     */
-    placeholder: {
-        type: StringConstructor;
-    };
-    /**
-     * The placeholder text of the starting range input
-     */
-    startPlaceholder: {
-        type: StringConstructor;
-    };
-    /**
-     * The placeholder text of the ending range input
-     */
-    endPlaceholder: {
-        type: StringConstructor;
-    };
-    /**
-     * Whether to enable the date range inputs
-     */
-    isRange: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * Start input label when is-range
-     */
-    startLabel: {
-        type: StringConstructor;
-    };
-    /**
-     * End input label when is-range
-     */
-    endLabel: {
-        type: StringConstructor;
-    };
-    /**
-     * The logical tab order of the input.
-     * Defaults to 0
-     */
-    tabindex: {
-        type: StringConstructor;
-        default: string;
-    };
-    /**
-     * Whether the input is rounded.
-     * Defaults to false
-     */
-    rounded: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * Enables the required asterisk. (UI only)
-     */
-    required: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * Enable the error section UI.
-     * Defaults to true
-     */
-    enableErrors: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * The minimum selectable date
-     */
-    minDate: {
-        type: PropType<FwDatePickerProps["minDate"]>;
-    };
-    /**
-     * The maximum selectable date
-     */
-    maxDate: {
-        type: PropType<FwDatePickerProps["maxDate"]>;
-    };
-    /**
-     * Validation rules. Accepts an object, string schema or validation function.
-     */
-    rules: {
-        type: PropType<FwDatePickerProps["rules"]>;
-    };
-}, {
-    uuid: string;
-    inputBaseClass: vue.Ref<string>;
-    dateModel: vue.WritableComputedRef<FwDatePickerModel>;
-    errors: vue.Ref<string[]>;
-    errorMessage: vue.Ref<string | undefined>;
-    meta: vee_validate.FieldMeta<unknown>;
-    fieldVal: vue.Ref<unknown>;
-    primaryFade5: string;
-    primaryFade10: string;
-    primaryFade20: string;
-    primaryFade30: string;
-    primaryFade40: string;
-    primaryFade50: string;
-    primaryFade70: string;
-    primaryFade80: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    /**
-     * The date-picker v-model
-     */
-    modelValue: {
-        type: PropType<FwDatePickerModel>;
-        default: null;
-    };
-    /**
-     * The name of the input field. Must be unique per form.
-     */
-    name: {
-        type: StringConstructor;
-        required: true;
-    };
-    /**
-     * Label for the input. Also renders to an aria-label attribute
-     */
-    label: {
-        type: StringConstructor;
-    };
-    /**
-     * The placeholder text of the input
-     */
-    placeholder: {
-        type: StringConstructor;
-    };
-    /**
-     * The placeholder text of the starting range input
-     */
-    startPlaceholder: {
-        type: StringConstructor;
-    };
-    /**
-     * The placeholder text of the ending range input
-     */
-    endPlaceholder: {
-        type: StringConstructor;
-    };
-    /**
-     * Whether to enable the date range inputs
-     */
-    isRange: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * Start input label when is-range
-     */
-    startLabel: {
-        type: StringConstructor;
-    };
-    /**
-     * End input label when is-range
-     */
-    endLabel: {
-        type: StringConstructor;
-    };
-    /**
-     * The logical tab order of the input.
-     * Defaults to 0
-     */
-    tabindex: {
-        type: StringConstructor;
-        default: string;
-    };
-    /**
-     * Whether the input is rounded.
-     * Defaults to false
-     */
-    rounded: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * Enables the required asterisk. (UI only)
-     */
-    required: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * Enable the error section UI.
-     * Defaults to true
-     */
-    enableErrors: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    /**
-     * The minimum selectable date
-     */
-    minDate: {
-        type: PropType<FwDatePickerProps["minDate"]>;
-    };
-    /**
-     * The maximum selectable date
-     */
-    maxDate: {
-        type: PropType<FwDatePickerProps["maxDate"]>;
-    };
-    /**
-     * Validation rules. Accepts an object, string schema or validation function.
-     */
-    rules: {
-        type: PropType<FwDatePickerProps["rules"]>;
-    };
-}>> & {
-    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {
-    modelValue: FwDatePickerModel;
-    isRange: boolean;
-    tabindex: string;
-    rounded: boolean;
-    required: boolean;
-    enableErrors: boolean;
-}, {}>;
+declare const __default__$1: DefineComponent<FwDatePickerProps>;
 
-declare const __default__: vue.DefineComponent<{
+declare const __default__: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The title of the popover
      */
@@ -3009,10 +3985,10 @@ declare const __default__: vue.DefineComponent<{
         validator: (value: string) => boolean;
     };
     /**
-     * The input event which causes the popover to show. Accepts 'click' and 'hover'
+     * The input event which causes the popover to show. Accepts 'click' and 'hover' & 'focus'
      */
     trigger: {
-        type: StringConstructor;
+        type: PropType<FwPopoverProps["trigger"]>;
         default: string;
         validator: (value: string) => boolean;
     };
@@ -3052,22 +4028,17 @@ declare const __default__: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    targetElement: vue.Ref<HTMLElement | undefined>;
-    contentElement: vue.Ref<HTMLElement | undefined>;
+}>, {
+    targetElement: vue.Ref<HTMLElement | null, HTMLElement | null>;
+    contentElement: vue.Ref<HTMLElement | null, HTMLElement | null>;
     contentElementId: string;
-    computedVisible: vue.ComputedRef<string | false | vue.Slot<any> | undefined>;
-    onHover: () => void;
-    onClick: () => void;
+    computedVisible: vue.ComputedRef<boolean>;
+    onEnter: () => void;
     onLeave: () => void;
+    onClick: () => void;
     autoCloseContent: (e: Event) => void;
-    visible: vue.Ref<boolean>;
     spacingSize: vue.ComputedRef<"12px" | "2px">;
-    debounce: {
-        <T extends (...args: any) => any>(func: T, wait: number | undefined, options: lodash.DebounceSettingsLeading): lodash.DebouncedFuncLeading<T>;
-        <T extends (...args: any) => any>(func: T, wait?: number, options?: lodash.DebounceSettings): lodash.DebouncedFunc<T>;
-    };
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "closed"[], "closed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "closed"[], "closed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The title of the popover
      */
@@ -3090,10 +4061,10 @@ declare const __default__: vue.DefineComponent<{
         validator: (value: string) => boolean;
     };
     /**
-     * The input event which causes the popover to show. Accepts 'click' and 'hover'
+     * The input event which causes the popover to show. Accepts 'click' and 'hover' & 'focus'
      */
     trigger: {
-        type: StringConstructor;
+        type: PropType<FwPopoverProps["trigger"]>;
         default: string;
         validator: (value: string) => boolean;
     };
@@ -3133,20 +4104,20 @@ declare const __default__: vue.DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
     onClosed?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     placement: "top" | "right" | "bottom" | "left" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
     position: "fixed" | "absolute";
-    trigger: string;
+    trigger: "click" | "hover" | "focus";
     showOnTop: boolean;
     closeOnClick: boolean;
     closeOnClickOutside: boolean;
     textAlign: string;
     showArrow: boolean;
-}, {}>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$3: vue.DefineComponent<{
+declare const _default$3: vue.DefineComponent<vue.ExtractPropTypes<{
     /**
      * The accepted file types for the media picker
      */
@@ -3155,7 +4126,7 @@ declare const _default$3: vue.DefineComponent<{
         default: string;
     };
     /**
-     * The maximum file size in bytes
+     * The maximum file size in bytes. Default 8 MB
      */
     maxFileSize: {
         type: NumberConstructor;
@@ -3187,28 +4158,28 @@ declare const _default$3: vue.DefineComponent<{
         type: StringConstructor;
         default: string;
     };
-}, {
+}>, {
     previewImageUrl: vue.ComputedRef<string | undefined>;
-    fileInput: vue.Ref<HTMLInputElement | null>;
-    editorCanvas: vue.Ref<HTMLCanvasElement | null>;
-    isSelectMediaModalOpen: vue.Ref<boolean>;
-    isEditMediaModalOpen: vue.Ref<boolean>;
+    fileInput: vue.Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    editorCanvas: vue.Ref<HTMLCanvasElement | null, HTMLCanvasElement | null>;
+    isSelectMediaModalOpen: vue.Ref<boolean, boolean>;
+    isEditMediaModalOpen: vue.Ref<boolean, boolean>;
     acceptedFileTypesText: vue.ComputedRef<string>;
     maxFileSizeText: vue.ComputedRef<string>;
     openFilePicker: () => void | undefined;
     fileSelected: (event: Event) => void;
-    dragging: vue.Ref<boolean>;
-    loading: vue.Ref<boolean>;
+    dragging: vue.Ref<boolean, boolean>;
+    loading: vue.Ref<boolean, boolean>;
     dragDropFile: (event: DragEvent) => void;
-    isInvalidFile: vue.ComputedRef<boolean | null>;
+    isInvalidFile: vue.ComputedRef<boolean>;
     showEditor: () => void;
     change: () => void;
     reset: () => void;
     save: () => Promise<void>;
-    startEditImage: ({ button, offsetX, offsetY }: MouseEvent) => void;
-    stopEditImage: () => void;
-    editImage: ({ offsetX, offsetY }: MouseEvent) => void;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "selected"[], "selected", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    startEditImage: (e: PointerEvent) => void;
+    stopEditImage: (e: PointerEvent) => void;
+    editImage: (e: PointerEvent) => void;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "selected"[], "selected", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     /**
      * The accepted file types for the media picker
      */
@@ -3217,7 +4188,7 @@ declare const _default$3: vue.DefineComponent<{
         default: string;
     };
     /**
-     * The maximum file size in bytes
+     * The maximum file size in bytes. Default 8 MB
      */
     maxFileSize: {
         type: NumberConstructor;
@@ -3249,16 +4220,25 @@ declare const _default$3: vue.DefineComponent<{
         type: StringConstructor;
         default: string;
     };
-}>> & {
+}>> & Readonly<{
     onSelected?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     acceptedFileTypes: string;
     maxFileSize: number;
     uploadHeaderText: string;
     editHeaderText: string;
-}, {}>;
+}, {}, {
+    FwModal: vue.ComponentOptions;
+    FwButton: vue.ComponentOptions;
+    ArrowRotateSvg: VueConstructor<Vue>;
+    CloudArrowUpSvg: VueConstructor<Vue>;
+    GuideSvg: VueConstructor<Vue>;
+    LoadingSvg: VueConstructor<Vue>;
+    PenSvg: VueConstructor<Vue>;
+    PlusSvg: VueConstructor<Vue>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default$2: vue.DefineComponent<{
+declare const _default$2: vue.DefineComponent<vue.ExtractPropTypes<{
     min: {
         type: NumberConstructor;
         default: number;
@@ -3279,13 +4259,16 @@ declare const _default$2: vue.DefineComponent<{
         type: NumberConstructor;
         default: null;
     };
-}, {
-    minimumValue: vue.WritableComputedRef<number>;
-    maximumValue: vue.WritableComputedRef<number>;
+}>, {
+    minLocal: vue.Ref<number, number>;
+    maxLocal: vue.Ref<number, number>;
     minPercentage: vue.ComputedRef<number>;
     maxPercentage: vue.ComputedRef<number>;
     clippingPoint: vue.ComputedRef<boolean>;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:minValue" | "update:maxValue")[], "update:minValue" | "update:maxValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    trackStyle: vue.ComputedRef<{
+        background: string;
+    }>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:minValue" | "update:maxValue")[], "update:minValue" | "update:maxValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
     min: {
         type: NumberConstructor;
         default: number;
@@ -3306,48 +4289,23 @@ declare const _default$2: vue.DefineComponent<{
         type: NumberConstructor;
         default: null;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:minValue"?: ((...args: any[]) => any) | undefined;
     "onUpdate:maxValue"?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     min: number;
     max: number;
     step: number;
     minValue: number;
     maxValue: number;
-}, {}>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare const _default$1: vue.DefineComponent<{
-    /**
-     * The transaction title of the chart
-     */
-    title: {
-        type: StringConstructor;
-    };
-    /**
-     * The marker label of the y-axis transactions
-     */
-    yMarker: {
-        type: StringConstructor;
-    };
-    /**
-     * The x axis data.
-     */
-    x: {
-        type: PropType<FwBarChartProps["x"]>;
-    };
-    /**
-     * The y axis data.
-     */
-    y: {
-        type: PropType<FwBarChartProps["y"]>;
-    };
-    /**
-     * The x and y axis data.
-     */
-    graphData: {
-        type: PropType<FwBarChartProps["graphData"]>;
-    };
+    title?: string | undefined;
+    yMarker?: string | undefined;
+    x?: string[] | string | undefined;
+    y?: (string | number)[] | string | undefined;
+    graphData?: FwBarGraphData[] | string | undefined;
 }, {
     uuid: string;
     xModel: vue.ComputedRef<string[]>;
@@ -3365,40 +4323,17 @@ declare const _default$1: vue.DefineComponent<{
     }>;
     bgColor: string;
     primaryFade: string;
-}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    /**
-     * The transaction title of the chart
-     */
-    title: {
-        type: StringConstructor;
-    };
-    /**
-     * The marker label of the y-axis transactions
-     */
-    yMarker: {
-        type: StringConstructor;
-    };
-    /**
-     * The x axis data.
-     */
-    x: {
-        type: PropType<FwBarChartProps["x"]>;
-    };
-    /**
-     * The y axis data.
-     */
-    y: {
-        type: PropType<FwBarChartProps["y"]>;
-    };
-    /**
-     * The x and y axis data.
-     */
-    graphData: {
-        type: PropType<FwBarChartProps["graphData"]>;
-    };
-}>>, {}, {}>;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{
+    title?: string | undefined;
+    yMarker?: string | undefined;
+    x?: string[] | string | undefined;
+    y?: (string | number)[] | string | undefined;
+    graphData?: FwBarGraphData[] | string | undefined;
+}> & Readonly<{}>, {}, {}, {
+    BarChart: vue_chartjs_dist_types.TypedChartComponent<"bar", (number | [number, number] | null)[] | vue_chartjs_dist_typedCharts.ExtendedDataPoint[], unknown>;
+}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
-declare const _default: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
 
 declare interface ModalServiceProps extends Omit<FwModalProps, 'modelValue'> {
     onConfirm?: () => void;
@@ -3437,6 +4372,7 @@ declare const useColours: () => {
     primaryFade90: string;
     brandBg1Fade95: string;
     colorErrorTextFade5: string;
+    colorSuccessNew: string;
 };
 
 declare const getVueComponentHtml: (component: Component, props: ComponentCustomProps) => string;
@@ -3445,4 +4381,4 @@ declare const install: Exclude<Plugin['install'], undefined>;
 
 declare module '@frollo/frollo-web-ui/icons' { }
 
-export { type ButtonAnimation, type ButtonDefinition, type ButtonDefinitionList, type ButtonSize, type ButtonSizes, type ButtonTypeAttribute, type ButtonVariantName, __default__$6 as FwAccordion, type FwAccordionProps, _default$g as FwAlert, _default$1 as FwBarChart, type FwBarChartProps, type FwBarGraphData, _default$h as FwButton, type FwButtonProps, __default__$a as FwCard, type FwCardProps, __default__$c as FwCheckbox, type FwCheckboxProps, __default__$1 as FwDatePicker, type FwDatePickerModel, type FwDatePickerProps, __default__$3 as FwDrawer, type FwDrawerProps, __default__$b as FwDropdown, type FwDropdownOption, type FwDropdownProps, __default__$5 as FwImage, type FwImageProps, __default__$d as FwInput, type FwInputProps, type FwInputType, __default__$4 as FwLoadingBar, _default$9 as FwLoadingCard, _default$7 as FwLoadingDots, _default$8 as FwLoadingTable, _default$3 as FwMediaPicker, type FwMediaPickerProps, __default__$9 as FwModal, type FwModalProps, _default$f as FwNavigationMenu, type FwNavigationMenuProps, __default__ as FwPopover, type FwPopoverProps, _default$c as FwProgressBar, __default__$2 as FwProviderList, type FwProviderListItem, type FwProviderListProps, _default$4 as FwSidebarMenu, type FwSidebarMenuItem, type FwSidebarMenuProps, _default$2 as FwSlider, _default as FwSuccessAnimation, _default$i as FwSwitch, type FwSwitchProps, _default$d as FwTab, __default__$7 as FwTable, type FwTableFormatFunction, _default$b as FwTableHead, type FwTableItem, type FwTableItemOptions, type FwTableProps, _default$a as FwTableRow, type FwTableSort, type FwTableSortFunction, _default$e as FwTabs, type FwTabsProps, __default__$8 as FwTag, type FwTagProps, _default$6 as FwToast, type FwToastProps, _default$5 as FwTransactionsCard, type FwTransactionsCardProps, type ModalServiceProps, type NavMenuItem, type ProgressBarStep, type TabsState, type TagDefinition, type TagDefinitionList, type TagSize, type TagSizes, type TagVariantName, type ToastPosition, type ToastServiceProps, type ToastType, type ToastTypes, install as default, getHexWithOpacity, getVueComponentHtml, modalService, toastService, useColours };
+export { type ButtonAnimation, type ButtonDefinition, type ButtonDefinitionList, type ButtonSize, type ButtonSizes, type ButtonTypeAttribute, type ButtonVariantName, __default__$5 as FwAccordion, type FwAccordionProps, _default$h as FwAlert, _default$1 as FwBarChart, type FwBarChartProps, type FwBarGraphData, _default$i as FwButton, type FwButtonProps, __default__$9 as FwCard, type FwCardProps, __default__$b as FwCheckbox, type FwCheckboxProps, __default__$1 as FwDatePicker, type FwDatePickerModel, type FwDatePickerProps, __default__$3 as FwDrawer, type FwDrawerProps, __default__$a as FwDropdown, type FwDropdownOption, type FwDropdownProps, __default__$4 as FwImage, type FwImageProps, __default__$c as FwInput, type FwInputProps, type FwInputType, _default$a as FwLoadingBar, _default$9 as FwLoadingCard, _default$7 as FwLoadingDots, _default$8 as FwLoadingTable, _default$3 as FwMediaPicker, type FwMediaPickerProps, __default__$8 as FwModal, type FwModalProps, _default$g as FwNavigationMenu, type FwNavigationMenuProps, __default__ as FwPopover, type FwPopoverProps, _default$d as FwProgressBar, __default__$2 as FwProviderList, type FwProviderListItem, type FwProviderListProps, _default$4 as FwSidebarMenu, type FwSidebarMenuItem, type FwSidebarMenuProps, _default$2 as FwSlider, _default as FwSuccessAnimation, _default$j as FwSwitch, type FwSwitchProps, _default$e as FwTab, type FwTabProps, __default__$6 as FwTable, type FwTableCellComponentHandlers, type FwTableCellComponentProps, type FwTableColumnMeta, type FwTableFormatFunction, _default$c as FwTableHead, type FwTableItem, type FwTableItemOptions, type FwTableItemValue, type FwTableProps, _default$b as FwTableRow, type FwTableSort, type FwTableSortFunction, _default$f as FwTabs, type FwTabsProps, __default__$7 as FwTag, type FwTagProps, _default$6 as FwToast, type FwToastProps, _default$5 as FwTransactionsCard, type FwTransactionsCardProps, type ModalServiceProps, type NavMenuItem, type ProgressBarStep, type TabRecord, type TabsApi, type TagDefinition, type TagDefinitionList, type TagSize, type TagSizes, type TagVariantName, type ToastPosition, type ToastServiceProps, type ToastType, type ToastTypes, install as default, getHexWithOpacity, getVueComponentHtml, modalService, toastService, useColours };