@omnia/fx 8.0.8-vnext → 8.0.10-vnext

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

@@ -42,6 +42,6 @@ declare const _default: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Readonly<import("vue").ExtractPropTypes<{}>>;
+    propsDefinition: Readonly<{} & {}>;
 };
 export default _default;

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

@@ -1,7 +1,7 @@
 import { VueComponentBase } from "@omnia/fx/ux";
 import "./StatusMessageOverlay.css";
 import { IWebComponentInstance } from "../..";
-import { StatusMessageOverlayType, HttpStatusCode } from "../../models";
+import { StatusMessageOverlayType, HttpStatusCode, LayoutEditorCanvasApi } from "../../models";
 import { IStatusMessageOverlay } from "./IStatusMessageOverlay";
 export declare class StatusMessageOverlay extends VueComponentBase implements IWebComponentInstance, IStatusMessageOverlay {
     content?: string | JSX.Element;
@@ -14,5 +14,8 @@ export declare class StatusMessageOverlay extends VueComponentBase implements IW
     mounted(): void;
     private renderStatusMessage;
     private renderStatusCode;
+    renderStatusMessageOverlay(): JSX.Element;
+    gotApi(api: LayoutEditorCanvasApi): void;
+    renderLayoutEngine(): JSX.Element;
     render(): JSX.Element;
 }

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

@@ -0,0 +1,24 @@
+import { Store } from "@omnia/fx/stores";
+import { ColorSchema, ColorSchemaType, ColorSchemaTypes } from "@omnia/fx-models";
+import { ThemeStoreV2 } from "./ThemeStoreV2";
+export declare class ColorSchemaStore extends Store {
+    private colorSchema;
+    private themeStore;
+    constructor();
+    onActivated(): void;
+    onDisposing(): void;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        colorSchema: () => ColorSchema;
+        color: (colorTypes: string) => any;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        colorSchema: import("@omnia/fx/stores").StoreMutation<(colorSchemaType: ColorSchemaTypes | ColorSchemaType) => void, (colorSchemaType: ColorSchemaTypes) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        themeStore: import("@omnia/fx/stores").StoreMutation<(themeStore: ThemeStoreV2) => void, (themeStore: ThemeStoreV2) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+}

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

@@ -1,5 +1,5 @@
 import { Store } from "@omnia/fx/stores";
