@omnia/fx 7.0.527-dev → 8.0.0-vnext

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

@@ -1,7 +1,47 @@
 import type { IDateTimeZonePicker } from "./IDateTimeZonePicker";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IDateTimeZonePicker, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IDateTimeZonePicker, never>;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IDateTimeZonePicker, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IDateTimeZonePicker, never>;
-});
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IDateTimeZonePicker>>> & 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<IDateTimeZonePicker>>>, {}, {}, {}, {}, 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<IDateTimeZonePicker>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IDateTimeZonePicker>>>, {}, {}, {}, {}, 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<IDateTimeZonePicker>>>;
+};
 export default _default;

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

@@ -1,7 +1,47 @@
 import type { IDateTimeZoneRenderer } from "./IDateTimeZoneRenderer";
-declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IDateTimeZoneRenderer, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IDateTimeZoneRenderer, never>;
-}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IDateTimeZoneRenderer, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<IDateTimeZoneRenderer, never>;
-});
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IDateTimeZoneRenderer>>> & 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<IDateTimeZoneRenderer>>>, {}, {}, {}, {}, 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<IDateTimeZoneRenderer>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IDateTimeZoneRenderer>>>, {}, {}, {}, {}, 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<IDateTimeZoneRenderer>>>;
+};
 export default _default;

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

@@ -0,0 +1,6 @@
+import { VueDecorator } from "./Helpers";
+/**
+ * Decorator of an event-emitter function
+ * @param  event The name of the event
+ */
+export declare function Emit(event?: string): VueDecorator;

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

@@ -0,0 +1,16 @@
+import { ComponentOptions, ShallowUnwrapRef, Ref } from "vue";
+import { Vue, VueBase, VueConstructor, VueMixin } from "./Vue";
+export declare function Options<V extends Vue>(options: ComponentOptions & ThisType<V>): <VC extends VueConstructor>(target: VC) => VC;
+export interface VueDecorator {
+    (Ctor: VueConstructor<VueBase>): void;
+    (target: VueBase, key: string): void;
+    (target: VueBase, key: string, index: number): void;
+}
+export declare function createDecorator(factory: (options: ComponentOptions, key: string, index: number) => void): VueDecorator;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type ExtractInstance<T> = T extends VueMixin<infer V> ? V : never;
+export type MixedVueBase<Mixins extends VueMixin[]> = Mixins extends (infer T)[] ? VueConstructor<UnionToIntersection<ExtractInstance<T>> & Vue> : never;
+export declare function mixins<T extends VueMixin[]>(...Ctors: T): MixedVueBase<T>;
+export type UnwrapSetupValue<T> = T extends Ref<infer R> ? R : ShallowUnwrapRef<T>;
+export type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;
+export declare function setup<R>(setupFn: () => R): UnwrapSetupValue<UnwrapPromise<R>>;

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

@@ -0,0 +1,9 @@
+import { VueDecorator } from "./Helpers";
+import { PropOptions } from "./Props";
+type Constructor = (new () => any) | SymbolConstructor;
+/**
+ * Decorator for prop options
+ * @param propOptions the options for the prop
+ */
+export declare function Prop(propOptions?: Constructor | Constructor[] | PropOptions): VueDecorator;
+export {};

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

