@omnia/fx 8.0.44-vnext → 8.0.46-vnext

package/internal-do-not-import-from-here/ux/ComponentTypings.d.ts

@@ -67,19 +67,39 @@ type VuetifyProps<T> = {
 type VuetifySlots<T> = {
     [K in keyof T as K extends `v-slot:${infer N}` ? N : never]: T[K];
 };
-import { VTextField, VBtn, VBtnToggle, VBtnGroup, VNavigationDrawer, VList, VListItem, VListGroup, VListImg, VListItemAction, VListItemTitle, VListItemSubtitle, VListItemMedia, VListSubheader, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VCard, VCardActions, VCardItem, VCardSubtitle, VCardText, VCardTitle, VExpansionPanels, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VAutocomplete, VMenu, VTable, VCheckbox, VCheckboxBtn, VVirtualScroll } from "vuetify/components";
+type VuetifyValue<T> = T extends {
+    value?: any;
+} ? T["value"] : T;
+import { VTextField, VBtn, VBtnToggle, VBtnGroup, VNavigationDrawer, VList, VListItem, VListGroup, VListImg, VListItemAction, VListItemTitle, VListItemSubtitle, VListItemMedia, VListSubheader, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VCard, VCardActions, VCardItem, VCardSubtitle, VCardText, VCardTitle, VExpansionPanels, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VAutocomplete, VMenu, VTable, VCheckbox, VCheckboxBtn, VVirtualScroll, VChip, VSelect, VBadge } from "vuetify/components";
+import { Intersect } from "vuetify/directives";
 import { VDataTable, VDataTableRow, VDataTableRows, VDataTableVirtual, VDataTableServer } from "vuetify/labs/components";
 export interface VDataTableServerSlots extends VuetifySlots<VuetifyProps<Pick<VDataTableServer, "$props">>> {
 }
 export interface VDataTableSlots extends VuetifySlots<VuetifyProps<Pick<VDataTable, "$props">>> {
 }
+export interface VListItemSlots extends VuetifySlots<VuetifyProps<Pick<VListItem, "$props">>> {
+}
+export interface VTextFieldSlots extends VuetifySlots<VuetifyProps<Pick<VTextField, "$props">>> {
+}
 declare global {
     namespace JSX {
         interface Element {
         }
         interface ElementClass {
         }
+        interface IntrinsicAttributes {
+            "v-intersect"?: VuetifyValue<Pick<Parameters<typeof Intersect.mounted>[1], "value">>;
+        }
         interface IntrinsicElements {
+            "v-badge": VuetifyProps<Pick<VBadge, "$props">> & {
+                [name: string]: any;
+            };
+            "v-select": VuetifyProps<Pick<VSelect, "$props">> & {
+                [name: string]: any;
+            };
+            "v-chip": VuetifyProps<Pick<VChip, "$props">> & {
+                [name: string]: any;
+            };
             "v-data-table-server": VuetifyProps<Pick<VDataTableServer, "$props">> & {
                 [name: string]: any;
             };

package/internal-do-not-import-from-here/ux/DefineVueTypings.d.ts

@@ -1,5 +1,4 @@
 import { Prop, PropType, VNodeChild } from "vue";
-import { Func } from "../models/Func";
 export type Slot<T extends any[] = any[]> = (...args: T) => VNodeChild;
 export type VModelKeyNameInJsxElement<N extends string> = N extends "" ? "v-model" : `v-model:${N}`;
 export type VModelEmitsInJsxElement<N extends string> = N extends "" ? "onUpdate:modelValue" : `onUpdate:${N}`;
@@ -62,15 +61,15 @@ export type DefinePropModelDoc<TName extends string, TPropType, E> = E & BuildVM
     defaultValue(value?: TPropType): Omit<DefinePropModelDefaultValue<TName, TPropType, E>, "require">;
 };
 export type DefinePropModelSlots = {
-    slots<Slots extends Record<string, Slot | false>>(): {
+    slots<Slots>(): {
         "v-slots": Prop<{
-            default?: Func<[VNodeChild]>;
+            default?: Slot;
         } & Slots>;
         doc$(doc?: {
             [K in keyof Slots]: string;
         }): {
             "v-slots": Prop<{
-                default?: Func<[VNodeChild]>;
+                default?: Slot;
             } & Slots>;
         };
     };

package/internal-do-not-import-from-here/ux/Exposes.d.ts

@@ -79,4 +79,4 @@ export type { FocusOption, ClickOutOption, ScrollOption, LinkHandlerOptions, } f
 export { FocusDirective, ClickOutDirective, ScrollDirective, LinkHandlerDirective, } from "./directives";
 export { VueComponentBase, getVuetifyAppClasses, VueComponentConnect, } from "./VueComponentBase";
 export type { VueComponentBaseProps, VueComponentBaseEvents, } from "./VueComponentBase";
-export { defineVueWebComponent, defineVueComponent, defineSlotsAndProps, definePropFunctionType, definePropObjectType, defineVue } from "./InternalDefineWebComponent";
+export { defineVueWebComponent, defineVueComponent, definePropFunctionType, definePropObjectType, defineVue } from "./InternalDefineWebComponent";

package/internal-do-not-import-from-here/ux/InternalDefineWebComponent.d.ts

@@ -1,8 +1,7 @@
-import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentPropsOptions, DefineComponent, ComponentObjectPropsOptions, Prop, VNodeChild, PropType, ObjectEmitsOptions, CreateComponentPublicInstance, ExtractPropTypes, ExtractDefaultPropTypes, ComponentOptionsBase, RenderFunction, VNode, SlotsType, ComponentOptions } from "vue";
+import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentPropsOptions, DefineComponent, ComponentObjectPropsOptions, Prop, PropType, ObjectEmitsOptions, CreateComponentPublicInstance, ExtractPropTypes, ExtractDefaultPropTypes, ComponentOptionsBase, RenderFunction, SlotsType, ComponentOptions, Slot } from "vue";
 import { LooseRequired, UnionToIntersection, Prettify } from "@vue/shared";
 import { ThemeableComponentProps, WebComponentBundleManifest } from "@omnia/fx-models";
 import { useColorSchemaSetup, useBlueprintSetup } from "./use";
-import { Slot } from "./DefineVueTypings";
 export declare function definePropFunctionType<T>(): PropType<T>;
 export declare function definePropObjectType<T>(): PropType<T>;
 type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
@@ -36,6 +35,11 @@ type ExcludeJsxPropKeys<T> = T extends string[] ? T : {
 type ExtractPropModels<T> = {
     -readonly [K in keyof T as K extends `v-model:${infer N}` ? N : K extends "v-model" ? "modelValue" : never]: T[K];
 };
+type ExtractPropSlots<T> = T extends {
+    ["v-slots"]?: any;
+} ? T["v-slots"] : {
+    default?: Slot;
+};
 type RequiredKeys<T> = {
     [K in keyof T]: T[K] extends {
         required: true;
@@ -55,11 +59,6 @@ type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
 type TsxComponentV3<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PropsDefinition = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? CustomExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions>> = DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE> & {
     propsDefinition: PropsDefinition extends {} ? Omit<PropsDefinition, keyof ({} extends E ? {} : EmitsToProps<E>)> & ({} extends E ? {} : EmitsToProps<E>) : never;
 };
-export declare function defineSlotsAndProps<Slots extends Record<string, Slot>>(): <Props>(props: ComponentObjectPropsOptions<Props>) => ComponentObjectPropsOptions<Props> & {
-    "v-slots"?: Prop<{
-        default?: () => VNodeChild;
-    } & Slots>;
-};
 type ComponentOptionsWithObjectPropsCustom<PropsOptions = ComponentObjectPropsOptions, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<ExtractPropTypes<PropsOptions>> & EmitsToProps<E>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBaseExtends<RemoveDefinePropApi<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> & {
     props: PropsOptions & ThisType<void>;
 } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I>>;
@@ -72,10 +71,6 @@ type ComponentOptionsWithArrayProps<PropNames extends string = string, RawBindin
     props: PropNames[];
 } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, {}, false, I>>;
 type Data = Record<string, unknown>;
-type InternalSlots = {
-    [name: string]: (...args: any[]) => VNode[] | undefined;
-};
-type Slots = Readonly<InternalSlots>;
 type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{
     [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : (event: key, ...args: any[]) => void;
 }[Event]>;
@@ -97,7 +92,7 @@ type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionType
 type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
 type SetupContext<Props, E = EmitsOptions> = E extends any ? {
     attrs: Data;
-    slots: Slots;
+    slots: ExtractPropSlots<Props>;
     models?: Required<ExtractPropModels<Props>>;
     colors: ReturnType<typeof useColorSchemaSetup>;
     blueprints: ReturnType<typeof useBlueprintSetup>;
@@ -109,13 +104,13 @@ interface ComponentOptionsBaseExtends<Props, RawBindings, D, C extends ComputedO
 }
 export declare function createPropType<T>(): PropType<T>;
 export declare function defineVue(): {
-    slots<Slots_1 extends Record<string, false | Slot<any[]>>>(): {
+    slots<Slots_1>(): {
         "v-slots": Prop<{
-            default?: import("@omnia/fx-models").Func<[VNodeChild]>;
+            default?: import("./DefineVueTypings").Slot<any[]>;
         } & Slots_1>;
         doc$(doc?: { [K in keyof Slots_1]: string; }): {
             "v-slots": Prop<{
-                default?: import("@omnia/fx-models").Func<[VNodeChild]>;
+                default?: import("./DefineVueTypings").Slot<any[]>;
             } & Slots_1>;
         };
     };

package/internal-do-not-import-from-here/ux/app/management/tabs/templates/Template.d.ts

@@ -50,8 +50,8 @@ declare const _default: {
                 [key: string]: any;
             }>) => void)[];
             readonly edit?: (template: AppTemplate) => void;
-            readonly cols?: number;
             readonly item?: AppTemplate;
+            readonly cols?: number;
         };
         $attrs: {
             [x: string]: unknown;
@@ -109,8 +109,8 @@ declare const _default: {
     propsDefinition: Omit<Readonly<{} & {
         delete?: () => void;
         edit?: (template: AppTemplate) => void;
-        cols?: number;
         item?: AppTemplate;
+        cols?: number;
     }>, never>;
 };
 export default _default;

package/internal-do-not-import-from-here/ux/identities/IdentityRenderer.d.ts

@@ -1,8 +1,5 @@
 import { Identity, IResolvedIdentity } from "@omnia/fx-models";
-export type RenderSlotsType = {
-    left?: () => JSX.Element;
-    right?: () => JSX.Element;
-};
+import { VNodeChild } from "vue";
 export declare const identityRendererStyles: {
     container: {
         $nest: {
@@ -34,7 +31,7 @@ declare const _default: {
             style?: unknown;
             class?: unknown;
             key?: string | number | symbol;
-            readonly size?: number;
+            readonly size?: "small" | "default" | "large" | "x-large" | "x-small";
             readonly inline?: boolean;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
@@ -77,7 +74,15 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly valueBind?: Identity[];
+            readonly "v-slots"?: {
+                default?: import("../DefineVueTypings").Slot<any[]>;
+            } & {
+                left?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+                right?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+            };
+            readonly "v-model"?: Identity[];
+            readonly modelValue?: Identity[];
+            readonly "onUpdate:modelValue"?: (value: Identity[]) => any;
             readonly styles?: {
                 container: {
                     $nest: {
@@ -107,7 +112,6 @@ declare const _default: {
             readonly presenceRtlOffsetX?: number;
             readonly presenceOffsetY?: number;
             readonly hideUsername?: boolean;
-            readonly renderSlots?: (resolvedIdentity: IResolvedIdentity) => RenderSlotsType;
         };
         $attrs: {
             [x: string]: unknown;
@@ -123,8 +127,157 @@ declare const _default: {
         $emit: (event: string, ...args: any[]) => void;
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            valueBind: import("vue").Prop<Identity[], Identity[]>;
-            styles: import("vue").Prop<{
+            "v-slots": import("vue").Prop<{
+                default?: import("../DefineVueTypings").Slot<any[]>;
+            } & {
+                left?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+                right?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+            }>;
+            hideUsername: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            presenceOffsetY: {
+                type: import("vue").PropType<number>;
+                required: false;
+            };
+            presenceRtlOffsetX: {
+                type: import("vue").PropType<number>;
+                required: false;
+            };
+            presenceOffsetX: {
+                type: import("vue").PropType<number>;
+                required: false;
+            };
+            hidePresence: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            imageOnly: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            styles: {
+                type: import("vue").PropType<{
+                    container: {
+                        $nest: {
+                            ".v-list": {
+                                background: string;
+                            };
+                        };
+                    };
+                    smallPresenceStatus: {
+                        $nest: {
+                            ".v-badge__badge": {
+                                padding: string;
+                                height: string;
+                                minWidth: string;
+                                $nest: {
+                                    ".v-icon": {
+                                        fontSize: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }>;
+            } & {
+                type: import("vue").PropType<{
+                    container: {
+                        $nest: {
+                            ".v-list": {
+                                background: string;
+                            };
+                        };
+                    };
+                    smallPresenceStatus: {
+                        $nest: {
+                            ".v-badge__badge": {
+                                padding: string;
+                                height: string;
+                                minWidth: string;
+                                $nest: {
+                                    ".v-icon": {
+                                        fontSize: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                }>;
+            };
+            inline: {
+                type: import("vue").PropType<boolean>;
+                required: false;
+            };
+            size: {
+                type: import("vue").PropType<"small" | "default" | "large" | "x-large" | "x-small">;
+                required: false;
+            };
+            "onUpdate:modelValue": {
+                type: import("vue").PropType<(value: Identity[]) => any>;
+            };
+            "v-model": {
+                type: import("vue").PropType<Identity[]>;
+                required: false;
+            };
+            modelValue: {
+                type: import("vue").PropType<Identity[]>;
+                required: false;
+            };
+        }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("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?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        "v-slots": import("vue").Prop<{
+            default?: import("../DefineVueTypings").Slot<any[]>;
+        } & {
+            left?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+            right?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+        }>;
+        hideUsername: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        presenceOffsetY: {
+            type: import("vue").PropType<number>;
+            required: false;
+        };
+        presenceRtlOffsetX: {
+            type: import("vue").PropType<number>;
+            required: false;
+        };
+        presenceOffsetX: {
+            type: import("vue").PropType<number>;
+            required: false;
+        };
+        hidePresence: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        imageOnly: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        styles: {
+            type: import("vue").PropType<{
                 container: {
                     $nest: {
                         ".v-list": {
@@ -146,7 +299,9 @@ declare const _default: {
                         };
                     };
                 };
-            }, {
+            }>;
+        } & {
+            type: import("vue").PropType<{
                 container: {
                     $nest: {
                         ".v-list": {
@@ -169,38 +324,63 @@ declare const _default: {
                     };
                 };
             }>;
-            size: import("vue").Prop<number, number>;
-            inline: import("vue").Prop<boolean, boolean>;
-            hidePresence: import("vue").Prop<boolean, boolean>;
-            imageOnly: import("vue").Prop<boolean, boolean>;
-            presenceOffsetX: import("vue").Prop<number, number>;
-            presenceRtlOffsetX: import("vue").Prop<number, number>;
-            presenceOffsetY: import("vue").Prop<number, number>;
-            hideUsername: import("vue").Prop<boolean, boolean>;
-            renderSlots: import("vue").Prop<(resolvedIdentity: IResolvedIdentity) => RenderSlotsType, (resolvedIdentity: IResolvedIdentity) => RenderSlotsType>;
-        }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
-            beforeCreate?: (() => void) | (() => void)[];
-            created?: (() => void) | (() => void)[];
-            beforeMount?: (() => void) | (() => void)[];
-            mounted?: (() => void) | (() => void)[];
-            beforeUpdate?: (() => void) | (() => void)[];
-            updated?: (() => void) | (() => void)[];
-            activated?: (() => void) | (() => void)[];
-            deactivated?: (() => void) | (() => void)[];
-            beforeDestroy?: (() => void) | (() => void)[];
-            beforeUnmount?: (() => void) | (() => void)[];
-            destroyed?: (() => void) | (() => void)[];
-            unmounted?: (() => void) | (() => void)[];
-            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
         };
-        $forceUpdate: () => void;
-        $nextTick: typeof import("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?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
-    } & Readonly<import("vue").ExtractPropTypes<{
-        valueBind: import("vue").Prop<Identity[], Identity[]>;
-        styles: import("vue").Prop<{
+        inline: {
+            type: import("vue").PropType<boolean>;
+            required: false;
+        };
+        size: {
+            type: import("vue").PropType<"small" | "default" | "large" | "x-large" | "x-small">;
+            required: false;
+        };
+        "onUpdate:modelValue": {
+            type: import("vue").PropType<(value: Identity[]) => any>;
+        };
+        "v-model": {
+            type: import("vue").PropType<Identity[]>;
+            required: false;
+        };
+        modelValue: {
+            type: import("vue").PropType<Identity[]>;
+            required: false;
+        };
+    }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    "v-slots": import("vue").Prop<{
+        default?: import("../DefineVueTypings").Slot<any[]>;
+    } & {
+        left?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+        right?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+    }>;
+    hideUsername: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    presenceOffsetY: {
+        type: import("vue").PropType<number>;
+        required: false;
+    };
+    presenceRtlOffsetX: {
+        type: import("vue").PropType<number>;
+        required: false;
+    };
+    presenceOffsetX: {
+        type: import("vue").PropType<number>;
+        required: false;
+    };
+    hidePresence: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    imageOnly: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    styles: {
+        type: import("vue").PropType<{
             container: {
                 $nest: {
                     ".v-list": {
@@ -222,7 +402,9 @@ declare const _default: {
                     };
                 };
             };
-        }, {
+        }>;
+    } & {
+        type: import("vue").PropType<{
             container: {
                 $nest: {
                     ".v-list": {
@@ -245,80 +427,39 @@ declare const _default: {
                 };
             };
         }>;
-        size: import("vue").Prop<number, number>;
-        inline: import("vue").Prop<boolean, boolean>;
-        hidePresence: import("vue").Prop<boolean, boolean>;
-        imageOnly: import("vue").Prop<boolean, boolean>;
-        presenceOffsetX: import("vue").Prop<number, number>;
-        presenceRtlOffsetX: import("vue").Prop<number, number>;
-        presenceOffsetY: import("vue").Prop<number, number>;
-        hideUsername: import("vue").Prop<boolean, boolean>;
-        renderSlots: import("vue").Prop<(resolvedIdentity: IResolvedIdentity) => RenderSlotsType, (resolvedIdentity: IResolvedIdentity) => RenderSlotsType>;
-    }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    valueBind: import("vue").Prop<Identity[], Identity[]>;
-    styles: import("vue").Prop<{
-        container: {
-            $nest: {
-                ".v-list": {
-                    background: string;
-                };
-            };
-        };
-        smallPresenceStatus: {
-            $nest: {
-                ".v-badge__badge": {
-                    padding: string;
-                    height: string;
-                    minWidth: string;
-                    $nest: {
-                        ".v-icon": {
-                            fontSize: string;
-                        };
-                    };
-                };
-            };
-        };
-    }, {
-        container: {
-            $nest: {
-                ".v-list": {
-                    background: string;
-                };
-            };
-        };
-        smallPresenceStatus: {
-            $nest: {
-                ".v-badge__badge": {
-                    padding: string;
-                    height: string;
-                    minWidth: string;
-                    $nest: {
-                        ".v-icon": {
-                            fontSize: string;
-                        };
-                    };
-                };
-            };
-        };
-    }>;
-    size: import("vue").Prop<number, number>;
-    inline: import("vue").Prop<boolean, boolean>;
-    hidePresence: import("vue").Prop<boolean, boolean>;
-    imageOnly: import("vue").Prop<boolean, boolean>;
-    presenceOffsetX: import("vue").Prop<number, number>;
-    presenceRtlOffsetX: import("vue").Prop<number, number>;
-    presenceOffsetY: import("vue").Prop<number, number>;
-    hideUsername: import("vue").Prop<boolean, boolean>;
-    renderSlots: import("vue").Prop<(resolvedIdentity: IResolvedIdentity) => RenderSlotsType, (resolvedIdentity: IResolvedIdentity) => RenderSlotsType>;
-}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    };
+    inline: {
+        type: import("vue").PropType<boolean>;
+        required: false;
+    };
+    size: {
+        type: import("vue").PropType<"small" | "default" | "large" | "x-large" | "x-small">;
+        required: false;
+    };
+    "onUpdate:modelValue": {
+        type: import("vue").PropType<(value: Identity[]) => any>;
+    };
+    "v-model": {
+        type: import("vue").PropType<Identity[]>;
+        required: false;
+    };
+    modelValue: {
+        type: import("vue").PropType<Identity[]>;
+        required: false;
+    };
+}>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
-        size?: number;
+        size?: "small" | "default" | "large" | "x-large" | "x-small";
         inline?: boolean;
-        valueBind?: Identity[];
+        "v-slots"?: {
+            default?: import("../DefineVueTypings").Slot<any[]>;
+        } & {
+            left?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+            right?: (resolvedIdentity: IResolvedIdentity) => VNodeChild;
+        };
+        "v-model"?: Identity[];
+        modelValue?: Identity[];
+        "onUpdate:modelValue"?: (value: Identity[]) => any;
         styles?: {
             container: {
                 $nest: {
@@ -348,7 +489,6 @@ declare const _default: {
         presenceRtlOffsetX?: number;
         presenceOffsetY?: number;
         hideUsername?: boolean;
-        renderSlots?: (resolvedIdentity: IResolvedIdentity) => RenderSlotsType;
     }>, never>;
 };
 export default _default;