@vuetify/nightly 3.2.0-dev-20230214.0 → 3.2.0-dev-20230322.0

package/lib/components/VCounter/index.d.ts

@@ -1,68 +1,1062 @@
 import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes } from 'vue';
 
-declare const VCounter: vue.DefineComponent<{
-    active: boolean;
-    transition: NonNullable<string | boolean | (vue.TransitionProps & {
-        component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
-    })> | {
-        component: vue.DefineComponent<{
-            origin: string;
-            group: boolean;
-            mode: string;
-            hideOnLeave: boolean;
-            leaveAbsolute: boolean;
-        } & {} & {
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): [yes: Partial<Pick<T, U>>, no: Omit<T, U>];
+}
+
+declare const VCounter: {
+    new (...args: any[]): {
+        $: vue.ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            active: boolean;
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }> & Omit<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                            [key: string]: any;
+                        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }, vue.ExtractPropTypes<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>>;
+            };
+            value: string | number;
+        }> & Omit<{
+            active: boolean;
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }> & Omit<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                            [key: string]: any;
+                        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }, vue.ExtractPropTypes<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>>;
+            };
+            value: string | number;
+        } & {
+            max?: string | number | undefined;
+        } & {
             $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
                 default?: (() => vue.VNodeChild) | undefined;
             };
+            $slots?: {
+                default?: (() => vue.VNodeChild) | undefined;
+            } | undefined;
             'v-slots'?: {
                 default?: false | (() => vue.VNodeChild) | undefined;
             } | undefined;
         } & {
             "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-            [key: string]: any;
-        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
-            origin: string;
-            group: boolean;
-            mode: string;
-            hideOnLeave: boolean;
-            leaveAbsolute: boolean;
-        } & {} & {
+        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "active" | "transition" | "value">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: vue.Slot | undefined;
+        }>;
+        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: vue.ComponentOptionsBase<{
+            active: boolean;
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }> & Omit<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                            [key: string]: any;
+                        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }, vue.ExtractPropTypes<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>>;
+            };
+            value: string | number;
+        } & {
+            max?: string | number | undefined;
+        } & {
             $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
                 default?: (() => vue.VNodeChild) | undefined;
             };
