@frollo/frollo-web-ui 9.0.1 → 9.0.2

package/types/components/fw-switch/fw-switch.vue.d.ts

@@ -1,6 +1,6 @@
 import { type PropType } from 'vue';
 import type { FwSwitchProps } from './index.types';
-declare const _default: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     /**
      * The name of the switch input field.
      * Multiple switches can use the same name with a unique value.
@@ -35,6 +35,11 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    /** v-model If provided, it is the source of truth. */
+    modelValue: {
+        type: BooleanConstructor;
+        required: false;
+    };
     /**
      * Progmatically set the checked state of the input.
      * Used outside a FwForm element
@@ -44,11 +49,12 @@ declare const _default: import("vue").DefineComponent<{
         required: false;
         default: boolean;
     };
-}, {
-    isSwitched: import("vue").Ref<boolean>;
-    toggleSwitch: () => void;
-    uuid: string;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, {
+    checked: import("vue").ComputedRef<boolean>;
+    onNativeChange: (e: Event) => void;
+    inputId: string;
+    resolvedValue: import("vue").ComputedRef<string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "update:isChecked")[], "change" | "update:modelValue" | "update:isChecked", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     /**
      * The name of the switch input field.
      * Multiple switches can use the same name with a unique value.
@@ -83,6 +89,11 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    /** v-model If provided, it is the source of truth. */
+    modelValue: {
+        type: BooleanConstructor;
+        required: false;
+    };
     /**
      * Progmatically set the checked state of the input.
      * Used outside a FwForm element
@@ -92,10 +103,373 @@ declare const _default: import("vue").DefineComponent<{
         required: false;
         default: boolean;
     };
-}>> & {
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onChange?: ((...args: any[]) => any) | undefined;
-}, {
+    "onUpdate:isChecked"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: boolean;
     enableErrors: boolean;
     isChecked: boolean;
-}, {}>;
+}, {}, {
+    InputField: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<import("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;
+            };
+        }>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").Slot<any> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>[];
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<import("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: import("vee-validate").RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }, true, {}, {}, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            as: {
+                type: (ObjectConstructor | StringConstructor)[];
+                default: any;
+            };
+            name: {
+                type: StringConstructor;
+                required: true;
+            };
+            rules: {
+                type: PropType<import("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;
+            };
+        }>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").Slot<any> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[] | {
+            default: () => import("vue").VNode<import("vue").RendererNode, import("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: import("vee-validate").RuleExpression<unknown>;
+            "onUpdate:modelValue": (e: any) => unknown;
+            keepValue: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        as: {
+            type: (ObjectConstructor | StringConstructor)[];
+            default: any;
+        };
+        name: {
+            type: StringConstructor;
+            required: true;
+        };
+        rules: {
+            type: PropType<import("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;
+        };
+    }>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").Slot<any> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[] | {
+        default: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[];
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("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: import("vee-validate").RuleExpression<unknown>;
+        'onUpdate:modelValue': (e: any) => unknown;
+        keepValue: boolean;
+    }, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        value: import("vue").UnwrapRef<import("vee-validate").FieldContext["value"]>;
+        meta: import("vue").UnwrapRef<import("vee-validate").FieldContext["meta"]>;
+        errors: import("vue").UnwrapRef<import("vee-validate").FieldContext["errors"]>;
+        errorMessage: import("vue").UnwrapRef<import("vee-validate").FieldContext["errorMessage"]>;
+        setErrors: import("vee-validate").FieldContext["setErrors"];
+        setTouched: import("vee-validate").FieldContext["setTouched"];
+        reset: import("vee-validate").FieldContext["resetField"];
+        validate: import("vee-validate").FieldContext["validate"];
+        setValue: import("vee-validate").FieldContext["setValue"];
+        handleChange: import("vee-validate").FieldContext["handleChange"];
+        $slots: {
+            default: (arg: import("vee-validate").FieldSlotProps<any>) => import("vue").VNode[];
+        };
+    });
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/components/fw-switch/index.types.d.ts

@@ -5,4 +5,5 @@ export declare interface FwSwitchProps {
     hint?: string;
     enableErrors?: boolean;
     isChecked?: boolean;
+    modelValue?: boolean;
 }

package/types/components/fw-table/fw-table-head.vue.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/components/fw-table/fw-table-row.vue.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/components/fw-table/fw-table.vue.d.ts

@@ -1,6 +1,6 @@
 import { type PropType } from 'vue';
-import type { FwTableItem, FwTableProps, FwTableSort } from './index.types';
-declare const __default__: import("vue").DefineComponent<{
+import type { FwTableItem, FwTableProps, FwTableSort, FwTableColumnMeta } from './index.types';
+declare const __default__: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     items: {
         type: PropType<FwTableProps["items"]>;
         required: true;
@@ -34,23 +34,30 @@ declare const __default__: import("vue").DefineComponent<{
     pageSize: {
         type: NumberConstructor;
     };
-}, {
-    columns: import("vue").ComputedRef<string[]>;
-    sortBy: import("vue").Ref<string>;
-    sortDirection: import("vue").Ref<FwTableSort>;
-    sortColumn: (column: string, isAction?: boolean) => void;
-    sortedData: import("vue").ComputedRef<FwTableItem[] | undefined>;
-    currentSortedColumn: import("vue").Ref<string>;
-    sortedIcon: (sortDir: string, column: string) => boolean;
-    formattedText: (row: FwTableItem, column: string) => string | number;
-    isColumnSortable: (column: string) => boolean | undefined;
-    isDisabled: (column: string) => boolean;
+    /**
+     * Optional stable row key. If omitted, falls back to index-based key.
+     */
+    rowKey: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: false;
+    };
+}>, {
+    colMeta: import("vue").ComputedRef<FwTableColumnMeta[]>;
+    sortBy: import("vue").Ref<string, string>;
+    sortDirection: import("vue").Ref<FwTableSort, FwTableSort>;
+    currentSortedColumn: import("vue").Ref<string, string>;
+    onSort: (column: string, isAction?: boolean) => void;
+    displayRows: import("vue").ComputedRef<FwTableItem[]>;
     rowClicked: (row: FwTableItem) => void;
     bgHoverColor: string;
-    currentPage: import("vue").Ref<number>;
-    maxPageAmount: import("vue").Ref<number | undefined>;
+    currentPage: import("vue").Ref<number, number>;
+    maxPageAmount: import("vue").Ref<number | undefined, number | undefined>;
     pageArrowClick: (next: boolean) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("rowClicked" | "columnSorted" | "pageChanged")[], "rowClicked" | "columnSorted" | "pageChanged", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    getRowKey: (row: FwTableItem, index?: number) => any;
+    skeletonRowCount: import("vue").ComputedRef<number>;
+    getComponentProps: (col: FwTableColumnMeta, row: FwTableItem) => Record<string, unknown>;
+    getComponentHandlers: (col: FwTableColumnMeta, row: FwTableItem) => Record<string, (...args: unknown[]) => void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("rowClicked" | "columnSorted" | "pageChanged")[], "rowClicked" | "columnSorted" | "pageChanged", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     items: {
         type: PropType<FwTableProps["items"]>;
         required: true;
@@ -84,13 +91,27 @@ declare const __default__: import("vue").DefineComponent<{
     pageSize: {
         type: NumberConstructor;
     };
-}>> & {
+    /**
+     * Optional stable row key. If omitted, falls back to index-based key.
+     */
+    rowKey: {
+        type: (StringConstructor | FunctionConstructor)[];
+        required: false;
+    };
+}>> & Readonly<{
     onRowClicked?: ((...args: any[]) => any) | undefined;
     onColumnSorted?: ((...args: any[]) => any) | undefined;
     onPageChanged?: ((...args: any[]) => any) | undefined;
-}, {
+}>, {
     loading: boolean;
     clickableRows: boolean;
     enablePagination: boolean;
-}, {}>;
+}, {}, {
+    FwLoadingBar: import("vue").ComponentOptions;
+    FwButton: import("vue").ComponentOptions;
+    ArrowDownSvg: VueConstructor<Vue>;
+    ArrowSortSvg: VueConstructor<Vue>;
+    ChevronLeftSvg: VueConstructor<Vue>;
+    ChevronRightSvg: VueConstructor<Vue>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default __default__;

package/types/components/fw-table/index.types.d.ts

@@ -1,13 +1,33 @@
-export declare type FwTableItem = Record<string, string | number>;
-export declare type FwTableFormatFunction = (value: string | number | object) => string;
+import type { Component } from 'vue';
+export declare type FwTableItemValue = string | number | boolean | object;
+export declare type FwTableItem = Record<string, FwTableItemValue>;
+export declare type FwTableFormatFunction = (value: FwTableItemValue, row?: FwTableItem) => string;
 export declare type FwTableSortFunction = (items: FwTableItem[], columnName: string, sortDirection?: FwTableSort) => FwTableItem[] | undefined;
 export declare type FwTableSort = 'asc' | 'desc';
+export declare type FwTableCellComponentProps = Record<string, unknown> | ((ctx: {
+    value: FwTableItemValue;
+    row: FwTableItem;
+    column: string;
+}) => Record<string, unknown>);
+export declare type FwTableCellComponentHandlers = Record<string, (...args: unknown[]) => void> | ((ctx: {
+    value: FwTableItemValue;
+    row: FwTableItem;
+    column: string;
+}) => Record<string, (...args: unknown[]) => void>);
 export 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;
 }>;
 export declare interface FwTableProps {
     items: FwTableItem[];
@@ -18,4 +38,18 @@ export declare interface FwTableProps {
     enablePagination?: boolean;
     totalAmount?: number;
     pageSize?: number;
+    rowKey?: string | ((row: FwTableItem) => string | number);
+}
+export 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;
 }

package/types/components/fw-tabs/fw-tab.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     /**
      * The label of the tab component used as the button panel label
      */
@@ -6,13 +6,9 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         required: true;
     };