@@ -0,0 +1,33 @@
+import { Prop, PropType } from "vue";
+import { Vue } from "./Vue";
+declare const withDefaultSymbol: unique symbol;
+export interface WithDefault<T> {
+    [withDefaultSymbol]: T;
+}
+export type DefaultFactory<T> = (props: Record<string, unknown>) => T | null | undefined;
+export interface PropOptions<T = any, D = T> {
+    type?: PropType<T> | true | null;
+    required?: boolean;
+    default?: D | DefaultFactory<D> | null | undefined | object;
+    validator?(value: unknown): boolean;
+}
+export interface PropOptionsWithDefault<T, D = T> extends PropOptions<T, D> {
+    default: PropOptions<T, D>["default"];
+}
+export interface PropOptionsWithRequired<T, D = T> extends PropOptions<T, D> {
+    required: true;
+}
+export type VueWithProps<P> = Vue<ExtractProps<P>, {}, ExtractDefaultProps<P>> & ExtractProps<P>;
+export type ExtractProps<P> = {
+    [K in keyof P]: P[K] extends WithDefault<infer T> ? T : P[K];
+};
+export type DefaultKeys<P> = {
+    [K in keyof P]: P[K] extends WithDefault<any> ? K : never;
+}[keyof P];
+export type ExtractDefaultProps<P> = {
+    [K in DefaultKeys<P>]: P[K] extends WithDefault<infer T> ? T : never;
+};
+export declare function prop<T>(options: PropOptionsWithDefault<T>): WithDefault<T>;
+export declare function prop<T>(options: PropOptionsWithRequired<T>): T;
+export declare function prop<T>(options: Prop<T>): T | undefined;
+export {};

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

@@ -0,0 +1,91 @@
+import { ComponentPublicInstance, ComponentOptions, VNode, VNodeProps, AllowedComponentProps, ComponentCustomProps, EmitsOptions, Slots } from "vue";
+import { VueWithProps } from "./Props";
+export interface VueStatic {
+    /**
+     * @internal
+     * The cache of __vccOpts
+     */
+    __c?: ComponentOptions;
+    /**
+     * @internal
+     * The base options specified to this class.
+     */
+    __b?: ComponentOptions;
+    /**
+     * @internal
+     * Component options specified with `@Options` decorator
+     */
+    __o?: ComponentOptions;
+    /**
+     * @internal
+     * Decorators applied to this class.
+     */
+    __d?: ((options: ComponentOptions) => void)[];
+    /**
+     * @internal
+     * Registered (lifecycle) hooks that will be ported from class methods
+     * into component options.
+     */
+    __h: string[];
+    /**
+     * @internal
+     * Final component options object that Vue core processes.
+     * The name must be __vccOpts since it is the contract with the Vue core.
+     */
+    __vccOpts: ComponentOptions;
+    /** @internal */
+    render?: () => VNode | void;
+    /** @internal */
+    ssrRender?: () => void;
+    /** @internal */
+    __file?: string;
+    /** @internal */
+    __cssModules?: Record<string, any>;
+    /** @internal */
+    __scopeId?: string;
+    /** @internal */
+    __hmrId?: string;
+}
+export type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
+export type VueBase = Vue<unknown, never[]>;
+export type VueMixin<V extends VueBase = VueBase> = VueStatic & {
+    prototype: V;
+};
+export interface ClassComponentHooks {
+    propertyData?(): object;
+    beforeCreate?(): void;
+    created?(): void;
+    beforeMount?(): void;
+    mounted?(): void;
+    beforeUnmount?(): void;
+    unmounted?(): void;
+    beforeUpdate?(): void;
+    updated?(): void;
+    activated?(): void;
+    deactivated?(): void;
+    render?(): VNode | void | boolean;
+    errorCaptured?(err: Error, vm: Vue, info: string): boolean | undefined;
+    serverPrefetch?(): Promise<unknown>;
+}
+interface LegacyPublicProperties {
+    $set(target: object, key: string, value: any): void;
+    $delete(target: object, key: string): void;
+    $mount(el?: string | Element): this;
+    $destroy(): void;
+    $scopedSlots: Slots;
+    $on(event: string | string[], fn: Function): this;
+    $once(event: string, fn: Function): this;
+    $off(event?: string | string[], fn?: Function): this;
+    $children: Vue[];
+    $listeners: Record<string, Function | Function[]>;
+}
+export type Vue<Props = unknown, Emits extends EmitsOptions = {}, DefaultProps = {}> = ComponentPublicInstance<Props, {}, {}, {}, {}, Emits, PublicProps, DefaultProps, true> & LegacyPublicProperties & ClassComponentHooks;
+export interface VueConstructor<V extends VueBase = Vue> extends VueMixin<V> {
+    new (...args: any[]): V;
+    registerHooks(keys: string[]): void;
+    with<P extends {
+        new (): unknown;
+    }>(Props: P): VueConstructor<V & VueWithProps<InstanceType<P>>>;
+}
+export declare const Vue: VueConstructor;
+export {};

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

