import * as vue 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_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';

type FwInputType = 'text' | 'password' | 'email' | 'tel' | 'time' | 'url' | 'week' | 'month';
declare interface FwInputProps {
    value: string;
    name: string;
    disableNamePrefix?: boolean;
    inputId?: string;
    inputClass?: string;
    type?: FwInputType;
    label?: string;
    placeholder?: string;
    rules?: RuleExpression<unknown>;
    readonly?: boolean;
    hint?: string;
    autocomplete?: string;
    tabindex?: string;
    rounded?: boolean;
    enableErrors?: boolean;
    maxLength?: number;
    required?: boolean;
    invalidate?: boolean;
}
declare interface InputTag {
    name: string;
    id: number;
}

declare const __default__$c: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The input v-model
     */
    modelValue: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The name of the input field. Must be unique per form.
     */
    name: {
        type: StringConstructor;
        required: true;
    };
    /**
     * Whether to disable the name prefix for the input field.
     */
    disableNamePrefix: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The custom id of the input field. Will auto-generate one if not provided.
     */
    inputId: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The custom class for the input field.
     */
    inputClass: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The input type. Accepts `text` | `password` | `email` | `tel` | `time` | `url` | `week` | `month`
     */
    type: {
        type: PropType<FwInputType>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Label for the input. Also renders to an aria-label attribute
     */
    label: {
        type: StringConstructor;
    };
    /**
     * The placeholder text of the input
     */
    placeholder: {
        type: StringConstructor;
    };
    /**
     * Validation rules. Accepts an object, string schema or validation function.
     */
    rules: {
        type: PropType<FwInputProps["rules"]>;
    };
    /**
     * Converts the input into a readonly disabled field
     */
    readonly: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * The autocomplete input attribute
     */
    autocomplete: {
        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;
    };
    /**
     * Enable the error section UI.
     * Defaults to true
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The inputs `maxlength` attribute.
     */
    maxLength: {
        type: NumberConstructor;
    };
    /**
     * Enables the required asterisk. (UI only)
     * Use the field validation rule to validate input.
     */
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Force triggers the error UI.
     * Use the field validation rule to validate/invalidate input.
     */
    invalidate: {
        type: BooleanConstructor;
        required: false;
    };
    /**
     * Enable tags within the input borders
     * Defaults to false
     */
    enableTags: {
        type: BooleanConstructor;
        default: boolean;
    };
    tags: {
        type: PropType<InputTag[]>;
        required: false;
    };
}>, {
    inputBaseClass: vue.Ref<string, string>;
    inputValue: vue.WritableComputedRef<string, string>;
    tagsValue: vue.WritableComputedRef<InputTag[] | undefined, InputTag[] | undefined>;
    onFocus: (e: FocusEvent) => void;
    onBlur: (e: FocusEvent) => void;
    primaryFade5: string;
    colorErrorTextFade5: string;
    handleTagDismiss: (id: number) => void;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "focus" | "blur" | "update:tags")[], "update:modelValue" | "focus" | "blur" | "update:tags", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The input v-model
     */
    modelValue: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The name of the input field. Must be unique per form.
     */
    name: {
        type: StringConstructor;
        required: true;
    };
    /**
     * Whether to disable the name prefix for the input field.
     */
    disableNamePrefix: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The custom id of the input field. Will auto-generate one if not provided.
     */
    inputId: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The custom class for the input field.
     */
    inputClass: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The input type. Accepts `text` | `password` | `email` | `tel` | `time` | `url` | `week` | `month`
     */
    type: {
        type: PropType<FwInputType>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Label for the input. Also renders to an aria-label attribute
     */
    label: {
        type: StringConstructor;
    };
    /**
     * The placeholder text of the input
     */
    placeholder: {
        type: StringConstructor;
    };
    /**
     * Validation rules. Accepts an object, string schema or validation function.
     */
    rules: {
        type: PropType<FwInputProps["rules"]>;
    };
    /**
     * Converts the input into a readonly disabled field
     */
    readonly: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * The autocomplete input attribute
     */
    autocomplete: {
        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;
    };
    /**
     * Enable the error section UI.
     * Defaults to true
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The inputs `maxlength` attribute.
     */
    maxLength: {
        type: NumberConstructor;
    };
    /**
     * Enables the required asterisk. (UI only)
     * Use the field validation rule to validate input.
     */
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Force triggers the error UI.
     * Use the field validation rule to validate/invalidate input.
     */
    invalidate: {
        type: BooleanConstructor;
        required: false;
    };
    /**
     * Enable tags within the input borders
     * Defaults to false
     */
    enableTags: {
        type: BooleanConstructor;
        default: boolean;
    };
    tags: {
        type: PropType<InputTag[]>;
        required: false;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    onFocus?: ((...args: any[]) => any) | undefined;
    onBlur?: ((...args: any[]) => any) | undefined;
    "onUpdate:tags"?: ((...args: any[]) => any) | undefined;
}>, {
    modelValue: string;
    type: FwInputType;
    required: boolean;
    disableNamePrefix: boolean;
    readonly: boolean;
    tabindex: string;
    rounded: boolean;
    enableErrors: boolean;
    invalidate: boolean;
    enableTags: 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[];
        };
    });
    FwTag: vue.ComponentOptions;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare interface FwCheckboxProps {
    name: string;
    value?: string;
    label?: string;
    rules?: string | Record<string, unknown> | (() => boolean);
    hint?: string;
    enableErrors?: boolean;
    isChecked?: boolean;
    disableNamePrefix?: boolean;
    inputId?: string;
}

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.
     */
    name: {
        type: StringConstructor;
        required: true;
    };
    /**
     * The value of the input field. Must be unique per name.
     */
    value: {
        type: StringConstructor;
        required: false;
    };
    /**
     * Label for the input. Also renders to an aria-label attribute
     */
    label: {
        type: StringConstructor;
    };
    /**
     * Validation rules. Accepts an object, stringm schema or validation function.
     */
    rules: {
        type: PropType<FwCheckboxProps["rules"]>;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * Enable or disable the error hidden element
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Progmatically set the checked state of the input.
     * Used outside a FwForm element
     */
    isChecked: {
        type: BooleanConstructor;
        required: false;
        default: undefined;
    };
    /**
     * Whether to disable the name prefix for the input field.
     */
    disableNamePrefix: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The custom id of the input field. Will auto-generate one if not provided.
     */
    inputId: {
        type: StringConstructor;
        required: false;
    };
    /**
     * Whether the checkbox is disabled or not.
     */
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    uuid: string;
    primaryFade5: string;
    colorErrorTextFade5: string;
    checkboxBaseClass: string;
}, {}, {}, {}, 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.
     */
    name: {
        type: StringConstructor;
        required: true;
    };
    /**
     * The value of the input field. Must be unique per name.
     */
    value: {
        type: StringConstructor;
        required: false;
    };
    /**
     * Label for the input. Also renders to an aria-label attribute
     */
    label: {
        type: StringConstructor;
    };
    /**
     * Validation rules. Accepts an object, stringm schema or validation function.
     */
    rules: {
        type: PropType<FwCheckboxProps["rules"]>;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * Enable or disable the error hidden element
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Progmatically set the checked state of the input.
     * Used outside a FwForm element
     */
    isChecked: {
        type: BooleanConstructor;
        required: false;
        default: undefined;
    };
    /**
     * Whether to disable the name prefix for the input field.
     */
    disableNamePrefix: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The custom id of the input field. Will auto-generate one if not provided.
     */
    inputId: {
        type: StringConstructor;
        required: false;
    };
    /**
     * Whether the checkbox is disabled or not.
     */
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, {
    enableErrors: boolean;
    isChecked: boolean;
    disableNamePrefix: boolean;
    disabled: 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;
    value: string;
    image_url?: string;
    description?: string;
}
declare interface FwDropdownProps {
    name: string;
    label?: string;
    rules?: string | Record<string, unknown> | (() => boolean);
    options: FwDropdownOption[];
    hint?: string;
    placeholder?: string;
    enableErrors?: boolean;
    required?: boolean;
}

declare const __default__$a: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The select v-model
     */
    modelValue: {
        type: StringConstructor;
    };
    /**
     * 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;
    };
    /**
     * Validation rules. Accepts an object, string schema or validation function.
     */
    rules: {
        type: PropType<FwDropdownProps["rules"]>;
    };
    /**
     * An array of options for the dropdown menu.
     */
    options: {
        type: PropType<FwDropdownProps["options"]>;
        required: true;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * Custom placeholder text
     */
    placeholder: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    /**
     * Enable the error section UI.
     * Defaults to true
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Enables the required asterisk. (UI only)
     * Use the field validation rule to validate input.
     */
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    menuButtonClass: string;
    menuClass: string;
    menuItemClass: string;
    menuItemActiveClass: (option: FwDropdownOption) => "fw-dropdown--open" | "bg-none";
    errors: vue.Ref<string[], string[]>;
    errorMessage: vue.Ref<string | undefined, string | undefined>;
    meta: vee_validate.FieldMeta<unknown>;
    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;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The select v-model
     */
    modelValue: {
        type: StringConstructor;
    };
    /**
     * 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;
    };
    /**
     * Validation rules. Accepts an object, string schema or validation function.
     */
    rules: {
        type: PropType<FwDropdownProps["rules"]>;
    };
    /**
     * An array of options for the dropdown menu.
     */
    options: {
        type: PropType<FwDropdownProps["options"]>;
        required: true;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * Custom placeholder text
     */
    placeholder: {
        type: StringConstructor;
        required: false;
        default: string;
    };
    /**
     * Enable the error section UI.
     * Defaults to true
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Enables the required asterisk. (UI only)
     * Use the field validation rule to validate input.
     */
    required: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {
    required: boolean;
    placeholder: string;
    enableErrors: boolean;
}, {}, {
    ChevronDownSvg: VueConstructor<Vue>;
    FwImage: vue.ComponentOptions;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare interface FwSwitchProps {
    name: string;
    value?: string;
    rules?: string | Record<string, unknown> | (() => boolean);
    hint?: string;
    enableErrors?: boolean;
    isChecked?: boolean;
    modelValue?: boolean;
}

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.
     */
    name: {
        type: StringConstructor;
        required: true;
    };
    /**
     * The value of the input field. Must be unique per name.
     */
    value: {
        type: StringConstructor;
        required: false;
    };
    /**
     * Validation rules. Accepts an object, stringm schema or validation function.
     */
    rules: {
        type: PropType<FwSwitchProps["rules"]>;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * Enable or disable the error hidden element
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /** v-model If provided, it is the source of truth. */
    modelValue: {
        type: BooleanConstructor;
        default: undefined;
    };
    /**
     * Progmatically set the checked state of the input.
     * Used outside a FwForm element
     */
    isChecked: {
        type: BooleanConstructor;
        required: false;
    };
}>, {
    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.
     */
    name: {
        type: StringConstructor;
        required: true;
    };
    /**
     * The value of the input field. Must be unique per name.
     */
    value: {
        type: StringConstructor;
        required: false;
    };
    /**
     * Validation rules. Accepts an object, stringm schema or validation function.
     */
    rules: {
        type: PropType<FwSwitchProps["rules"]>;
    };
    /**
     * The hint text shown below the input
     */
    hint: {
        type: StringConstructor;
    };
    /**
     * Enable or disable the error hidden element
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
    /** v-model If provided, it is the source of truth. */
    modelValue: {
        type: BooleanConstructor;
        default: undefined;
    };
    /**
     * Progmatically set the checked state of the input.
     * Used outside a FwForm element
     */
    isChecked: {
        type: BooleanConstructor;
        required: false;
    };
}>> & 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__$9: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The header title of the card
     */
    title: {
        type: StringConstructor;
    };
    /**
     * Title prefix with primary color
     */
    prefixTitle: {
        type: StringConstructor;
    };
    /**
     * A `router-link` path or object
     */
    to: {
        type: (StringConstructor | ObjectConstructor)[];
    };
    /**
     * A URL to link to using a native anchor element
     */
    href: StringConstructor;
    /**
     * Whether padding should be applied around the default slot
     */
    slotPadding: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the card has a border or shadow by default
     */
    isBordered: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    componentName: vue.ComputedRef<"router-link" | "a" | "div">;
    linkClass: string;
    cardHeaderBg: string;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The header title of the card
     */
    title: {
        type: StringConstructor;
    };
    /**
     * Title prefix with primary color
     */
    prefixTitle: {
        type: StringConstructor;
    };
    /**
     * A `router-link` path or object
     */
    to: {
        type: (StringConstructor | ObjectConstructor)[];
    };
    /**
     * A URL to link to using a native anchor element
     */
    href: StringConstructor;
    /**
     * Whether padding should be applied around the default slot
     */
    slotPadding: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the card has a border or shadow by default
     */
    isBordered: {
        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 {
    text: string;
    background: string;
    border: string;
}
type ButtonDefinitionList = {
    [key in ButtonVariantName]: ButtonDefinition;
};
type ButtonSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
type ButtonSizes = {
    [key in ButtonSize]: string;
};
type ButtonTypeAttribute = 'button' | 'submit' | 'reset';
type ButtonAnimation = 'alternate' | 'fade';
declare interface FwButtonProps {
    label?: string;
    to?: string | object;
    href?: string;
    size?: ButtonSize;
    variant?: ButtonVariantName;
    buttonType?: ButtonTypeAttribute;
    animation?: ButtonAnimation;
    rounded?: boolean;
    loading?: boolean;
    external?: boolean;
}

declare const _default$i: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The label text of the button.
     * Overrides the default slot content.
     */
    label: {
        type: StringConstructor;
    };
    /**
     * A `router-link` path or object
     */
    to: {
        type: (StringConstructor | ObjectConstructor)[];
    };
    /**
     * A URL to link to using a native anchor element
     */
    href: StringConstructor;
    /**
     * The size of the button. Accepts: 'sm', 'md', 'lg', 'xl', '2xl'
     */
    size: {
        type: PropType<ButtonSize>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The colour variant of the button.
     * Accepts 'primary', 'secondary', 'tertiary', 'quaternary', 'error', 'success', 'link', 'text', 'transparent', 'gradient'
     */
    variant: {
        type: PropType<ButtonVariantName>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The type attribute of the button
     */
    buttonType: {
        type: PropType<ButtonTypeAttribute>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The animation type of the hover & focus states.
     * Accepts 'alternate' and 'fade'
     */
    animation: {
        type: PropType<ButtonAnimation>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether the button is rounded or not
     */
    rounded: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the loading animation is shown or not
     */
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the link should open in a new tab
     */
    external: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the button selected state is active
     */
    selected: {
        type: BooleanConstructor;
    };
    /**
     * Whether the button is disabled
     */
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    textColorClass: vue.ComputedRef<string>;
    bgColorClass: vue.ComputedRef<string>;
    sizeClass: vue.ComputedRef<string>;
    borderClass: vue.ComputedRef<string>;
    onClick: (e: MouseEvent | KeyboardEvent) => void;
    onMouseover: (e: MouseEvent) => void;
    onMouseout: (e: MouseEvent) => void;
    onFocusin: (e: FocusEvent) => void;
    onFocusout: (e: FocusEvent) => void;
    tagName: vue.ComputedRef<"button" | "router-link" | "a">;
    iconSize: vue.ComputedRef<{
        spacing: string;
        size: string;
    } | {
        spacing: string;
        size: string;
    } | {
        spacing: string;
        size: string;
    } | {
        spacing: string;
        size: string;
    } | {
        spacing: string;
        size: string;
    }>;
    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.
     */
    label: {
        type: StringConstructor;
    };
    /**
     * A `router-link` path or object
     */
    to: {
        type: (StringConstructor | ObjectConstructor)[];
    };
    /**
     * A URL to link to using a native anchor element
     */
    href: StringConstructor;
    /**
     * The size of the button. Accepts: 'sm', 'md', 'lg', 'xl', '2xl'
     */
    size: {
        type: PropType<ButtonSize>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The colour variant of the button.
     * Accepts 'primary', 'secondary', 'tertiary', 'quaternary', 'error', 'success', 'link', 'text', 'transparent', 'gradient'
     */
    variant: {
        type: PropType<ButtonVariantName>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The type attribute of the button
     */
    buttonType: {
        type: PropType<ButtonTypeAttribute>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The animation type of the hover & focus states.
     * Accepts 'alternate' and 'fade'
     */
    animation: {
        type: PropType<ButtonAnimation>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether the button is rounded or not
     */
    rounded: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the loading animation is shown or not
     */
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the link should open in a new tab
     */
    external: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the button selected state is active
     */
    selected: {
        type: BooleanConstructor;
    };
    /**
     * Whether the button is disabled
     */
    disabled: {
        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;
    animation: ButtonAnimation;
    rounded: boolean;
    loading: boolean;
    external: boolean;
    selected: boolean;
    disabled: boolean;
}, {}, {
    LoadingSvg: VueConstructor<Vue>;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

type AlertVariantName = 'success' | 'error';

declare const _default$h: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The colour variant of the alert element.
     * Accepts 'success', 'error'
     */
    variant: {
        type: PropType<AlertVariantName>;
        required: true;
        validator: (value: string) => boolean;
    };
    /**
     * Disables the icon element.
     */
    disableIcon: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    visible: vue.Ref<boolean, boolean>;
    bgClass: vue.ComputedRef<"bg-brand-error-bg" | "bg-brand-success-bg">;
    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'
     */
    variant: {
        type: PropType<AlertVariantName>;
        required: true;
        validator: (value: string) => boolean;
    };
    /**
     * Disables the icon element.
     */
    disableIcon: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{}>, {
    disableIcon: boolean;
}, {}, {
    CheckSvg: VueConstructor<Vue>;
    AlertSvg: VueConstructor<Vue>;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare interface NavMenuItem {
    to?: string | object;
    href?: string;
    label: string;
    external?: boolean;
    onClick?: () => void;
    disabled?: boolean;
}
declare interface FwNavigationMenuProps {
    menuItems: NavMenuItem[];
    additionalMenuItems?: NavMenuItem[];
    /** @deprecated Use `actionLabels` instead. */
    actionLabel?: string;
    actionMenuItems?: NavMenuItem[];
    containerClass?: string;
    menuEnabled?: boolean;
    authenticated?: boolean;
    paddingClasses?: string;
    transparent?: boolean;
    logoSrc?: string;
    mobileLogoSrc?: string;
    reversedDesktopNavButton?: boolean;
    forcedLogoSrc?: string;
}

declare const _default$g: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * An array of menu items
     * `{ to?: string | object; href?: string; label: string; external?: boolean; }`
     */
    menuItems: {
        type: PropType<FwNavigationMenuProps["menuItems"]>;
    };
    /**
     * An array of menu items
     * `{ to?: string | object; href?: string; label: string; external?: boolean; }`
     */
    additionalMenuItems: {
        type: PropType<FwNavigationMenuProps["menuItems"] | null>;
    };
    /**
     * @deprecated Use `actionLabels` instead.
     * The label for the action button. Emits the `action` event on click.
     */
    actionLabel: {
        type: StringConstructor;
    };
    /**
     * An array of action items shown in the user popover.
     * `{ label: string; onClick?: () => void; }`
     */
    actionMenuItems: {
        type: PropType<FwNavigationMenuProps["actionMenuItems"]>;
    };
    /**
     * The class for the container wrapper.
     */
    containerClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Whether menu items are enabled or disabled.
     */
    menuEnabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the route is an authenticated route.
     */
    authenticated: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Padding for the inner menu, should match the sidebar menu width.
     */
    paddingClasses: {
        type: StringConstructor;
    };
    /**
     * Whether the background is transparent
     */
    transparent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The logo image source url for the desktop menu.
     */
    logoSrc: {
        type: StringConstructor;
    };
    /**
     * The logo image source url for the mobile menu.
     */
    mobileLogoSrc: {
        type: StringConstructor;
    };
    /**
     * Whether to reverse the colours of the desktop navigation menu items.
     */
    reversedDesktopNavButton: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether to force the logo to be displayed (forced for mobile themes that don't need a menu)
     */
    forcedLogoSrc: {
        type: StringConstructor;
    };
}>, {
    parsedMenuItems: vue.ShallowRef<NavMenuItem[], NavMenuItem[]>;
    parsedAdditionalMenuItems: vue.ShallowRef<NavMenuItem[], NavMenuItem[]>;
    mergedActionMenuItems: vue.ComputedRef<NavMenuItem[]>;
    mobileMenuClass: vue.Ref<string, string>;
    isMobileMenuOpen: vue.Ref<boolean, boolean>;
    toggleMobileMenu: () => boolean;
}, {}, {}, {}, 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; }`
     */
    menuItems: {
        type: PropType<FwNavigationMenuProps["menuItems"]>;
    };
    /**
     * An array of menu items
     * `{ to?: string | object; href?: string; label: string; external?: boolean; }`
     */
    additionalMenuItems: {
        type: PropType<FwNavigationMenuProps["menuItems"] | null>;
    };
    /**
     * @deprecated Use `actionLabels` instead.
     * The label for the action button. Emits the `action` event on click.
     */
    actionLabel: {
        type: StringConstructor;
    };
    /**
     * An array of action items shown in the user popover.
     * `{ label: string; onClick?: () => void; }`
     */
    actionMenuItems: {
        type: PropType<FwNavigationMenuProps["actionMenuItems"]>;
    };
    /**
     * The class for the container wrapper.
     */
    containerClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Whether menu items are enabled or disabled.
     */
    menuEnabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the route is an authenticated route.
     */
    authenticated: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Padding for the inner menu, should match the sidebar menu width.
     */
    paddingClasses: {
        type: StringConstructor;
    };
    /**
     * Whether the background is transparent
     */
    transparent: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The logo image source url for the desktop menu.
     */
    logoSrc: {
        type: StringConstructor;
    };
    /**
     * The logo image source url for the mobile menu.
     */
    mobileLogoSrc: {
        type: StringConstructor;
    };
    /**
     * Whether to reverse the colours of the desktop navigation menu items.
     */
    reversedDesktopNavButton: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether to force the logo to be displayed (forced for mobile themes that don't need a menu)
     */
    forcedLogoSrc: {
        type: StringConstructor;
    };
}>> & Readonly<{
    onAction?: ((...args: any[]) => any) | undefined;
}>, {
    containerClass: string;
    menuEnabled: boolean;
    authenticated: boolean;
    transparent: boolean;
    reversedDesktopNavButton: boolean;
}, {}, {
    FwButton: vue.ComponentOptions;
    FwPopover: vue.ComponentOptions;
    UserSvg: VueConstructor<Vue>;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

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$f: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The active tab v-model
     */
    modelValue: {
        type: NumberConstructor;
        required: true;
    };
}>, {
    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
     */
    modelValue: {
        type: NumberConstructor;
        required: true;
    };
}>> & Readonly<{
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}>, {}, {}, {
    FwButton: vue.ComponentOptions;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const _default$e: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The label of the tab component used as the button panel label
     */
    label: {
        type: StringConstructor;
        required: true;
    };
}>, {
    isActive: vue.ComputedRef<boolean>;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The label of the tab component used as the button panel label
     */
    label: {
        type: StringConstructor;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare interface FwCardProps {
    title?: string;
    prefixTitle?: string;
    to?: string | object;
    href?: string;
    slotPadding?: boolean;
    isBordered?: boolean;
}

declare interface FwModalProps {
    modelValue: boolean;
    header?: string;
    element?: string;
    body?: string;
    role?: string;
    showCancel?: boolean;
    showConfirm?: boolean;
    cancelButtonText?: string;
    cancelButtonType?: ButtonVariantName;
    confirmButtonText?: string;
    confirmButtonType?: ButtonVariantName;
    padding?: boolean;
    showCloseButton?: boolean;
    containerClass?: string;
    footerClass?: string;
}

declare interface ProgressBarStep {
    label: string;
    position: number;
    subSteps: number;
}

type TagVariantName = 'primary' | 'secondary' | 'tertiary' | 'quaternary' | 'alert' | 'error' | 'success';
declare interface TagDefinition {
    text: string;
    background: string;
    iconButtonType: FwButtonProps['variant'];
}
type TagDefinitionList = {
    [key in TagVariantName]: TagDefinition;
};
type TagSize = 'xs' | 'sm' | 'md';
type TagSizes = {
    [key in TagSize]: string;
};
declare interface FwTagProps {
    size?: TagSize;
    variant?: TagVariantName;
}

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[];
    options?: FwTableItemOptions;
    loading?: boolean;
    clickableRows?: boolean;
    autoSortColumn?: number;
    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 {
    title?: string;
    titleClass?: string;
    suffixTitle?: string;
    isOpened?: boolean;
    iconPositionStart?: boolean;
    isArrow?: boolean;
    buttonPadding?: string;
    borderStyle?: string;
}

declare interface FwImageProps {
    src?: string;
    alt?: string;
    type?: 'native' | 'background';
    rounded?: boolean;
    imageClass?: string;
    threshold?: number;
    enableErrors?: boolean;
}

type ToastType = 'success' | 'error' | 'warning';
type ToastTypes = {
    [key in ToastType]: string;
};
type ToastPosition = 'top' | 'bottom' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
declare interface FwToastProps {
    modelValue: boolean;
    type?: ToastType;
    position?: ToastPosition;
    content?: string;
    element?: string;
    timeout?: number;
}

declare interface FwTransactionsCardProps {
    title: string;
    subTitle?: string;
    imageUrl?: string;
    amount?: string;
}

declare interface FwBarGraphData {
    name: string;
    value: string | number;
}
declare interface FwBarChartProps {
    title?: string;
    yMarker?: string;
    x?: string[] | string;
    y?: (string | number)[] | string;
    graphData?: FwBarGraphData[] | string;
}

declare interface FwSidebarMenuItem {
    to?: string | object;
    href?: string;
    label: string;
    external?: boolean;
    disabled?: boolean;
    onClick?: () => void;
    modelValue?: boolean;
}
declare interface FwSidebarMenuProps {
    modelValue: boolean;
    menuItems: FwSidebarMenuItem[];
    toggleButtonClass?: string;
    openWidth?: string;
    closedWidth?: string;
    toggleButtonVariant?: ButtonVariantName;
}

declare interface FwDrawerProps {
    modelValue: boolean;
    header?: string;
    body?: string;
    role?: string;
    showCancel?: boolean;
    showConfirm?: boolean;
    cancelButtonText?: string;
    cancelButtonType?: ButtonVariantName;
    confirmButtonText?: string;
    confirmButtonType?: ButtonVariantName;
}

declare interface FwProviderListItem {
    status: 'supported' | 'outage';
    name: string;
    image_url: string;
}
declare interface FwProviderListProps {
    heading: string;
    items: FwProviderListItem[];
    searchPlaceholder?: string;
    tableHeaderName?: string;
}

type FwDatePickerModel = string | Date | {
    start: string | Date;
    end: string | Date;
} | null;
declare interface FwDatePickerProps {
    modelValue: FwDatePickerModel;
    name: string;
    label?: string;
    placeholder?: string;
    isRange?: boolean;
    startLabel?: string;
    endLabel?: string;
    startPlaceholder?: string;
    endPlaceholder?: string;
    tabindex?: string;
    rounded?: boolean;
    required?: boolean;
    maxDate?: string | Date;
    minDate?: string | Date;
    rules?: string | Record<string, unknown> | (() => boolean);
    enableErrors?: boolean;
}

interface FwPopoverProps {
    title: string;
    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';
    trigger: 'click' | 'hover' | 'focus';
    position: 'fixed' | 'absolute';
    closeOnClick?: boolean;
    closeOnClickOutside?: boolean;
    showOnTop?: boolean;
    showArrow?: boolean;
    textAlign?: 'center' | 'left' | 'right';
}

declare interface FwMediaPickerProps {
    acceptedFileTypes?: string;
    maxFileSize?: number;
    imageUrl?: string;
    title?: string;
    uploadHeaderText?: string;
    editHeaderText?: string;
}

declare const __default__$8: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The modal's v-model. Controls the visibility of the modal.
     */
    modelValue: {
        type: BooleanConstructor;
    };
    /**
     * The header title of the modal
     */
    header: {
        type: StringConstructor;
    };
    /**
     * The element to attach the modal too. Defaults to `#app` element.
     */
    element: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The body description of the modal
     */
    body: {
        type: StringConstructor;
    };
    /**
     * The aria role of the modal container. Defaults to `dialog`
     */
    role: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Whether to show the cancel button
     */
    showCancel: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether to show the confirm button
     */
    showConfirm: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Custom text for the cancel button
     */
    cancelButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the cancel button
     */
    cancelButtonType: {
        type: PropType<FwModalProps["cancelButtonType"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Custom text for the confirm button
     */
    confirmButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the confirm button
     */
    confirmButtonType: {
        type: PropType<FwModalProps["confirmButtonType"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Icon name for the confirm button
     */
    confirmIconName: {
        type: StringConstructor;
    };
    /**
     * Whether the confirm button loading animation is showing or not
     */
    confirmLoading: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Controls the outer padding of the modal
     */
    padding: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Controls the visibility of the 'X' close button.
     */
    showCloseButton: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Custom class for the modal container.
     */
    containerClass: {
        type: StringConstructor;
    };
    /**
     * Custom class for the footer container.
     */
    footerClass: {
        type: StringConstructor;
    };
    /**
     * Banner Image Url source
     */
    bannerUrl: {
        type: StringConstructor;
    };
}>, {
    isOpen: vue.ComputedRef<boolean>;
    uuid: `${string}-${string}-${string}-${string}-${string}`;
    isMounted: vue.Ref<boolean, boolean>;
    modalBgColour: string;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("cancel" | "confirm")[], "cancel" | "confirm", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The modal's v-model. Controls the visibility of the modal.
     */
    modelValue: {
        type: BooleanConstructor;
    };
    /**
     * The header title of the modal
     */
    header: {
        type: StringConstructor;
    };
    /**
     * The element to attach the modal too. Defaults to `#app` element.
     */
    element: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The body description of the modal
     */
    body: {
        type: StringConstructor;
    };
    /**
     * The aria role of the modal container. Defaults to `dialog`
     */
    role: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Whether to show the cancel button
     */
    showCancel: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether to show the confirm button
     */
    showConfirm: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Custom text for the cancel button
     */
    cancelButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the cancel button
     */
    cancelButtonType: {
        type: PropType<FwModalProps["cancelButtonType"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Custom text for the confirm button
     */
    confirmButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the confirm button
     */
    confirmButtonType: {
        type: PropType<FwModalProps["confirmButtonType"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Icon name for the confirm button
     */
    confirmIconName: {
        type: StringConstructor;
    };
    /**
     * Whether the confirm button loading animation is showing or not
     */
    confirmLoading: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Controls the outer padding of the modal
     */
    padding: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Controls the visibility of the 'X' close button.
     */
    showCloseButton: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Custom class for the modal container.
     */
    containerClass: {
        type: StringConstructor;
    };
    /**
     * Custom class for the footer container.
     */
    footerClass: {
        type: StringConstructor;
    };
    /**
     * Banner Image Url source
     */
    bannerUrl: {
        type: StringConstructor;
    };
}>> & Readonly<{
    onCancel?: ((...args: any[]) => any) | undefined;
    onConfirm?: ((...args: any[]) => any) | undefined;
}>, {
    cancelButtonType: ButtonVariantName | undefined;
    confirmButtonType: ButtonVariantName | undefined;
    modelValue: boolean;
    element: string;
    role: string;
    showCancel: boolean;
    showConfirm: boolean;
    cancelButtonText: string;
    confirmButtonText: string;
    confirmLoading: boolean;
    padding: boolean;
    showCloseButton: boolean;
}, {}, {
    FwButton: vue.ComponentOptions;
    XMarkSvg: VueConstructor<Vue>;
    FwImage: vue.ComponentOptions;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const _default$d: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * An array of menu progress steps.
     * `{ label: string; position: number; subSteps: number; }`
     */
    steps: {
        type: PropType<ProgressBarStep[]>;
        required: true;
    };
    /**
     * An current active step.
     */
    activeStep: {
        type: NumberConstructor;
        required: true;
    };
    /**
     * An current active sub-step.
     */
    activeSubStep: {
        type: NumberConstructor;
        required: true;
    };
}>, {
    calculatedProgressBar: (step: ProgressBarStep) => string;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * An array of menu progress steps.
     * `{ label: string; position: number; subSteps: number; }`
     */
    steps: {
        type: PropType<ProgressBarStep[]>;
        required: true;
    };
    /**
     * An current active step.
     */
    activeStep: {
        type: NumberConstructor;
        required: true;
    };
    /**
     * An current active sub-step.
     */
    activeSubStep: {
        type: NumberConstructor;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {
    CheckSvg: VueConstructor<Vue>;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const __default__$7: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The label text of the tag.
     * Overrides the default slot content.
     */
    label: {
        type: StringConstructor;
    };
    /**
     * The size of the tag. Accepts: 'xs', 'sm' & 'md'
     */
    size: {
        type: PropType<TagSize>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The colour variant of the tag. Accepts 'primary', 'secondary', 'alert', 'error', 'success'
     */
    variant: {
        type: PropType<TagVariantName>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether the tag can be dismissed or closed.
     */
    dismissable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the tag has round borders or not.
     */
    rounded: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    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;
    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.
     */
    label: {
        type: StringConstructor;
    };
    /**
     * The size of the tag. Accepts: 'xs', 'sm' & 'md'
     */
    size: {
        type: PropType<TagSize>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The colour variant of the tag. Accepts 'primary', 'secondary', 'alert', 'error', 'success'
     */
    variant: {
        type: PropType<TagVariantName>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether the tag can be dismissed or closed.
     */
    dismissable: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the tag has round borders or not.
     */
    rounded: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onDismissed?: ((...args: any[]) => any) | undefined;
}>, {
    variant: TagVariantName;
    size: TagSize;
    dismissable: boolean;
    rounded: boolean;
}, {}, {
    FwButton: vue.ComponentOptions;
    XMarkSvg: VueConstructor<Vue>;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const __default__$6: vue.DefineComponent<vue.ExtractPropTypes<{
    items: {
        type: PropType<FwTableProps["items"]>;
        required: true;
    };
    options: {
        type: PropType<FwTableProps["options"]>;
        required: false;
    };
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Enable click events on rows.
     * Emits row data when clicked
     */
    clickableRows: {
        type: BooleanConstructor;
        default: boolean;
    };
    autoSortColumn: {
        type: NumberConstructor;
    };
    enablePagination: {
        type: BooleanConstructor;
        default: boolean;
    };
    totalAmount: {
        type: NumberConstructor;
    };
    pageSize: {
        type: NumberConstructor;
    };
    /**
     * 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, number>;
    maxPageAmount: vue.Ref<number | undefined, number | undefined>;
    pageArrowClick: (next: boolean) => void;
    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;
    };
    options: {
        type: PropType<FwTableProps["options"]>;
        required: false;
    };
    loading: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Enable click events on rows.
     * Emits row data when clicked
     */
    clickableRows: {
        type: BooleanConstructor;
        default: boolean;
    };
    autoSortColumn: {
        type: NumberConstructor;
    };
    enablePagination: {
        type: BooleanConstructor;
        default: boolean;
    };
    totalAmount: {
        type: NumberConstructor;
    };
    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$c: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const _default$b: vue.DefineComponent<{}, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const __default__$5: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The header title of the accordion
     */
    title: {
        type: StringConstructor;
    };
    /**
     * Classname for the title
     */
    titleClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Title suffix of the accordion header
     */
    suffixTitle: {
        type: StringConstructor;
    };
    /**
     * Whether the accordion should be initially opened
     */
    isOpened: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the accordion open icon should be at the start or end
     */
    iconPositionStart: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Header className for the accordion button
     */
    headerClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Border style className for the accordion button
     */
    borderStyle: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Secondary appearance of the accordion
     */
    secondary: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    isOpen: vue.Ref<boolean, boolean>;
    beforeEnter: (el: Element) => void;
    enter: (el: Element) => void;
    beforeLeave: (el: Element) => void;
    leave: (el: Element) => void;
    bgHoverColor: string;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "toggled"[], "toggled", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The header title of the accordion
     */
    title: {
        type: StringConstructor;
    };
    /**
     * Classname for the title
     */
    titleClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Title suffix of the accordion header
     */
    suffixTitle: {
        type: StringConstructor;
    };
    /**
     * Whether the accordion should be initially opened
     */
    isOpened: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether the accordion open icon should be at the start or end
     */
    iconPositionStart: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Header className for the accordion button
     */
    headerClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Border style className for the accordion button
     */
    borderStyle: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Secondary appearance of the accordion
     */
    secondary: {
        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__$4: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The src attribute of the image
     */
    src: StringConstructor;
    /**
     * The alt attribute of the image
     */
    alt: StringConstructor;
    /**
     * The type of component. Accepts 'background' and defaults to the native html5 element.
     */
    type: {
        type: PropType<FwImageProps["type"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether the loading bar and error state are rounded.
     */
    rounded: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The class for the native image element
     */
    imageClass: {
        type: StringConstructor;
    };
    /**
     * Controls the threshold before the component triggers the src url.
     */
    threshold: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * Controls the error UI when an image src is unavailable.
     */
    enableErrors: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    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;
    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
     */
    src: StringConstructor;
    /**
     * The alt attribute of the image
     */
    alt: StringConstructor;
    /**
     * The type of component. Accepts 'background' and defaults to the native html5 element.
     */
    type: {
        type: PropType<FwImageProps["type"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether the loading bar and error state are rounded.
     */
    rounded: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The class for the native image element
     */
    imageClass: {
        type: StringConstructor;
    };
    /**
     * Controls the threshold before the component triggers the src url.
     */
    threshold: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * Controls the error UI when an image src is unavailable.
     */
    enableErrors: {
        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$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<{}> & Readonly<{}>, {}, {}, {
    FwLoadingBar: vue.ComponentOptions;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const _default$8: vue.DefineComponent<vue.ExtractPropTypes<{
    columns: {
        type: NumberConstructor;
        default: number;
    };
    rows: {
        type: NumberConstructor;
        default: number;
    };
}>, {
    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;
    };
    rows: {
        type: NumberConstructor;
        default: number;
    };
}>> & Readonly<{}>, {
    columns: number;
    rows: number;
}, {}, {
    FwLoadingBar: vue.ComponentOptions;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

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<vue.ExtractPropTypes<{
    /**
     * The toast's v-model. Controls the visibility of the toast.
     */
    modelValue: {
        type: BooleanConstructor;
    };
    /**
     * The type of the toast.
     * Accepts: 'success', 'error', 'warning'
     */
    type: {
        type: PropType<ToastType>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The position of the toast on the screen.
     * Accepts: 'top', 'bottom', 'top-left', 'top-right', 'bottom-left', 'bottom-right'
     */
    position: {
        type: PropType<ToastPosition>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The content of the toast.
     */
    content: {
        type: StringConstructor;
    };
    /**
     * The base container to attach to. Defaults to `#app` element.
     */
    element: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The duration timeout before the toast is dismissed.
     */
    timeout: {
        type: NumberConstructor;
        default: number;
    };
}>, {
    isMounted: vue.Ref<boolean, boolean>;
    isOpen: vue.WritableComputedRef<vue.Ref<boolean, boolean>, vue.Ref<boolean, boolean>>;
    uuid: `${string}-${string}-${string}-${string}-${string}`;
    containerEl: vue.ComputedRef<string>;
    baseClass: string;
    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.
     */
    modelValue: {
        type: BooleanConstructor;
    };
    /**
     * The type of the toast.
     * Accepts: 'success', 'error', 'warning'
     */
    type: {
        type: PropType<ToastType>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The position of the toast on the screen.
     * Accepts: 'top', 'bottom', 'top-left', 'top-right', 'bottom-left', 'bottom-right'
     */
    position: {
        type: PropType<ToastPosition>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The content of the toast.
     */
    content: {
        type: StringConstructor;
    };
    /**
     * The base container to attach to. Defaults to `#app` element.
     */
    element: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The duration timeout before the toast is dismissed.
     */
    timeout: {
        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<vue.ExtractPropTypes<{
    /**
     * The transaction title of the card
     */
    title: {
        type: StringConstructor;
    };
    /**
     * The transaction sub-title of the card
     */
    subTitle: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The transaction amount.
     */
    amount: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The src url for the image.
     */
    imageUrl: {
        type: StringConstructor;
        required: false;
    };
}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The transaction title of the card
     */
    title: {
        type: StringConstructor;
    };
    /**
     * The transaction sub-title of the card
     */
    subTitle: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The transaction amount.
     */
    amount: {
        type: StringConstructor;
        required: false;
    };
    /**
     * The src url for the image.
     */
    imageUrl: {
        type: StringConstructor;
        required: false;
    };
}>> & Readonly<{}>, {}, {}, {
    FwCard: vue.ComponentOptions;
    FwImage: vue.ComponentOptions;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const _default$4: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * Controls the sidebar menu open/close state
     */
    modelValue: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * An array of menu items
     * `{ to?: string | object; href?: string; label: string; }`
     */
    menuItems: {
        type: PropType<FwSidebarMenuProps["menuItems"]>;
    };
    /**
     * The class for the open/close toggle button
     */
    toggleButtonClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The width class for the sidebar when opened
     */
    openWidth: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The width class for the sidebar when opened
     */
    closedWidth: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The button variant of the toggle button
     */
    toggleButtonVariant: {
        type: PropType<FwSidebarMenuProps["toggleButtonVariant"]>;
        default: string;
        validator: (value: string) => boolean;
    };
}>, {
    baseClass: string;
    isMenuOpen: vue.WritableComputedRef<boolean, boolean>;
    toggleMenu: () => void;
    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
     */
    modelValue: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * An array of menu items
     * `{ to?: string | object; href?: string; label: string; }`
     */
    menuItems: {
        type: PropType<FwSidebarMenuProps["menuItems"]>;
    };
    /**
     * The class for the open/close toggle button
     */
    toggleButtonClass: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The width class for the sidebar when opened
     */
    openWidth: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The width class for the sidebar when opened
     */
    closedWidth: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The button variant of the toggle button
     */
    toggleButtonVariant: {
        type: PropType<FwSidebarMenuProps["toggleButtonVariant"]>;
        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<vue.ExtractPropTypes<{
    /**
     * The drawer's v-model. Controls the visibility of the drawer.
     */
    modelValue: {
        type: BooleanConstructor;
    };
    /**
     * The header title of the drawer
     */
    header: {
        type: StringConstructor;
    };
    /**
     * The body description of the drawer
     */
    body: {
        type: StringConstructor;
    };
    /**
     * The aria role of the drawer container. Defaults to `dialog`
     */
    role: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The element to attach the modal too. Defaults to `#app` element.
     */
    element: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Whether to show the cancel button
     */
    showCancel: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether to show the confirm button
     */
    showConfirm: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Custom text for the cancel button
     */
    cancelButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the cancel button
     */
    cancelButtonType: {
        type: PropType<FwDrawerProps["cancelButtonType"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Custom text for the confirm button
     */
    confirmButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the confirm button
     */
    confirmButtonType: {
        type: PropType<FwDrawerProps["confirmButtonType"]>;
        default: string;
        validator: (value: string) => boolean;
    };
}>, {
    baseDrawerClass: string;
    drawerFooterClass: string;
    isOpen: vue.WritableComputedRef<boolean, boolean>;
    uuid: string;
    isMounted: vue.Ref<boolean, boolean>;
    onConfirmed: () => void;
    onCancelled: () => void;
    drawerBgColour: string;
}, {}, {}, {}, 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.
     */
    modelValue: {
        type: BooleanConstructor;
    };
    /**
     * The header title of the drawer
     */
    header: {
        type: StringConstructor;
    };
    /**
     * The body description of the drawer
     */
    body: {
        type: StringConstructor;
    };
    /**
     * The aria role of the drawer container. Defaults to `dialog`
     */
    role: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The element to attach the modal too. Defaults to `#app` element.
     */
    element: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Whether to show the cancel button
     */
    showCancel: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Whether to show the confirm button
     */
    showConfirm: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Custom text for the cancel button
     */
    cancelButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the cancel button
     */
    cancelButtonType: {
        type: PropType<FwDrawerProps["cancelButtonType"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Custom text for the confirm button
     */
    confirmButtonText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Button variant for the confirm button
     */
    confirmButtonType: {
        type: PropType<FwDrawerProps["confirmButtonType"]>;
        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;
    role: string;
    element: string;
    showCancel: boolean;
    showConfirm: boolean;
    cancelButtonText: string;
    confirmButtonText: string;
}, {}, {
    FwButton: vue.ComponentOptions;
    XMarkSvg: VueConstructor<Vue>;
}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const __default__$2: vue.DefineComponent<vue.ExtractPropTypes<{
    heading: {
        type: StringConstructor;
    };
    items: {
        type: PropType<FwProviderListProps["items"]>;
        required: true;
    };
    tableHeaderName: {
        type: StringConstructor;
        default: string;
    };
    searchPlaceholder: {
        type: StringConstructor;
        default: string;
    };
    searchLabel: {
        type: StringConstructor;
        default: string;
    };
    statusFilterLabel: {
        type: StringConstructor;
        default: string;
    };
}>, {
    options: vue.ComputedRef<FwTableItemOptions | undefined>;
    sortedTableItems: vue.ComputedRef<FwTableItem[]>;
    searchFilterModel: vue.Ref<string, string>;
    statusFilterModel: vue.Ref<"supported" | "outage" | "all", "supported" | "outage" | "all">;
    primaryFade5: string;
    primaryFade20: string;
    primaryFade40: string;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "changed"[], "changed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    heading: {
        type: StringConstructor;
    };
    items: {
        type: PropType<FwProviderListProps["items"]>;
        required: true;
    };
    tableHeaderName: {
        type: StringConstructor;
        default: string;
    };
    searchPlaceholder: {
        type: StringConstructor;
        default: string;
    };
    searchLabel: {
        type: StringConstructor;
        default: string;
    };
    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: DefineComponent<FwDatePickerProps>;

declare const __default__: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The title of the popover
     */
    title: StringConstructor;
    /**
     * The side of the target element the popover should be placed against. Accepts 'top', 'right', 'bottom' and 'left'
     */
    placement: {
        type: PropType<FwPopoverProps["placement"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether to use `fixed` or `absolute` positioning.
     * Absolute is more performant if you have a lot of popovers; fixed is more robust
     */
    position: {
        type: PropType<FwPopoverProps["position"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The input event which causes the popover to show. Accepts 'click' and 'hover' & 'focus'
     */
    trigger: {
        type: PropType<FwPopoverProps["trigger"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether to show component on top of all components by setting the highest z-index
     */
    showOnTop: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Close the popover automatically when the user clicks inside of the popover
     */
    closeOnClick: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Close the popover automatically when the user clicks outside of the popover
     */
    closeOnClickOutside: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The text alignment of the popover content should be placed against. Accepts 'center', 'right' and 'left'
     */
    textAlign: {
        type: StringConstructor;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether to show the arrow
     **/
    showArrow: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    targetElement: vue.Ref<HTMLElement | null, HTMLElement | null>;
    contentElement: vue.Ref<HTMLElement | null, HTMLElement | null>;
    contentElementId: string;
    computedVisible: vue.ComputedRef<boolean>;
    onEnter: () => void;
    onLeave: () => void;
    onClick: () => void;
    autoCloseContent: (e: Event) => void;
    spacingSize: vue.ComputedRef<"12px" | "2px">;
}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "closed"[], "closed", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    /**
     * The title of the popover
     */
    title: StringConstructor;
    /**
     * The side of the target element the popover should be placed against. Accepts 'top', 'right', 'bottom' and 'left'
     */
    placement: {
        type: PropType<FwPopoverProps["placement"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether to use `fixed` or `absolute` positioning.
     * Absolute is more performant if you have a lot of popovers; fixed is more robust
     */
    position: {
        type: PropType<FwPopoverProps["position"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * The input event which causes the popover to show. Accepts 'click' and 'hover' & 'focus'
     */
    trigger: {
        type: PropType<FwPopoverProps["trigger"]>;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether to show component on top of all components by setting the highest z-index
     */
    showOnTop: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Close the popover automatically when the user clicks inside of the popover
     */
    closeOnClick: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Close the popover automatically when the user clicks outside of the popover
     */
    closeOnClickOutside: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * The text alignment of the popover content should be placed against. Accepts 'center', 'right' and 'left'
     */
    textAlign: {
        type: StringConstructor;
        default: string;
        validator: (value: string) => boolean;
    };
    /**
     * Whether to show the arrow
     **/
    showArrow: {
        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: "click" | "hover" | "focus";
    showOnTop: boolean;
    closeOnClick: boolean;
    closeOnClickOutside: boolean;
    textAlign: string;
    showArrow: boolean;
}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare const _default$3: vue.DefineComponent<vue.ExtractPropTypes<{
    /**
     * The accepted file types for the media picker
     */
    acceptedFileTypes: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The maximum file size in bytes. Default 8 MB
     */
    maxFileSize: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * The title of the picker tile
     */
    title: {
        type: StringConstructor;
    };
    /**
     * The image URL to display in the media picker
     */
    imageUrl: {
        type: StringConstructor;
    };
    /**
     * The header text for the upload modal
     */
    uploadHeaderText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The header text for the edit modal
     */
    editHeaderText: {
        type: StringConstructor;
        default: string;
    };
}>, {
    previewImageUrl: vue.ComputedRef<string | undefined>;
    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, boolean>;
    loading: vue.Ref<boolean, boolean>;
    dragDropFile: (event: DragEvent) => void;
    isInvalidFile: vue.ComputedRef<boolean>;
    showEditor: () => void;
    change: () => void;
    reset: () => void;
    save: () => Promise<void>;
    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
     */
    acceptedFileTypes: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The maximum file size in bytes. Default 8 MB
     */
    maxFileSize: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * The title of the picker tile
     */
    title: {
        type: StringConstructor;
    };
    /**
     * The image URL to display in the media picker
     */
    imageUrl: {
        type: StringConstructor;
    };
    /**
     * The header text for the upload modal
     */
    uploadHeaderText: {
        type: StringConstructor;
        default: string;
    };
    /**
     * The header text for the edit modal
     */
    editHeaderText: {
        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<vue.ExtractPropTypes<{
    min: {
        type: NumberConstructor;
        default: number;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    step: {
        type: NumberConstructor;
        default: number;
    };
    minValue: {
        type: NumberConstructor;
        default: null;
    };
    maxValue: {
        type: NumberConstructor;
        default: null;
    };
}>, {
    minLocal: vue.Ref<number, number>;
    maxLocal: vue.Ref<number, number>;
    minPercentage: vue.ComputedRef<number>;
    maxPercentage: vue.ComputedRef<number>;
    clippingPoint: vue.ComputedRef<boolean>;
    lastMoved: vue.Ref<"min" | "max", "min" | "max">;
    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;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    step: {
        type: NumberConstructor;
        default: number;
    };
    minValue: {
        type: NumberConstructor;
        default: null;
    };
    maxValue: {
        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<{
    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[]>;
    yModel: vue.ComputedRef<number[]>;
    chartOptions: vue.ComputedRef<chart_js_dist_types_utils._DeepPartialObject<chart_js.CoreChartOptions<"bar"> & chart_js.ElementChartOptions<"bar"> & chart_js.PluginChartOptions<"bar"> & chart_js.DatasetChartOptions<"bar"> & chart_js.ScaleChartOptions<"bar"> & chart_js.BarControllerChartOptions>>;
    chartData: vue.ComputedRef<{
        labels: string[];
        datasets: {
            backgroundColor: string[] | undefined;
            data: number[];
            borderWidth: number;
            borderRadius: number;
            barPercentage: number;
        }[];
    }>;
    bgColor: string;
    primaryFade: string;
}, {}, {}, {}, 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<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;

declare interface ModalServiceProps extends Omit<FwModalProps, 'modelValue'> {
    onConfirm?: () => void;
    onCancel?: () => void;
}
declare const modalService: (options?: ModalServiceProps) => {
    open: () => void;
    close: () => void;
};

declare interface ToastServiceProps extends Omit<FwToastProps, 'modelValue' | 'type'> {
    onDismissed?: () => void;
}
declare const toastService: () => {
    success: (options?: ToastServiceProps) => void;
    error: (options?: ToastServiceProps) => void;
    warning: (options?: ToastServiceProps) => void;
};

declare const getHexWithOpacity: (hexColor: string, fadePercentage: number | string) => string;
declare const useColours: () => {
    colorPrimary: string;
    colorSecondary: string;
    colorTertiary: string;
    fontFamily: string;
    colorBody: string;
    primaryFade5: string;
    primaryFade10: string;
    primaryFade20: string;
    primaryFade30: string;
    primaryFade40: string;
    primaryFade50: string;
    primaryFade60: string;
    primaryFade70: string;
    primaryFade80: string;
    primaryFade90: string;
    brandBg1Fade95: string;
    colorErrorTextFade5: string;
    colorSuccessNew: string;
};

declare const getVueComponentHtml: (component: Component, props: ComponentCustomProps) => string;

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__$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 InputTag, 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 };