-}, {
+}>, {
     isActive: import("vue").ComputedRef<boolean>;
-    index: import("vue").ComputedRef<number | undefined>;
-    props: import("@vue/shared").LooseRequired<{
-        readonly label: string;
-    } & {}>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     /**
      * The label of the tab component used as the button panel label
      */
@@ -20,5 +16,5 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         required: true;
     };
-}>>, {}, {}>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/components/fw-tabs/fw-tabs.vue.d.ts

@@ -1,5 +1,5 @@
-import { type TabsState } from './index.types';
-declare const _default: import("vue").DefineComponent<{
+import { type TabRecord } from './index.types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     /**
      * The active tab v-model
      */
@@ -7,10 +7,11 @@ declare const _default: import("vue").DefineComponent<{
         type: NumberConstructor;
         required: true;
     };
-}, {
-    state: TabsState;
-    selectTab: (tab: number) => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, {
+    tabs: import("vue").ShallowReactive<TabRecord[]>;
+    active: import("vue").ComputedRef<number>;
+    selectTab: (index: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     /**
      * The active tab v-model
      */
@@ -18,7 +19,9 @@ declare const _default: import("vue").DefineComponent<{
         type: NumberConstructor;
         required: true;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
-}, {}, {}>;
+}>, {}, {}, {
+    FwButton: import("vue").ComponentOptions;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/components/fw-tabs/index.types.d.ts

@@ -1,7 +1,17 @@
-import { type ComponentInternalInstance } from 'vue';
-export declare interface TabsState {
-    tabs: ComponentInternalInstance[] | null;
-    active: number;
+import { ComputedRef, ShallowReactive } from 'vue';
+export declare type TabRecord = {
+    uid: number;
+    label: string;
+    index: number;
+};
+export declare type TabsApi = {
+    active: ComputedRef<number>;
+    registerTabs: (uid: number, label: string) => number;
+    unregisterTabs: (uid: number) => void;
+    tabs: ShallowReactive<TabRecord[]>;
+};
+export declare interface FwTabProps {
+    label: string;
 }
 export declare interface FwTabsProps {
     modelValue: number;