@omnia/fx 7.0.527-dev → 8.0.0-vnext

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

@@ -35,5 +35,5 @@ export declare class TextTranslator extends VueComponentBase implements IWebComp
     hideNonSystemLanguages(): void;
     renderIcon(): string;
     private renderLanguage;
-    render(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }

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

@@ -1,8 +1,8 @@
 import { ThemeDefinition } from "../../models";
 import { Theming } from "./Theming";
 import { ThemeStore } from "./ThemeStore";
+import { App, ComponentPublicInstance } from "vue";
 export type VueThemingInstance = {
-    $options: any;
     $theming: Theming;
     themeTargetId: string;
     themeDefinitionId: string;
@@ -14,9 +14,9 @@ export type VueThemingInstance = {
         id: string;
     };
     omvcparent: any;
-};
+} & ComponentPublicInstance;
 export declare class InternalTheming {
     themeStore: ThemeStore;
     private static _installed;
-    static install(vue: any): void;
+    static install(app: App): void;
 }

package/internal-do-not-import-from-here/ux/theming/components/IThemeDefinitionEditor.d.ts

@@ -10,7 +10,7 @@ export interface IThemeDefinitionEditor {
     [name: string]: any;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {

package/internal-do-not-import-from-here/ux/theming/components/ThemeDefinitionEditor.d.ts

@@ -26,14 +26,14 @@ export declare class ThemeDefinitionEditor extends VueComponentBase implements I
     mounted(): void;
     onModelUpdated(): void;
     onDefinitionSelected(themeDefintion: ThemeDefinition): void;
-    renderBorderThemeStyling(themeStyling: ThemeStyling, themeArea: ThemeArea): VueTsxSupport.JSX.Element;
-    renderAdvancedSettings(themeArea: ThemeArea, themeStyling: ThemeStyling): VueTsxSupport.JSX.Element;
-    renderCustomThemeStyling(themeDefinition: ThemeColorDefinition, themeArea: ThemeArea): VueTsxSupport.JSX.Element;
-    renderSettings(): VueTsxSupport.JSX.Element;
-    renderMenuItems(): VueTsxSupport.JSX.Element[];
-    renderMenu(): VueTsxSupport.JSX.Element;
-    renderSingleTab(): VueTsxSupport.JSX.Element;
-    renderTabs(): VueTsxSupport.JSX.Element;
-    render(): VueTsxSupport.JSX.Element;
+    renderBorderThemeStyling(themeStyling: ThemeStyling, themeArea: ThemeArea): JSX.Element;
+    renderAdvancedSettings(themeArea: ThemeArea, themeStyling: ThemeStyling): JSX.Element;
+    renderCustomThemeStyling(themeDefinition: ThemeColorDefinition, themeArea: ThemeArea): JSX.Element;
+    renderSettings(): JSX.Element;
+    renderMenuItems(): JSX.Element[];
+    renderMenu(): JSX.Element;
+    renderSingleTab(): JSX.Element;
+    renderTabs(): JSX.Element;
+    render(): JSX.Element;
 }
 export {};

package/internal-do-not-import-from-here/ux/theming-v2/themedefinitionpicker/ThemeDefinitionPicker.d.ts

@@ -1,19 +1,62 @@
 import { Guid, ThemeDefinitionV2 } from "@omnia/fx-models";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
-    model: Guid;
-    onChange: (theme: ThemeDefinitionV2) => void;
-}, "onChange" | "model">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            model: Guid;
+            onChange: (theme: ThemeDefinitionV2) => void;
+        }>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            model: Guid;
+            onChange: (theme: ThemeDefinitionV2) => void;
+        }>>>, () => 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<import("vue").ComponentObjectPropsOptions<{
         model: Guid;
         onChange: (theme: ThemeDefinitionV2) => void;
-    }, "onChange" | "model">;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    }>>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
     model: Guid;
     onChange: (theme: ThemeDefinitionV2) => void;
-}, "onChange" | "model">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+}>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
         model: Guid;
         onChange: (theme: ThemeDefinitionV2) => void;
-    }, "onChange" | "model">;
-});
+    }>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/theming-v2/themeeditor/ThemeEditor.d.ts

@@ -1,8 +1,69 @@
 import { ThemeStoreV2 } from "@omnia/fx/ux";