-import { ThemeDefinitionV2 } from "../../shared/models";
+import { ColorSchemaType, ColorSchemaTypes, ColorType, ColorTypes, ThemeDefinitionV2, TypographyType, TypographyTypes } from "../../shared/models";
 export declare class ThemeStoreV2 extends Store {
     private currentTheme;
     constructor();
@@ -9,13 +9,13 @@ export declare class ThemeStoreV2 extends Store {
     * Implementation of getters
     */
     getters: {
-        colorSchema: (colorSchemaType: string) => import("@omnia/fx-models").ColorSchema;
-        typography: (typographyType: string) => import("@omnia/fx-models").TypographyType;
-        color: (colorSchemaType: string, colorType: string) => string;
-        colorDefinition: (colorSchemaType: string, colorType: string) => import("@omnia/fx-models").ColorDefinition;
-        complementaryColorType: (colorType: string) => string;
-        complementaryColor: (colorSchemaType: string, colorType: string) => string;
-        complementaryColorDefinition: (colorSchemaType: string, colorType: string) => import("@omnia/fx-models").ColorDefinition;
+        colorSchema: (colorSchemaType: ColorSchemaTypes | ColorSchemaType) => import("@omnia/fx-models").ColorSchema;
+        typography: (typographyType: TypographyTypes | TypographyType) => import("@omnia/fx-models").TypographyTypeDefinition;
+        color: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => string;
+        colorDefinition: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => import("@omnia/fx-models").ColorDefinition;
+        complementaryColorType: (colorType: ColorTypes | ColorType) => ColorTypes.base | ColorTypes.onBase | ColorTypes.container | ColorTypes.onContainer;
+        complementaryColor: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => string;
+        complementaryColorDefinition: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => import("@omnia/fx-models").ColorDefinition;
         currentTheme: () => ThemeDefinitionV2;
     };
     /**

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

@@ -2,3 +2,4 @@ export * from "./themes";
 export * from "./ColorManager";
 export * from "./ThemeStoreV2";
 export * from "./styling";
+export * from "./ColorSchemaStore";

package/internal-do-not-import-from-here/ux/theming-v2/styling/UseBlueprintStyling.d.ts

@@ -0,0 +1,8 @@
+import { ColorSchemaType, ColorSchemaTypes, ColorTypeResult } from "@omnia/fx-models";
+import { ThemeStoreV2 } from "../ThemeStoreV2";
+export declare const useButtonBlueprint: (injectedThemeStore?: ThemeStoreV2) => string;
+export declare const useIconBlueprint: (injectedThemeStore?: ThemeStoreV2) => string;
+export declare const useCardBlueprint: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, injectedThemeStore?: ThemeStoreV2, opacity?: number) => {
+    card: ColorTypeResult<string>;
+    cardImage: string;
+};

package/internal-do-not-import-from-here/ux/theming-v2/styling/UseComponentStyling.d.ts

@@ -0,0 +1,2 @@
+import { ColorSchema, ColorStyles, ColorTypeResult } from "@omnia/fx-models";
+export declare const useComponentStyling: (colorSchema: ColorSchema) => ColorTypeResult<ColorStyles>;

package/internal-do-not-import-from-here/ux/theming-v2/styling/UseThemeStyling.d.ts

@@ -0,0 +1,16 @@
+import { ColorSchema, ColorSchemaType, ColorSchemaTypes } from "@omnia/fx-models";
+import { ThemeStoreV2 } from "../ThemeStoreV2";
+export declare const useThemeStyling: (injectThemeStore?: ThemeStoreV2) => {
+    bluePrints: {
+        card: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, opacity?: number) => {
+            card: import("@omnia/fx-models").ColorTypeResult<string>;
+            cardImage: string;
+        };
+    };
+    component: (colorSchema: ColorSchemaTypes | ColorSchemaType | ColorSchema) => import("@omnia/fx-models").ColorTypeResult<import("@omnia/fx-models").ColorStyles>;
+    typography: () => import("./UseTypographyStyling").TypographyTypesResult;
+    vuetify: {
+        color: (colorSchema: ColorSchemaTypes | ColorSchemaType | ColorSchema) => import("@omnia/fx-models").ColorTypeResult<object>;
+        slider: (colorSchema: ColorSchemaTypes | ColorSchemaType | ColorSchema) => import("@omnia/fx-models").ColorTypeResult<object>;
+    };
+};

package/internal-do-not-import-from-here/ux/theming-v2/styling/UseTypographyStyling.d.ts

@@ -0,0 +1,25 @@
+import { TypographyTypes } from "@omnia/fx-models";
+import { MediaQuery } from "typestyle/lib/types";
+import { ThemeStoreV2 } from "../ThemeStoreV2";
+export interface TypographyTypesResult {
+    h1: string;
+    h2: string;
+    h3: string;
+    caption: string;
+    link: string;
+    text: string;
+    typographyType: (typographyType: string) => string;
+}
+export declare const useTypographyTypeStyling: (typographyType: TypographyTypes, injectedThemeStore?: ThemeStoreV2) => {
+    baseStyles: {
+        fontSize: string;
+        fontWeight: number;
+        lineHeight: string;
+        textDecoration: string;
+    };
+    mediumStyles: any;
+    smallStyles: any;
+    queryOnSmallScreen: MediaQuery;
+    queryOnMediumScreen: MediaQuery;
+};
+export declare const useTypographyStyling: (injectedThemeStore?: ThemeStoreV2) => TypographyTypesResult;

package/internal-do-not-import-from-here/ux/theming-v2/styling/UseVuetifyStyling.d.ts

@@ -0,0 +1,4 @@
+import { ColorSchema, ColorTypeResult } from "@omnia/fx-models";
+import { ThemeStoreV2 } from "../ThemeStoreV2";
+export declare const useVuetifyColorStyling: (colorSchema: ColorSchema) => ColorTypeResult<object>;
+export declare const useVuetifySliderStyling: (colorSchema: ColorSchema, injectThemeStore?: ThemeStoreV2) => ColorTypeResult<object>;

package/internal-do-not-import-from-here/ux/theming-v2/styling/index.d.ts

@@ -1 +1,5 @@
-export * from "./themeStyling";
+export * from "./UseBlueprintStyling";
+export * from "./UseComponentStyling";
+export * from "./UseThemeStyling";
+export * from "./UseTypographyStyling";
+export * from "./UseVuetifyStyling";

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

@@ -1,12 +1,12 @@
-import { Guid, ThemeDefinitionV2 } from "@omnia/fx-models";
+import { ColorSchemaTypes, ColorTypes, Guid, ThemeDefinitionV2 } from "@omnia/fx-models";
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
         $data: {};
         $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
             model: Guid;
-            colorSchemaType: string;
-            colorType: string;
+            colorSchemaType: ColorSchemaTypes;
+            colorType: ColorTypes;
             onChange: (theme: ThemeDefinitionV2) => void;
         }>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
         $attrs: {
@@ -24,8 +24,8 @@ declare const _default: {
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
             model: Guid;
-            colorSchemaType: string;
-            colorType: string;
+            colorSchemaType: ColorSchemaTypes;
+            colorType: ColorTypes;
             onChange: (theme: ThemeDefinitionV2) => void;
         }>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
             beforeCreate?: (() => void) | (() => void)[];
@@ -49,8 +49,8 @@ declare const _default: {
         $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;
-        colorSchemaType: string;
-        colorType: string;
+        colorSchemaType: ColorSchemaTypes;
+        colorType: ColorTypes;
         onChange: (theme: ThemeDefinitionV2) => void;
     }>>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
@@ -58,15 +58,15 @@ declare const _default: {
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
     model: Guid;
-    colorSchemaType: string;
-    colorType: string;
+    colorSchemaType: ColorSchemaTypes;
+    colorType: ColorTypes;
     onChange: (theme: ThemeDefinitionV2) => void;
 }>>>, () => 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;
-        colorSchemaType: string;
-        colorType: string;
-        onChange: (theme: ThemeDefinitionV2) => void;
-    }>>>;
+    propsDefinition: Readonly<{} & {
+        onChange?: (theme: ThemeDefinitionV2) => void;
+        colorSchemaType?: ColorSchemaTypes;
+        colorType?: ColorTypes;
+        model?: Guid;
+    }>;
 };
 export default _default;

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

@@ -56,9 +56,9 @@ declare const _default: {
     themeStoreRegistrationHook: RegisterThemeStore;
     onCloseThemingEditor: () => void;
 }>>>, () => 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<{
-        themeStoreRegistrationHook: RegisterThemeStore;
-        onCloseThemingEditor: () => void;
-    }>>>;
+    propsDefinition: Readonly<{} & {
+        themeStoreRegistrationHook?: RegisterThemeStore;
+        onCloseThemingEditor?: () => void;
+    }>;
 };
 export default _default;

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

@@ -1,2 +1,46 @@
-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<{}>>, {}>;
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & 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<{}>>, () => 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").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<{} & {}>;
+};
 export default _default;

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

@@ -1,2 +1,46 @@
-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<{}>>, {}>;
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & 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<{}>>, () => 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").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<{} & {}>;
+};
 export default _default;

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

@@ -1,2 +1,46 @@
-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<{}>>, {}>;
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & 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<{}>>, () => 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").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<{} & {}>;
+};
 export default _default;

package/internal-do-not-import-from-here/ux/theming-v2/themes/Themes.d.ts

@@ -18,6 +18,7 @@ export declare class ThemeDefinitionInstance implements ThemeDefinitionV2 {
     constructor(primary: string, secondary: string, accent1: string, accent2: string, accent3: string, neutral: string, background: string, info: string, error: string, typography: TypographyDefinition, blueprint: BlueprintDefinition, name: string, dark: boolean, id: Guid);
 }
 export declare const DarkKnightDefinition: () => ThemeDefinitionInstance;
+export declare const DarkEditorDefinition: () => ThemeDefinitionInstance;
 export declare const BlackDefinition: () => ThemeDefinitionInstance;
 export declare const BumbleBeeDefinition: () => ThemeDefinitionInstance;
 export declare const CyberPunkDefinition: () => ThemeDefinitionInstance;

package/internal-do-not-import-from-here/ux/theming-v2/themes/TypographyTypes.d.ts

@@ -1,12 +1,12 @@
-import { Guid, TypographyDefinition, TypographyType } from "@omnia/fx-models";
+import { Guid, TypographyDefinition, TypographyTypeDefinition } from "@omnia/fx-models";
 export declare class DefaultTypography implements TypographyDefinition {
     id: Guid;
-    h1: TypographyType;
-    h2: TypographyType;
-    h3: TypographyType;
-    summary: TypographyType;
-    text: TypographyType;
-    caption: TypographyType;
-    link: TypographyType;
+    h1: TypographyTypeDefinition;
+    h2: TypographyTypeDefinition;
+    h3: TypographyTypeDefinition;
+    summary: TypographyTypeDefinition;
+    text: TypographyTypeDefinition;
+    caption: TypographyTypeDefinition;
+    link: TypographyTypeDefinition;
     constructor();
 }

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

@@ -0,0 +1,10 @@
+import { ColorType, ColorTypes } from "@omnia/fx/models";
+import { ColorSchemaStore } from "../theming-v2";
+export declare const useComponentSetup: (props: object) => ColorSchemaStore[];
+export declare const useComponentColors: (props: object, colorSchemaStore: ColorSchemaStore, defaultBaseColor: ColorTypes | ColorType) => {
+    baseColor: any;
+    onBaseColor: import("@omnia/fx-models").ColorDefinition;
+    baseIsTonedColor: any;
+    baseColorType: any;
+    onBaseColorType: ColorTypes;
+};

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

@@ -0,0 +1,2 @@
+import { IIcon } from "@omnia/fx-models";
+export declare const useIconClass: (icon: IIcon) => any;

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

@@ -10,3 +10,5 @@ export * from "./UseEventHook";
 export * from "./UseClone";
 export * from "./UseKeyboard";
 export * from "./UseIndexedDb";
+export * from "./UseComponentSetup";
+export * from "./UseIcon";

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

@@ -68,11 +68,11 @@ declare const _default: {
 }>>>, () => 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;
-    }>>>;
+    propsDefinition: Readonly<{} & {
+        disabled?: boolean;
+        valueBind?: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>;
+        onValueBindChanged?: (value: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>) => void;
+        editMode?: boolean;
+    }>;
 };
 export default _default;

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

@@ -54,9 +54,9 @@ declare const _default: {
     valueBind: UserPropertyConfiguration;
     onValueBindChanged: (newValue: UserPropertyConfiguration) => void;
 }>>>, () => 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;
-    }>>>;
+    propsDefinition: Readonly<{} & {
+        valueBind?: UserPropertyConfiguration;
+        onValueBindChanged?: (newValue: UserPropertyConfiguration) => void;
+    }>;
 };
 export default _default;

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

@@ -1,4 +1,4 @@
-import { IPropertyProviderDisplayRenderer } from "@omnia/fx-models";
+import { IPropertyProviderDisplayRenderer, PropertyConfiguration } from "@omnia/fx-models";
 import { UserPropertiesByMicrosoftGraphDefinition } from "../UserPropertiesByMicrosoftGraphDefinition";
 declare const msgraphUserDisplayComponent: {
     new (...args: any[]): {
@@ -43,6 +43,10 @@ declare const msgraphUserDisplayComponent: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyProviderDisplayRenderer<UserPropertiesByMicrosoftGraphDefinition>>>>, {}, {}, {}, {}, 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<IPropertyProviderDisplayRenderer<UserPropertiesByMicrosoftGraphDefinition>>>>;
+    propsDefinition: Readonly<{} & {
+        configuration?: PropertyConfiguration<UserPropertiesByMicrosoftGraphDefinition>;
+        valueBind?: import("../UserPropertiesByMicrosoftGraphDefinition").MSGraphUserPropertyValue;
+        displaySettings?: import("../UserPropertiesByMicrosoftGraphDefinition").MSGraphUserPropertyDisplaySettings;
+    }>;
 };
 export default msgraphUserDisplayComponent;

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

@@ -1,5 +1,5 @@
-import { IPropertyProviderEditorRenderer } from "@omnia/fx-models";
-import { UserPropertiesByMicrosoftGraphDefinition } from "../UserPropertiesByMicrosoftGraphDefinition";
+import { IPropertyProviderEditorRenderer, PropertyConfiguration } from "@omnia/fx-models";
+import { UserPropertiesByMicrosoftGraphDefinition, MSGraphUserPropertyValue } from "../UserPropertiesByMicrosoftGraphDefinition";
 declare const msgraphUserEditorComponent: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
@@ -43,6 +43,13 @@ declare const msgraphUserEditorComponent: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyProviderEditorRenderer<UserPropertiesByMicrosoftGraphDefinition>>>>, {}, {}, {}, {}, 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<IPropertyProviderEditorRenderer<UserPropertiesByMicrosoftGraphDefinition>>>>;
+    propsDefinition: Readonly<{} & {
+        configuration?: PropertyConfiguration<UserPropertiesByMicrosoftGraphDefinition>;
+        disabled?: boolean;
+        valueBind?: MSGraphUserPropertyValue;
+        displaySettings?: import("../UserPropertiesByMicrosoftGraphDefinition").MSGraphUserPropertyDisplaySettings;
+        editorSettings?: import("../UserPropertiesByMicrosoftGraphDefinition").MSGraphUserEditorSettings;
+        onValueBindChanged?: (newValue: MSGraphUserPropertyValue) => void;
+    }>;
 };
 export default msgraphUserEditorComponent;

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

@@ -1,4 +1,4 @@
-import { IPropertyProviderDisplayRenderer } from "@omnia/fx-models";
+import { IPropertyProviderDisplayRenderer, PropertyConfiguration } from "@omnia/fx-models";
 import { UserPropertyProviderDefinition } from "../UserPropertyProviderDefinition";
 declare const _default: {
     new (...args: any[]): {
@@ -43,6 +43,10 @@ declare const _default: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyProviderDisplayRenderer<UserPropertyProviderDefinition>>>>, {}, {}, {}, {}, 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<IPropertyProviderDisplayRenderer<UserPropertyProviderDefinition>>>>;
+    propsDefinition: Readonly<{} & {
+        configuration?: PropertyConfiguration<UserPropertyProviderDefinition>;
+        valueBind?: import("../UserPropertyProviderDefinition").BuiltinUserPropertyValue;
+        displaySettings?: import("../UserPropertyProviderDefinition").UserPropertyProviderDefinitionDisplaySettings;
+    }>;
 };
 export default _default;

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

@@ -1,4 +1,4 @@
-import { IPropertyProviderEditorRenderer } from "@omnia/fx-models";
+import { IPropertyProviderEditorRenderer, PropertyConfiguration } from "@omnia/fx-models";
 import { UserPropertyProviderDefinition } from "../UserPropertyProviderDefinition";
 declare const _default: {
     new (...args: any[]): {
@@ -43,6 +43,13 @@ declare const _default: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<IPropertyProviderEditorRenderer<UserPropertyProviderDefinition>>>>, {}, {}, {}, {}, 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<IPropertyProviderEditorRenderer<UserPropertyProviderDefinition>>>>;
+    propsDefinition: Readonly<{} & {
+        configuration?: PropertyConfiguration<UserPropertyProviderDefinition>;
+        disabled?: boolean;
+        valueBind?: import("../UserPropertyProviderDefinition").BuiltinUserPropertyValue;
+        displaySettings?: import("../UserPropertyProviderDefinition").UserPropertyProviderDefinitionDisplaySettings;
+        editorSettings?: import("../UserPropertyProviderDefinition").UserPropertyProviderDefinitionEditorSettings;
+        onValueBindChanged?: (newValue: import("../UserPropertyProviderDefinition").BuiltinUserPropertyValue) => void;
+    }>;
 };
 export default _default;

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

@@ -70,13 +70,13 @@ declare const _default: {
         container?: import("@omnia/fx-models").NestedCSSPropertiesExtends;
     };
 }>>>, () => 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: UserIdentity;
-        offsetX: number;
-        offsetY: number;
-        styles: {
+    propsDefinition: Readonly<{} & {
+        valueBind?: UserIdentity;
+        styles?: {
             container?: import("@omnia/fx-models").NestedCSSPropertiesExtends;
         };
-    }>>>;
+        offsetX?: number;
+        offsetY?: number;
+    }>;
 };
 export default _default;

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

@@ -50,8 +50,8 @@ declare const _default: {
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
     userTypeId: GuidValue;
 }>>>, () => 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<{
-        userTypeId: GuidValue;
-    }>>>;
+    propsDefinition: Readonly<{} & {
+        userTypeId?: GuidValue;
+    }>;
 };
 export default _default;