@@ -0,0 +1,8 @@
+import { WatchOptions } from "vue";
+import { VueDecorator } from "./Helpers";
+/**
+ * Decorator for watch options
+ * @param path the path or the expression to observe
+ * @param watchOptions
+ */
+export declare function Watch(path: string, watchOptions?: WatchOptions): VueDecorator;

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

@@ -0,0 +1,5 @@
+export * from "./Prop";
+export * from "./Watch";
+export * from "./Vue";
+export * from "./Emit";
+export { Options } from "./Helpers";

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

@@ -1,30 +1,92 @@
 import { DialogModel, DialogPositions } from "./IDialog";
-declare const dialogComponent: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
-    contentClass: string;
-    headerClass: string;
-    disabled: boolean;
-    hideOverlay: boolean;
-    lazy: boolean;
-    customZIndex: boolean;
-    maxWidth: string | number;
-    persistent: boolean;
-    scrollable: boolean;
-    width: string | number;
-    title: string;
-    light: boolean;
-    dark: boolean;
-    onClose: () => void;
-    attach: string;
-    hideCloseButton: boolean;
-    retainFocus: boolean;
-    valueBind: DialogModel;
-    position: DialogPositions;
-    onClickOutside: (closeDialog: (prompt: boolean, title?: string) => void, event?: Event) => void;
-    noClickAnimation: boolean;
-    renderBody: () => JSX.Element;
-    eager: boolean;
-}, never>, any, any, any>> & {
-    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+import { nextTick } from "vue";
+declare const dialogComponent: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
+            contentClass: string;
+            headerClass: string;
+            disabled: boolean;
+            hideOverlay: boolean;
+            lazy: boolean;
+            customZIndex: boolean;
+            maxWidth: string | number;
+            persistent: boolean;
+            scrollable: boolean;
+            width: string | number;
+            title: string;
+            light: boolean;
+            dark: boolean;
+            onClose: () => void;
+            attach: string;
+            hideCloseButton: boolean;
+            retainFocus: boolean;
+            valueBind: DialogModel;
+            position: DialogPositions;
+            onClickOutside: (closeDialog: (prompt: boolean, title?: string) => void, event?: Event) => void;
+            noClickAnimation: boolean;
+            renderBody: () => JSX.Element;
+            eager: 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<{
+            contentClass: string;
+            headerClass: string;
+            disabled: boolean;
+            hideOverlay: boolean;
+            lazy: boolean;
+            customZIndex: boolean;
+            maxWidth: string | number;
+            persistent: boolean;
+            scrollable: boolean;
+            width: string | number;
+            title: string;
+            light: boolean;
+            dark: boolean;
+            onClose: () => void;
+            attach: string;
+            hideCloseButton: boolean;
+            retainFocus: boolean;
+            valueBind: DialogModel;
+            position: DialogPositions;
+            onClickOutside: (closeDialog: (prompt: boolean, title?: string) => void, event?: Event) => void;
+            noClickAnimation: boolean;
+            renderBody: () => JSX.Element;
+            eager: boolean;
+        }>>>, () => 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 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<{
         contentClass: string;
         headerClass: string;
         disabled: boolean;
@@ -48,8 +110,11 @@ declare const dialogComponent: (import("vue").VueConstructor<import("vue-tsx-sup
         noClickAnimation: boolean;
         renderBody: () => JSX.Element;
         eager: boolean;
-    }, never>;
-}) | (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<{
     contentClass: string;
     headerClass: string;
     disabled: boolean;
@@ -73,8 +138,8 @@ declare const dialogComponent: (import("vue").VueConstructor<import("vue-tsx-sup
     noClickAnimation: boolean;
     renderBody: () => JSX.Element;
     eager: boolean;
-}, never>, 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<{
         contentClass: string;
         headerClass: string;
         disabled: boolean;
@@ -98,6 +163,6 @@ declare const dialogComponent: (import("vue").VueConstructor<import("vue-tsx-sup
         noClickAnimation: boolean;
         renderBody: () => JSX.Element;
         eager: boolean;
-    }, never>;
-});
+    }>>>;
+};
 export default dialogComponent;

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

@@ -1,4 +1,3 @@
-import { VNodeDirective } from "vue";
 import { LinkType, LinkTypeConfig } from "@omnia/fx-models";
 /**
  * Link handler options
@@ -38,5 +37,21 @@ export declare function registerLinkHandlerDirective(): void;
  * @returns {Array[VNodeDirective]} Array contains link handler directive
  */
 export declare function LinkHandlerDirective(options: LinkHandlerOptions): {
-    directives: VNodeDirective[];
+    directives: {
+        name: string;
+        value: {
+            /**
+             * URL passed to link handler provider
+             */
+            url: string;
+            /**
+             * Link type to match with provider
+             */
+            linkType: LinkType;
+            /**
+             * Additional configuration for link handler and provider
+             */
+            config?: LinkTypeConfig;
+        };
+    }[];
 };

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

@@ -1,8 +1,8 @@
-import Vue from "vue";
+import { VueComponentBase } from "@omnia/fx/ux";
 import { IWebComponentInstance } from "../..";
 import { IDocumentIcon } from "./IDocumentIcon";
 import { IconSizes, ImageSources } from "../../models";
-export declare class DocumentIcon extends Vue implements IWebComponentInstance, IDocumentIcon {
+export declare class DocumentIcon extends VueComponentBase implements IWebComponentInstance, IDocumentIcon {
     color?: string;
     size?: IconSizes;
     source?: ImageSources;
@@ -14,5 +14,5 @@ export declare class DocumentIcon extends Vue implements IWebComponentInstance,
     extensionChange(): void;
     private getFontAwesomeFileIcon;
     private getBase64FileIcon;
-    render(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }

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

@@ -1,4 +1,5 @@
 import { IconSizes, ImageSources } from "@omnia/fx/models";
+import { TsxAllowUnknowProperties } from "../TsxAllowUnknowProperties";
 export interface IDocumentIconProperties {
     size?: IconSizes;
     source?: ImageSources;
@@ -10,7 +11,7 @@ export interface IDocumentIcon extends IDocumentIconProperties {
     [name: string]: any;
 }
 declare global {
-    namespace VueTsxSupport.JSX {
+    namespace JSX {
         interface Element {
         }
         interface ElementClass {
@@ -18,7 +19,7 @@ declare global {
         interface ElementAttributesProperty {
         }
         interface IntrinsicElements {
-            "omfx-document-icon": IDocumentIcon;
+            "omfx-document-icon": TsxAllowUnknowProperties<IDocumentIcon>;
         }
     }
 }

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

@@ -1,23 +1,73 @@
 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;
-}, "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;
+        }>>> & 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;
+        }>>>, () => 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;
-    }, "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;
-}, "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;
-    }, "valueBind">;
-});
+    }>>>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/editorchrome/action_toolbar/ActionToolbar.d.ts

@@ -22,5 +22,5 @@ export declare class ActionToolbar extends VueComponentBase<IActionToolbar> {
     private createButtonGroup;
     private renderToolbarWithButtons;
     private renderToolbarWithLoadingIndicator;
-    render(h: any): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }

package/internal-do-not-import-from-here/ux/editorchrome/action_toolbar/DisplaySettingsToolbar.d.ts

@@ -13,5 +13,5 @@ export declare class DisplaySettingsToolbar extends VueComponentBase<DisplaySett
     getButtonClass(highlighted: boolean): any;
     private renderEditorActionButtonWithPermission;
     private renderEditorActionButton;
-    render(): VueTsxSupport.JSX.Element;
+    render(): JSX.Element;
 }