+import { nextTick } from "vue";
 export type RegisterThemeStore = (store: ThemeStoreV2) => void;
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<unknown, never>;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<unknown, never>;
-});
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            [x: number]: string;
+        } | {}> & Omit<(readonly string[] | Readonly<import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+            [x: string]: unknown;
+        }>>>>) & (import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<readonly string[] | import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+            [x: string]: unknown;
+        }>>>>), never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<readonly string[] | Readonly<import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+            [x: string]: unknown;
+        }>>>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            [x: number]: 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 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 string[] | Readonly<import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+        [x: string]: unknown;
+    }>>>>) & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {} & Readonly<readonly string[] | import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+        [x: string]: unknown;
+    }>>>>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<readonly string[] | Readonly<import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+    [x: string]: unknown;
+}>>>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    [x: number]: string;
+} | {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<readonly string[] | import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
+        [x: string]: unknown;
+    }>>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/theming-v2/themeeditor/components/ColorSelector.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>;
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/internal-do-not-import-from-here/ux/theming-v2/themeeditor/components/ThemeCodeEditor.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>;
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/internal-do-not-import-from-here/ux/theming-v2/themeeditor/components/ThemeViewer.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>;
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

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

@@ -1,6 +1,7 @@
 import { TsxAllowUnknowProperties } from "../";
 import { TimePeriodSettings } from "../../models";
 export interface ITimePeriodPicker {
+    label?: string;
     dark?: boolean;
     disabled?: boolean;
     hideDetails?: boolean;
@@ -8,7 +9,7 @@ export interface ITimePeriodPicker {
     onValueChanged: (model: TimePeriodSettings) => void;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {

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

@@ -1,9 +1,9 @@
-import Vue from "vue";
+import { VueComponentBase } from "@omnia/fx/ux";
 import { IWebComponentInstance } from "../../";
 import { ITimePeriodPicker } from ".";
 import { TimePeriodSettings, TimePeriodTypes } from "../../models";
 import { OmniaUxLocalization } from "../UxModels";
-export default class TimePeriodPicker extends Vue implements IWebComponentInstance, ITimePeriodPicker {
+export default class TimePeriodPicker extends VueComponentBase implements IWebComponentInstance, ITimePeriodPicker {
     dark: boolean;
     valueBind: TimePeriodSettings;
     onValueChanged: (model: TimePeriodSettings) => void;
@@ -25,5 +25,5 @@ export default class TimePeriodPicker extends Vue implements IWebComponentInstan
     init(): void;
     fixTimeValue(val: any): number;
     update(): void;
-    render(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }

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

@@ -13,7 +13,7 @@ export interface ITimeZonePicker {
     styles?: typeof TimeZonePickerStyles;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {

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

@@ -1,11 +1,11 @@
-import Vue from "vue";
+import { VueComponentBase } from "@omnia/fx/ux";
 import { IWebComponentInstance } from "../../";
 import { ITimeZonePicker } from "./ITimeZonePicker";
 import { TimeZone } from "../../models";
 import { ScopedSlots, TimeZonePickerStyles } from "..";
 import { IVSelectScopedSlots } from "../vuetify";
 import "./TimeZonePicker.css";
-export declare class TimeZonePicker extends Vue implements IWebComponentInstance, ITimeZonePicker {
+export declare class TimeZonePicker extends VueComponentBase implements IWebComponentInstance, ITimeZonePicker {
     valueBind: TimeZone;
     disabled?: boolean;
     label?: string;
@@ -28,5 +28,5 @@ export declare class TimeZonePicker extends Vue implements IWebComponentInstance
     private populateModel;
     private updateSelected;
     private onClick;
-    render(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }

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

@@ -1,5 +1,5 @@
 import { UrlPropertyValue } from "../../../fx/models";
-import { IValidator } from "@omnia/fx/ux";
+import { IValidator, TsxAllowUnknowProperties } from "@omnia/fx/ux";
 export interface IUrlInputProperties {
     /**Label */
     label?: string;
@@ -28,7 +28,7 @@ export interface IUrlInput extends IUrlInputProperties {
     onBlur?: () => void;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {
@@ -36,7 +36,7 @@ declare global {
         interface ElementAttributesProperty {
         }
         interface IntrinsicElements {
-            "omfx-url-input": IUrlInput;
+            "omfx-url-input": TsxAllowUnknowProperties<IUrlInput>;
         }
     }
 }

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

@@ -39,8 +39,8 @@ export declare class UrlInput extends VueComponentBase implements IWebComponentI
     validate(): boolean;
     clearValidation(): void;
     onClickUrlCategoryIcon(selectedProperty: string): void;
-    renderLabel(): VueTsxSupport.JSX.Element;
-    renderTabView(): VueTsxSupport.JSX.Element;
-    renderListView(): VueTsxSupport.JSX.Element;
+    renderLabel(): JSX.Element;
+    renderTabView(): JSX.Element;
+    renderListView(): JSX.Element;
     render(): JSX.Element;
 }

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

@@ -1,4 +1,5 @@
-import Vue, { Ref, ComputedRef } from "vue";
+import { Ref, ComputedRef } from "vue";
+import { Vue } from "../decorators";
 /**
  * Func
  *
@@ -31,8 +32,7 @@ export type MaybeComputedRef<T> = MaybeReadonlyRef<T> | MaybeRef<T>;
  * ```
  */
 export type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
-export declare type VueInstance = Vue;
 export declare type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
 export declare type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeComputedRef<T>;
-export declare type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
-export declare type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;
+export declare type MaybeElement = HTMLElement | SVGElement | Vue | undefined | null;
+export declare type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends Vue ? Exclude<MaybeElement, Vue> : T | undefined;

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

@@ -1,2 +1 @@
-import { Breakpoint } from "@omnia/fx-models";
-export declare function useBreakPoints(): Breakpoint;
+export declare function useBreakPoints(): import("vuetify").DisplayInstance;

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

@@ -1,10 +1,16 @@
 import { GuidValue } from "@omnia/fx-models";
-import { VNode, VNodeChildren, VNodeData } from "vue";
-export declare function useCurrentVueInstance(): import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>;
-export declare function useCreateElementByManifestId(componentManifestId: GuidValue, data?: VNodeData, children?: VNodeChildren, onComponentCreated?: (instance: any) => void): VNode;
-export declare function useCreateElementByName(elementName: string, data?: VNodeData, children?: VNodeChildren, onComponentCreated?: (instance: any) => void): VNode;
+import { VNodeArrayChildren, VNodeProps } from "vue";
+import { VNode } from "vue";
+type RawProps = VNodeProps & {
+    __v_isVNode?: never;
+    [Symbol.iterator]?: never;
+} & Record<string, any>;
+type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
+export declare function useCurrentVueInstance(): import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+export declare function useCreateVueNode(element: string | GuidValue, props?: RawProps, children?: RawChildren, onComponentCreated?: (instance: any) => void): VNode;
 export declare function useTransformVSlot(slots: {
     [name: string]: (ref?: any) => Array<JSX.Element>;
 }): {
     scopedSlots: any;
 };
+export {};

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

@@ -1,27 +1,78 @@
 import { PropertyDefinition, PropertyValueBinding, PropertyValue } from "@omnia/fx-models";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
-    valueBind: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>;
-    onValueBindChanged: (value: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>) => void;
-    disabled: boolean;
-    editMode: boolean;
-}, "valueBind">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            valueBind: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>;
+            onValueBindChanged: (value: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>) => void;
+            disabled: boolean;
+            editMode: boolean;
+        }>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            valueBind: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>;
+            onValueBindChanged: (value: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>) => void;
+            disabled: boolean;
+            editMode: boolean;
+        }>>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, 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<import("vue").ComponentObjectPropsOptions<{
         valueBind: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>;
         onValueBindChanged: (value: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>) => void;
         disabled: boolean;
         editMode: boolean;
-    }, "valueBind">;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => import("vue").VNode>, {}, import("vue-tsx-support").PropsForOutside<{
+    }>>> & import("vue").ShallowUnwrapRef<() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
     valueBind: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>;
     onValueBindChanged: (value: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>) => void;
     disabled: boolean;
     editMode: boolean;
-}, "valueBind">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+}>>>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
         valueBind: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>;
         onValueBindChanged: (value: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>) => void;
         disabled: boolean;
         editMode: boolean;
-    }, "valueBind">;
-});
+    }>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/user/components/PropertyConfigurationRenderer.d.ts

@@ -1,19 +1,62 @@
 import { UserPropertyConfiguration } from "@omnia/fx-models";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
-    valueBind: UserPropertyConfiguration;
-    onValueBindChanged: (newValue: UserPropertyConfiguration) => void;
-}, "valueBind" | "onValueBindChanged">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            valueBind: UserPropertyConfiguration;
+            onValueBindChanged: (newValue: UserPropertyConfiguration) => void;
+        }>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            valueBind: UserPropertyConfiguration;
+            onValueBindChanged: (newValue: UserPropertyConfiguration) => void;
+        }>>>, () => 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<import("vue").ComponentObjectPropsOptions<{
         valueBind: UserPropertyConfiguration;
         onValueBindChanged: (newValue: UserPropertyConfiguration) => void;
-    }, "valueBind" | "onValueBindChanged">;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    }>>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
     valueBind: UserPropertyConfiguration;
     onValueBindChanged: (newValue: UserPropertyConfiguration) => void;
-}, "valueBind" | "onValueBindChanged">, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+}>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
         valueBind: UserPropertyConfiguration;
         onValueBindChanged: (newValue: UserPropertyConfiguration) => void;
-    }, "valueBind" | "onValueBindChanged">;
-});
+    }>>>;
+};
 export default _default;