+            $slots?: {
+                default?: (() => vue.VNodeChild) | undefined;
+            } | undefined;
             'v-slots'?: {
                 default?: false | (() => vue.VNodeChild) | undefined;
             } | undefined;
         } & {
             "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, {
-            origin: string;
-            group: boolean;
-            mode: string;
-            hideOnLeave: boolean;
-            leaveAbsolute: boolean;
-        }>;
-    };
-    value: string | number;
-} & {
-    max?: string | number | undefined;
-} & {
-    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
-        default?: (() => vue.VNodeChild) | undefined;
-    };
-    'v-slots'?: {
-        default?: false | (() => vue.VNodeChild) | undefined;
-    } | undefined;
-} & {
-    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
+        }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+            active: boolean;
+            transition: NonNullable<string | boolean | (vue.TransitionProps & {
+                component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+            })> | {
+                component: {
+                    new (...args: any[]): {
+                        $: vue.ComponentInternalInstance;
+                        $data: {};
+                        $props: Partial<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }> & Omit<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                        $attrs: {
+                            [x: string]: unknown;
+                        };
+                        $refs: {
+                            [x: string]: unknown;
+                        };
+                        $slots: Readonly<{
+                            [name: string]: vue.Slot | undefined;
+                        }>;
+                        $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                        $emit: (event: string, ...args: any[]) => void;
+                        $el: any;
+                        $options: vue.ComponentOptionsBase<{
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        } & {} & {
+                            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            };
+                            $slots?: {
+                                default?: (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                            'v-slots'?: {
+                                default?: false | (() => vue.VNodeChild) | undefined;
+                            } | undefined;
+                        } & {
+                            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                        }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                            [key: string]: any;
+                        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                            origin: string;
+                            group: boolean;
+                            mode: string;
+                            hideOnLeave: boolean;
+                            leaveAbsolute: boolean;
+                        }, {}, string> & {
+                            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                            created?: ((() => void) | (() => void)[]) | undefined;
+                            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                            mounted?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                            updated?: ((() => void) | (() => void)[]) | undefined;
+                            activated?: ((() => void) | (() => void)[]) | undefined;
+                            deactivated?: ((() => void) | (() => void)[]) | undefined;
+                            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                            destroyed?: ((() => void) | (() => void)[]) | undefined;
+                            unmounted?: ((() => void) | (() => void)[]) | undefined;
+                            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                        };
+                        $forceUpdate: () => void;
+                        $nextTick: typeof vue.nextTick;
+                        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                    } & {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>> & {} & vue.ComponentCustomProperties & {};
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & vue.ComponentOptionsBase<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }, vue.ExtractPropTypes<{
+                    group: BooleanConstructor;
+                    hideOnLeave: BooleanConstructor;
+                    leaveAbsolute: BooleanConstructor;
+                    mode: {
+                        type: StringConstructor;
+                        default: string | undefined;
+                    };
+                    origin: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>>;
+            };
+            value: string | number;
+        }, {}, string> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof vue.nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+    } & {
+        active: boolean;
+        transition: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }> & Omit<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            } & {} & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }, vue.ExtractPropTypes<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>>;
+        };
+        value: string | number;
+    } & {
+        max?: string | number | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            default?: (() => vue.VNodeChild) | undefined;
+        };
+        $slots?: {
+            default?: (() => vue.VNodeChild) | undefined;
+        } | undefined;
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    } & vue.ShallowUnwrapRef<{}> & {} & vue.ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
     active: boolean;
     transition: NonNullable<string | boolean | (vue.TransitionProps & {
         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
     })> | {
-        component: vue.DefineComponent<{
+        component: {
+            new (...args: any[]): {
+                $: vue.ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }> & Omit<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: vue.Slot | undefined;
+                }>;
+                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: vue.ComponentOptionsBase<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }, {}, string> & {
+                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                    created?: ((() => void) | (() => void)[]) | undefined;
+                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                    mounted?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                    updated?: ((() => void) | (() => void)[]) | undefined;
+                    activated?: ((() => void) | (() => void)[]) | undefined;
+                    deactivated?: ((() => void) | (() => void)[]) | undefined;
+                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                    destroyed?: ((() => void) | (() => void)[]) | undefined;
+                    unmounted?: ((() => void) | (() => void)[]) | undefined;
+                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof vue.nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+            } & {
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            } & {} & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>> & {} & vue.ComponentCustomProperties & {};
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & vue.ComponentOptionsBase<{
             origin: string;
             group: boolean;
             mode: string;
@@ -72,6 +1066,9 @@ declare const VCounter: vue.DefineComponent<{
             $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
                 default?: (() => vue.VNodeChild) | undefined;
             };
+            $slots?: {
+                default?: (() => vue.VNodeChild) | undefined;
+            } | undefined;
             'v-slots'?: {
                 default?: false | (() => vue.VNodeChild) | undefined;
             } | undefined;
@@ -79,28 +1076,37 @@ declare const VCounter: vue.DefineComponent<{
             "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
         }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
             [key: string]: any;
-        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
+        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
             origin: string;
             group: boolean;
             mode: string;
             hideOnLeave: boolean;
             leaveAbsolute: boolean;
-        } & {} & {
-            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
-                default?: (() => vue.VNodeChild) | undefined;
+        }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+            group: BooleanConstructor;
+            hideOnLeave: BooleanConstructor;
+            leaveAbsolute: BooleanConstructor;
+            mode: {
+                type: StringConstructor;
+                default: string | undefined;
             };
-            'v-slots'?: {
-                default?: false | (() => vue.VNodeChild) | undefined;
-            } | undefined;
-        } & {
-            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, {
-            origin: string;
-            group: boolean;
-            mode: string;
-            hideOnLeave: boolean;
-            leaveAbsolute: boolean;
-        }>;
+            origin: {
+                type: StringConstructor;
+                default: string;
+            };
+        }, vue.ExtractPropTypes<{
+            group: BooleanConstructor;
+            hideOnLeave: BooleanConstructor;
+            leaveAbsolute: BooleanConstructor;
+            mode: {
+                type: StringConstructor;
+                default: string | undefined;
+            };
+            origin: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>>;
     };
     value: string | number;
 } & {
@@ -109,17 +1115,132 @@ declare const VCounter: vue.DefineComponent<{
     $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
         default?: (() => vue.VNodeChild) | undefined;
     };
+    $slots?: {
+        default?: (() => vue.VNodeChild) | undefined;
+    } | undefined;
     'v-slots'?: {
         default?: false | (() => vue.VNodeChild) | undefined;
     } | undefined;
 } & {
     "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-}, {
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
     active: boolean;
     transition: NonNullable<string | boolean | (vue.TransitionProps & {
         component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
     })> | {
-        component: vue.DefineComponent<{
+        component: {
+            new (...args: any[]): {
+                $: vue.ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }> & Omit<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: vue.Slot | undefined;
+                }>;
+                $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: vue.ComponentOptionsBase<{
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                }, {}, string> & {
+                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                    created?: ((() => void) | (() => void)[]) | undefined;
+                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                    mounted?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                    updated?: ((() => void) | (() => void)[]) | undefined;
+                    activated?: ((() => void) | (() => void)[]) | undefined;
+                    deactivated?: ((() => void) | (() => void)[]) | undefined;
+                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                    destroyed?: ((() => void) | (() => void)[]) | undefined;
+                    unmounted?: ((() => void) | (() => void)[]) | undefined;
+                    renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                    errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof vue.nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+            } & {
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            } & {} & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>> & {} & vue.ComponentCustomProperties & {};
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & vue.ComponentOptionsBase<{
             origin: string;
             group: boolean;
             mode: string;
@@ -129,6 +1250,9 @@ declare const VCounter: vue.DefineComponent<{
             $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
                 default?: (() => vue.VNodeChild) | undefined;
             };
+            $slots?: {
+                default?: (() => vue.VNodeChild) | undefined;
+            } | undefined;
             'v-slots'?: {
                 default?: false | (() => vue.VNodeChild) | undefined;
             } | undefined;
@@ -136,31 +1260,738 @@ declare const VCounter: vue.DefineComponent<{
             "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
         }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
             [key: string]: any;
-        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, {
+        }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
             origin: string;
             group: boolean;
             mode: string;
             hideOnLeave: boolean;
             leaveAbsolute: boolean;
-        } & {} & {
-            $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
-                default?: (() => vue.VNodeChild) | undefined;
+        }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+            group: BooleanConstructor;
+            hideOnLeave: BooleanConstructor;
+            leaveAbsolute: BooleanConstructor;
+            mode: {
+                type: StringConstructor;
+                default: string | undefined;
             };
-            'v-slots'?: {
-                default?: false | (() => vue.VNodeChild) | undefined;
-            } | undefined;
-        } & {
-            "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
-        }, {
-            origin: string;
-            group: boolean;
-            mode: string;
-            hideOnLeave: boolean;
-            leaveAbsolute: boolean;
-        }>;
+            origin: {
+                type: StringConstructor;
+                default: string;
+            };
+        }, vue.ExtractPropTypes<{
+            group: BooleanConstructor;
+            hideOnLeave: BooleanConstructor;
+            leaveAbsolute: BooleanConstructor;
+            mode: {
+                type: StringConstructor;
+                default: string | undefined;
+            };
+            origin: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>>;
     };
     value: string | number;
-}>;
+}, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }> & Omit<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            } & {} & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }, vue.ExtractPropTypes<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>>;
+        }>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }> & Omit<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            } & {} & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }, vue.ExtractPropTypes<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>>;
+        };
+    };
+    active: BooleanConstructor;
+    max: (StringConstructor | NumberConstructor)[];
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+}, vue.ExtractPropTypes<{
+    transition: Omit<{
+        type: vue.PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }> & Omit<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            } & {} & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }, vue.ExtractPropTypes<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>>;
+        }>;
+        default: NonNullable<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component<any, any, any, vue.ComputedOptions, vue.MethodOptions> | undefined;
+        })> | {
+            component: {
+                new (...args: any[]): {
+                    $: vue.ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }> & Omit<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    } & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, "origin" | "group" | "mode" | "hideOnLeave" | "leaveAbsolute">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: vue.Slot | undefined;
+                    }>;
+                    $root: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $parent: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+                    $emit: (event: string, ...args: any[]) => void;
+                    $el: any;
+                    $options: vue.ComponentOptionsBase<{
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    } & {} & {
+                        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        };
+                        $slots?: {
+                            default?: (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                        'v-slots'?: {
+                            default?: false | (() => vue.VNodeChild) | undefined;
+                        } | undefined;
+                    } & {
+                        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                    }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                        [key: string]: any;
+                    }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                        origin: string;
+                        group: boolean;
+                        mode: string;
+                        hideOnLeave: boolean;
+                        leaveAbsolute: boolean;
+                    }, {}, string> & {
+                        beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                        created?: ((() => void) | (() => void)[]) | undefined;
+                        beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                        mounted?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                        updated?: ((() => void) | (() => void)[]) | undefined;
+                        activated?: ((() => void) | (() => void)[]) | undefined;
+                        deactivated?: ((() => void) | (() => void)[]) | undefined;
+                        beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                        beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                        destroyed?: ((() => void) | (() => void)[]) | undefined;
+                        unmounted?: ((() => void) | (() => void)[]) | undefined;
+                        renderTracked?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        renderTriggered?: (((e: vue.DebuggerEvent) => void) | ((e: vue.DebuggerEvent) => void)[]) | undefined;
+                        errorCaptured?: (((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: vue.ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, vue.ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof vue.nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: vue.WatchOptions<boolean> | undefined): vue.WatchStopHandle;
+                } & {
+                    origin: string;
+                    group: boolean;
+                    mode: string;
+                    hideOnLeave: boolean;
+                    leaveAbsolute: boolean;
+                } & {} & {
+                    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    };
+                    $slots?: {
+                        default?: (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                    'v-slots'?: {
+                        default?: false | (() => vue.VNodeChild) | undefined;
+                    } | undefined;
+                } & {
+                    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+                } & vue.ShallowUnwrapRef<() => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                    [key: string]: any;
+                }>> & {} & vue.ComponentCustomProperties & {};
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & vue.ComponentOptionsBase<{
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            } & {} & {
+                $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+                    default?: (() => vue.VNodeChild) | undefined;
+                };
+                $slots?: {
+                    default?: (() => vue.VNodeChild) | undefined;
+                } | undefined;
+                'v-slots'?: {
+                    default?: false | (() => vue.VNodeChild) | undefined;
+                } | undefined;
+            } & {
+                "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+            }, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, {
+                origin: string;
+                group: boolean;
+                mode: string;
+                hideOnLeave: boolean;
+                leaveAbsolute: boolean;
+            }, {}, string> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }, vue.ExtractPropTypes<{
+                group: BooleanConstructor;
+                hideOnLeave: BooleanConstructor;
+                leaveAbsolute: BooleanConstructor;
+                mode: {
+                    type: StringConstructor;
+                    default: string | undefined;
+                };
+                origin: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>>;
+        };
+    };
+    active: BooleanConstructor;
+    max: (StringConstructor | NumberConstructor)[];
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+}>>;
 type VCounter = InstanceType<typeof VCounter>;
 
 export { VCounter };