@omnia/fx 8.0.102-vnext → 8.0.103-vnext

package/internal-do-not-import-from-here/core/messaging/InternalTopics.d.ts

@@ -28,6 +28,9 @@ export declare class InternalTopics {
         instance: any;
         object: any;
     }>;
+    static get requestedLoadManifestByElement(): IMessageBusTopicPublishSubscriber<{
+        elementName: string;
+    }>;
     static get vueOnDestroyed(): IMessageBusTopicPublishSubscriber<{
         instance: ComponentInternalInstance;
     }>;

package/internal-do-not-import-from-here/core/services/ServiceManifestProviderInternal.d.ts

@@ -1,10 +1,10 @@
-import { OmniaManifests, WebComponentBundleManifest } from "../../models";
+import { OmniaManifests, ComponentBundleManifest } from "../../models";
 export declare class ServiceManifestProviderInternal {
     private static _omniaManifests;
     private static _wcManifests;
     static init(): Promise<void>;
     static getAllOmniaManifests(): OmniaManifests[];
     static getAllWebComponentsManifests(): {
-        [manifestId: string]: WebComponentBundleManifest;
+        [manifestId: string]: ComponentBundleManifest;
     };
 }

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

@@ -1,7 +1,7 @@
 export * from "./expose";
 import * as Exposes from "./expose";
 import * as Models from "internal/fx/models";
-import { IExtend, ThemeDefinitionV2, WebComponentBundleManifest } from "./models";
+import { IExtend, ThemeDefinitionV2, ComponentBundleManifest } from "./models";
 interface IExtendApi {
     extendApi: <T>(targetApi: (extend: IExtend) => Promise<T>, callback?: (api: T) => void | Promise<void>) => void;
 }
@@ -16,15 +16,15 @@ declare global {
 export interface IWebComponentInstance {
 }
 export interface IWebComponentRegistrationHandler {
-    (webComponentManifest: WebComponentBundleManifest): void;
+    (webComponentManifest: ComponentBundleManifest): void;
 }
 export interface IConnectedWebComponent {
     setRegistrationHandler: (registrationHandler: IWebComponentRegistrationHandler) => void;
     addElementInstanceHandler: (instanceHandler: IWebComponentInstance, htmlElement: HTMLElement) => IWebComponentInstanceContext;
-    getManifest: () => WebComponentBundleManifest;
+    getManifest: () => ComponentBundleManifest;
 }
 export interface IWebComponentInstanceContext {
-    getManifest: () => WebComponentBundleManifest;
+    getManifest: () => ComponentBundleManifest;
 }
 export declare class WebComponentBootstrapper {
     static registerElement: (registrationHandler: IWebComponentRegistrationHandler) => void;
@@ -117,7 +117,7 @@ export declare function setCurrentManifest(omniaServiceId: any, resourceId: any)
     getVueApps(): Set<import("vue").App<Element>>;
     destroyVueApp(app: import("vue").App<Element>): void;
     createVueApp(rootComponent: any, rootProps?: any): import("vue").App<Element>;
-    registerAsyncVueComponent(app: import("vue").App<any>, component: Models.WebComponentBundleManifest): void;
+    registerAsyncVueComponent(app: import("vue").App<any>, component: Models.ComponentBundleManifest): void;
     resolveAsyncVueComponent(elementName: string, definition: import("vue").DefineComponent): void;
     vueCustomElement(tag: string, componentDefinition: Object | Exposes.ComponentDefinitionFunc, options?: Exposes.VueCustomElementOptions): HTMLElement;
     DisplayRules: typeof Exposes.DisplayRules;

package/internal-do-not-import-from-here/runtime/core/InternalWebComponentBootstrapper.d.ts

@@ -1,16 +1,16 @@
-import { GuidValue, WebComponentBundleManifest } from "../../models";
+import { GuidValue, ComponentBundleManifest } from "../../models";
 export interface IWebComponentInstance {
 }
 export interface IWebComponentRegistrationHandler {
-    (webComponentManifest: WebComponentBundleManifest): void;
+    (webComponentManifest: ComponentBundleManifest): void;
 }
 export interface IConnectedWebComponent {
     setRegistrationHandler: (registrationHandler: IWebComponentRegistrationHandler) => void;
     addElementInstanceHandler: (instanceHandler: IWebComponentInstance, htmlElement: HTMLElement) => IWebComponentInstanceContext;
-    getManifest: () => WebComponentBundleManifest;
+    getManifest: () => ComponentBundleManifest;
 }
 export interface IWebComponentInstanceContext {
-    getManifest: () => WebComponentBundleManifest;
+    getManifest: () => ComponentBundleManifest;
 }
 export declare class InternalWebComponentBootstrapper {
     static registerElement: (omniaServiceId: GuidValue, manifestId: GuidValue, registrationHandler: IWebComponentRegistrationHandler) => void;

package/internal-do-not-import-from-here/runtime/core/ManifestByElementLoader.d.ts

@@ -6,6 +6,7 @@ export declare class ManifestByElementLoader {
     private static ElementNameToManifestMap;
     private static StoredAddMutations;
     private static StoredMutationsLimit;
+    private static requestedLoadManifestMatchingElement;
     private Subscriber;
     private constructor();
     static manifestSubscriber: () => IManifestSubscriber;

package/internal-do-not-import-from-here/runtime/core/PrivateWebComponentBootstrapper.d.ts

@@ -1,23 +1,23 @@
 import { IWebComponentInstanceContext, IConnectedWebComponent, IWebComponentRegistrationHandler, IWebComponentInstance } from "./InternalWebComponentBootstrapper";
-import { WebComponentBundleManifest } from "../../models";
+import { ComponentBundleManifest } from "../../models";
 export declare class WebComponentInstanceContext implements IWebComponentInstanceContext {
     private instance;
-    getManifest: () => WebComponentBundleManifest;
-    constructor(instance: IWebComponentInstance, getManifest: () => WebComponentBundleManifest);
+    getManifest: () => ComponentBundleManifest;
+    constructor(instance: IWebComponentInstance, getManifest: () => ComponentBundleManifest);
 }
 export declare class ConnectedWebComponent implements IConnectedWebComponent {
     private webComponentManifest;
     private registrationHandler;
     instanceContexts: Array<WebComponentInstanceContext>;
-    constructor(webComponentManifest: WebComponentBundleManifest);
+    constructor(webComponentManifest: ComponentBundleManifest);
     hasElementRegistrationHandler: () => boolean;
-    getManifest: () => WebComponentBundleManifest;
+    getManifest: () => ComponentBundleManifest;
     setRegistrationHandler: (registrationHandler: IWebComponentRegistrationHandler) => void;
     executeElementRegistration: () => void;
     addElementInstanceHandler: (instanceHandler: IWebComponentInstance, htmlElement: HTMLElement) => IWebComponentInstanceContext;
 }
 export declare class PrivateBootstrapper {
     private static ProxyHolder;
-    static newWebComponentProxy: (webComponentManifest: WebComponentBundleManifest) => ConnectedWebComponent;
-    static getWebComponentProxy: (webComponentManifest: WebComponentBundleManifest) => ConnectedWebComponent;
+    static newWebComponentProxy: (webComponentManifest: ComponentBundleManifest) => ConnectedWebComponent;
+    static getWebComponentProxy: (webComponentManifest: ComponentBundleManifest) => ConnectedWebComponent;
 }

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

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

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

@@ -1,7 +1,7 @@
 import { SubscriptionHandler } from "@omnia/fx";
 import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentPropsOptions, DefineComponent, ComponentObjectPropsOptions, Prop, PropType, ObjectEmitsOptions, CreateComponentPublicInstance, ExtractPropTypes, ExtractDefaultPropTypes, ComponentOptionsBase, RenderFunction, watchEffect, SlotsType, ComponentOptions, Slot, watch } from "vue";
 import { LooseRequired, UnionToIntersection, Prettify } from "@vue/shared";
-import { ThemeableComponentProps, WebComponentBundleManifest } from "@omnia/fx-models";
+import { ThemeableComponentProps, ComponentBundleManifest } from "@omnia/fx-models";
 import { useColorSchemaSetup, useBlueprintSetup } from "./use";
 import { IValidatorBase } from "./models/Validation";
 export declare function definePropFunctionType<T>(): PropType<T>;
@@ -113,6 +113,25 @@ type SetupContext<Props, E = EmitsOptions> = E extends any ? {
 interface ComponentOptionsBaseExtends<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string> extends ComponentOptionsBase<ExcludeJsxPropKeys<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> {
     setup?: (this: void, props: LooseRequired<ExcludeJsxPropKeys<Props> & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, "P">>>, ctx: SetupContext<Props, E>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
 }
+export declare function defineVueComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
+    props?: (keyof Props)[];
+    emits?: E | EE[];
+    slots?: S;
+}, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>) => void): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
+export declare function defineVueComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
+    props?: ComponentObjectPropsOptions<Props>;
+    emits?: E | EE[];
+    slots?: S;
+}, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>) => void): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
+export declare function defineVueComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function defineVueComponent<Props extends Object, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<ComponentObjectPropsOptions<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<RemoveDefinePropApi<ComponentObjectPropsOptions<Props>>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function defineVueComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<Readonly<{
+    [key in PropNames]?: any;
+}>, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<Readonly<{
+    [key in PropNames]?: any;
+}>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function defineVueComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: ComponentBundleManifest, component: TsxComponentV3<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<RemoveDefinePropApi<PropsOptions>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
+export declare function internalDefineVueWebComponent(omniaServiceId: any, manifestId: any, options: any, extraOptions?: any, register?: (manifest: ComponentBundleManifest, component: any) => void): any;
 export declare function createPropType<T>(): PropType<T>;
 export declare function defineVue(): {
     slots<Slots_1>(): {
@@ -226,41 +245,6 @@ export declare function defineVue(): {
         };
     };
 };
-export declare function defineVueComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
-    props?: (keyof Props)[];
-    emits?: E | EE[];
-    slots?: S;
-}): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
-export declare function defineVueComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
-    props?: ComponentObjectPropsOptions<Props>;
-    emits?: E | EE[];
-    slots?: S;
-}): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
-export declare function defineVueComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function defineVueComponent<Props extends Object, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<ComponentObjectPropsOptions<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<RemoveDefinePropApi<ComponentObjectPropsOptions<Props>>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function defineVueComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<Readonly<{
-    [key in PropNames]?: any;
-}>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function defineVueComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<RemoveDefinePropApi<PropsOptions>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function defineVueWebComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
-    props?: (keyof Props)[];
-    emits?: E | EE[];
-    slots?: S;
-}, register?: (manifest: WebComponentBundleManifest, component: TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>) => void): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
-export declare function defineVueWebComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, "name" | "inheritAttrs"> & {
-    props?: ComponentObjectPropsOptions<Props>;
-    emits?: E | EE[];
-    slots?: S;
-}, register?: (manifest: WebComponentBundleManifest, component: TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>) => void): TsxComponentV3<Props, {}, {}, {}, {}, {}, {}, E, EE>;
-export declare function defineVueWebComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: WebComponentBundleManifest, component: TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function defineVueWebComponent<Props extends Object, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<ComponentObjectPropsOptions<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: WebComponentBundleManifest, component: TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<RemoveDefinePropApi<ComponentObjectPropsOptions<Props>>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function defineVueWebComponent<PropNames extends string, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithArrayProps<PropNames, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: WebComponentBundleManifest, component: TsxComponentV3<Readonly<{
-    [key in PropNames]?: any;
-}>, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<Readonly<{
-    [key in PropNames]?: any;
-}>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function defineVueWebComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>, register?: (manifest: WebComponentBundleManifest, component: TsxComponentV3<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE>) => void): TsxComponentV3<RemoveDefinePropApi<PropsOptions>, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare function internalDefineVueWebComponent(omniaServiceId: any, manifestId: any, options: any, extraOptions?: any, register?: (manifest: WebComponentBundleManifest, component: any) => void): any;
 declare global {
     namespace JSX {
         interface IntrinsicAttributes {

package/internal-do-not-import-from-here/ux/imagetransformer/Components/ImageTransformEditor/ImageTransformEditor.css.d.ts

@@ -0,0 +1,7 @@
+import { ColorDefinition } from "@omnia/fx-models";
+export declare const ImageTransformEditorStyles: {
+    imageMenuWrapper: (color: ColorDefinition) => string;
+    rotateIcon90: string;
+    menyDrawerExpanded: string;
+    menyDrawer: (dark: boolean) => string;
+};

package/internal-do-not-import-from-here/ux/imagetransformer/Components/ImageTransformEditor/ImageTransformEditor.d.ts

@@ -1,4 +1,5 @@
 import { MediaPickerCropTransformation, MediaPickerImageRatioDefinition, MediaPickerTransformedBase64Image, MediaPickerBase64Image, ImageTransformerEditorOptions } from "../../../../models";
+import { nextTick } from "vue";
 export interface ImageTransformEditorProps {
     sourceImage: MediaPickerBase64Image;
     containerId: string;
@@ -64,6 +65,7 @@ declare const _default: {
             }>) => void)[];
             readonly sourceImage?: MediaPickerBase64Image;
             readonly containerId?: string;
+            readonly selectableRatios?: MediaPickerImageRatioDefinition[];
             readonly shareableRenditions?: MediaPickerCropTransformation[];
             readonly selectedRenditionId?: {
                 value: number;
@@ -71,7 +73,6 @@ declare const _default: {
             readonly isShowWarningDialog?: {
                 value: boolean;
             };
-            readonly selectableRatios?: MediaPickerImageRatioDefinition[];
             readonly "source-image"?: MediaPickerBase64Image;
             readonly "container-id"?: string;
             readonly "selectable-ratios"?: MediaPickerImageRatioDefinition[];
@@ -169,7 +170,7 @@ declare const _default: {
             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;
+        $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<{
         options: {
@@ -286,6 +287,7 @@ declare const _default: {
         options?: ImageTransformerEditorOptions;
         sourceImage?: MediaPickerBase64Image;
         containerId?: string;
+        selectableRatios?: MediaPickerImageRatioDefinition[];
         shareableRenditions?: MediaPickerCropTransformation[];
         selectedRenditionId?: {
             value: number;
@@ -293,7 +295,6 @@ declare const _default: {
         isShowWarningDialog?: {
             value: boolean;
         };
-        selectableRatios?: MediaPickerImageRatioDefinition[];
         "source-image"?: MediaPickerBase64Image;
         "container-id"?: string;
         "selectable-ratios"?: MediaPickerImageRatioDefinition[];

package/internal-do-not-import-from-here/ux/imagetransformer/Components/ImageTransformEditor/ImageTransformEditor_old.d.ts

@@ -1,66 +0,0 @@
-import { IWebComponentInstance } from "../../../..";
-import { OmniaTheming, VueComponentBase, ConfirmDialogResponse } from "../../..";
-import { MediaPickerEnums, MediaPickerCropTransformation, MediaPickerTransformation, MediaPickerImageRatioDefinition, MediaPickerTransformedBase64Image, MediaPickerBase64Image, ImageTransformerEditorOptions } from "../../../../models";
-import { ImageTransformerLocalization } from "../../loc/localize";
-import { ImageEditorMenu } from "../../../imagetransformation/enums";
-import { MediaPickerService } from "../../../../services";
-export interface ImageTransformEditorProps {
-    sourceImage: MediaPickerBase64Image;
-    containerId: string;
-    selectableRatios?: Array<MediaPickerImageRatioDefinition>;
-    transformationChanged: (originalBase64: MediaPickerBase64Image, transformation: MediaPickerTransformedBase64Image) => void;
-    shareableRenditions?: Array<MediaPickerCropTransformation>;
-    selectedRenditionId?: {
-        value: number;
-    };
-    isShowWarningDialog?: {
-        value: boolean;
-    };
-    options?: ImageTransformerEditorOptions;
-}
-export declare class ImageTransformEditor extends VueComponentBase<ImageTransformEditorProps> implements IWebComponentInstance, ImageTransformEditorProps {
-    sourceImage: MediaPickerBase64Image;
-    containerId: string;
-    selectableRatios?: Array<MediaPickerImageRatioDefinition>;
-    transformationChanged: (originalBase64: MediaPickerBase64Image, transformation: MediaPickerTransformedBase64Image) => void;
-    shareableRenditions: Array<MediaPickerCropTransformation>;
-    selectedRenditionId: {
-        value: number;
-    };
-    isShowWarningDialog: {
-        value: boolean;
-    };
-    options: ImageTransformerEditorOptions;
-    omniaTheming: OmniaTheming;
-    mediaPickerService: MediaPickerService;
-    loc: ImageTransformerLocalization.locInterface;
-    private transformedImage;
-    private transformedImageInformation;
-    private editorInstance;
-    private maxImageHeight;
-    private maxImageWidth;
-    private menu;
-    private cropButton;
-    private flipButton;
-    private filterButton;
-    private isHiddenMenu;
-    private editorId;
-    private imageEditorMenuClassname;
-    private imageEditorMenuOptionClassname;
-    private isLoadingAndTransforming;
-    created(): void;
-    mounted(): void;
-    beforeDestroy(): void;
-    private init;
-    private transformUsingTuiEditor;
-    private onImageTransformationDataChanged;
-    resizeCanvasDimension(forceDefault?: boolean): Promise<void>;
-    resetStyle(res: ConfirmDialogResponse): void;
-    getConfig(data: Array<MediaPickerTransformation>, type: MediaPickerEnums.MediaPickerTransformationTypes): MediaPickerTransformation;
-    getUiOption(): void;
-    openMenu(menu: ImageEditorMenu, res?: ConfirmDialogResponse): void;
-    toogleCurrentButton(currentMenu: ImageEditorMenu): void;
-    renderMenu(): JSX.Element;
-    renderMenuOptions(): JSX.Element;
-    render(): JSX.Element;
-}

package/internal-do-not-import-from-here/ux/imagetransformer/Components/ImageTransformFilter/ImageTransformFilter.d.ts

@@ -1,23 +1,136 @@
-import { IWebComponentInstance } from "../../../..";
 import "../../ImageTransformer.css";
-import { OmniaTheming, VueComponentBase } from "../../..";
-import { ImageTransformerLocalization } from "../../loc/localize";
 import { MediaPickerFilterTransformation, MediaPickerTransformation } from "../../../../models";
 export interface ImageTransformFilterProps {
     imageTransformationData?: Array<MediaPickerTransformation>;
     changedImageConfigurationCallback?: (imageFilterTransformationData: MediaPickerFilterTransformation) => void;
 }
-export declare class ImageTransformFilter extends VueComponentBase<ImageTransformFilterProps> implements IWebComponentInstance {
-    imageTransformationData?: Array<MediaPickerTransformation>;
-    changedImageConfigurationCallback?: (imageFilterTransformationData: MediaPickerFilterTransformation) => void;
-    omniaTheming: OmniaTheming;
-    loc: ImageTransformerLocalization.locInterface;
-    private currentFilterTransformationData;
-    private isLoading;
-    private imageWithoutFilterTransformationData;
-    created(): void;
-    mounted(): void;
-    private init;
-    private onFilterTransformationChanged;
-    render(): JSX.Element;
-}
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            readonly imageTransformationData?: MediaPickerTransformation[];
+            readonly "image-transformation-data"?: MediaPickerTransformation[];
+            onChangedImageConfiguration?: (imageFilterTransformationData: MediaPickerFilterTransformation) => any;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any>;
+        }>;
+        $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: "changedImageConfiguration", imageFilterTransformationData: MediaPickerFilterTransformation) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            "image-transformation-data": {
+                type: import("vue").PropType<MediaPickerTransformation[]>;
+            };
+            imageTransformationData: {
+                type: import("vue").PropType<MediaPickerTransformation[]>;
+            };
+        }>> & {
+            onChangedImageConfiguration?: (imageFilterTransformationData: MediaPickerFilterTransformation) => any;
+        }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            changedImageConfiguration: (imageFilterTransformationData: MediaPickerFilterTransformation) => true;
+        }, 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<{
+        "image-transformation-data": {
+            type: import("vue").PropType<MediaPickerTransformation[]>;
+        };
+        imageTransformationData: {
+            type: import("vue").PropType<MediaPickerTransformation[]>;
+        };
+    }>> & {
+        onChangedImageConfiguration?: (imageFilterTransformationData: MediaPickerFilterTransformation) => any;
+    } & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    "image-transformation-data": {
+        type: import("vue").PropType<MediaPickerTransformation[]>;
+    };
+    imageTransformationData: {
+        type: import("vue").PropType<MediaPickerTransformation[]>;
+    };
+}>> & {
+    onChangedImageConfiguration?: (imageFilterTransformationData: MediaPickerFilterTransformation) => any;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    changedImageConfiguration: (imageFilterTransformationData: MediaPickerFilterTransformation) => true;
+}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        imageTransformationData?: MediaPickerTransformation[];
+        "image-transformation-data"?: MediaPickerTransformation[];
+    }>, "onChangedImageConfiguration"> & {
+        onChangedImageConfiguration?: (imageFilterTransformationData: MediaPickerFilterTransformation) => any;
+    };
+};
+export default _default;

package/internal-do-not-import-from-here/ux/imagetransformer/Components/ImageTransformFilter/ImageTransformFilter_old.d.ts

@@ -0,0 +1,23 @@
+import { IWebComponentInstance } from "../../../..";
+import "../../ImageTransformer.css";
+import { OmniaTheming, VueComponentBase } from "../../..";
+import { ImageTransformerLocalization } from "../../loc/localize";
+import { MediaPickerFilterTransformation, MediaPickerTransformation } from "../../../../models";
+export interface ImageTransformFilterProps {
+    imageTransformationData?: Array<MediaPickerTransformation>;
+    changedImageConfigurationCallback?: (imageFilterTransformationData: MediaPickerFilterTransformation) => void;
+}
+export declare class ImageTransformFilter extends VueComponentBase<ImageTransformFilterProps> implements IWebComponentInstance {
+    imageTransformationData?: Array<MediaPickerTransformation>;
+    changedImageConfigurationCallback?: (imageFilterTransformationData: MediaPickerFilterTransformation) => void;
+    omniaTheming: OmniaTheming;
+    loc: ImageTransformerLocalization.locInterface;
+    private currentFilterTransformationData;
+    private isLoading;
+    private imageWithoutFilterTransformationData;
+    created(): void;
+    mounted(): void;
+    private init;
+    private onFilterTransformationChanged;
+    render(): JSX.Element;
+}

package/internal-do-not-import-from-here/ux/imagetransformer/ImageTransformer.css.d.ts

@@ -2,4 +2,4 @@ import { OmniaTheming } from "..";
 export declare const MediaStyles: {
     hideDisplayWrapper: string;
 };
-export declare const transformer: (theme: OmniaTheming) => string;
+export declare function transformer(theme: OmniaTheming): string;

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

@@ -52,11 +52,11 @@ declare const _default: {
             }>) => void)[];
             readonly sourceImage?: MediaPickerBase64Image | MediaPickerTransformedBase64Image;
             onChanged?: (currentTransformationResult: MediaPickerImageTransformationResult) => any;
-            readonly rollupRatios?: MediaPickerRollupImageRatio[];
             readonly selectableRatios?: MediaPickerImageRatioDefinition[];
             readonly "source-image"?: MediaPickerBase64Image | MediaPickerTransformedBase64Image;
             readonly "selectable-ratios"?: MediaPickerImageRatioDefinition[];
             readonly renditions?: MediaPickerRenditionData[];
+            readonly rollupRatios?: MediaPickerRollupImageRatio[];
             readonly "rollup-ratios"?: MediaPickerRollupImageRatio[];
         };
         $attrs: {
@@ -197,11 +197,11 @@ declare const _default: {
     propsDefinition: Omit<Readonly<{} & {
         options?: ImageTransformerOptions;
         sourceImage?: MediaPickerBase64Image | MediaPickerTransformedBase64Image;
-        rollupRatios?: MediaPickerRollupImageRatio[];
         selectableRatios?: MediaPickerImageRatioDefinition[];
         "source-image"?: MediaPickerBase64Image | MediaPickerTransformedBase64Image;
         "selectable-ratios"?: MediaPickerImageRatioDefinition[];
         renditions?: MediaPickerRenditionData[];
+        rollupRatios?: MediaPickerRollupImageRatio[];
         "rollup-ratios"?: MediaPickerRollupImageRatio[];
     }>, "onChanged"> & {
         onChanged?: (currentTransformationResult: MediaPickerImageTransformationResult) => any;

package/internal-do-not-import-from-here/ux/layoutcanvas/editor/LayoutEditorCanvas.d.ts

@@ -86,7 +86,7 @@ declare const _default: {
                     drawerPanel: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     developerDialog: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     drawerToolbar: import("@omnia/fx-models").NestedCSSPropertiesExtends;
-                    drawerToolbarWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
+                    drawerToolbarWrapper: (dark: boolean) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     settingsWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     closeButton: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     rightResizer: (backgroundColor: string) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
@@ -103,7 +103,7 @@ declare const _default: {
                     drawerPanel: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     developerDialog: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     drawerToolbar: import("@omnia/fx-models").NestedCSSPropertiesExtends;
-                    drawerToolbarWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
+                    drawerToolbarWrapper: (dark: boolean) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     settingsWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     closeButton: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                     rightResizer: (backgroundColor: string) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
@@ -153,7 +153,7 @@ declare const _default: {
                 drawerPanel: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 developerDialog: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 drawerToolbar: import("@omnia/fx-models").NestedCSSPropertiesExtends;
-                drawerToolbarWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
+                drawerToolbarWrapper: (dark: boolean) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 settingsWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 closeButton: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 rightResizer: (backgroundColor: string) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
@@ -170,7 +170,7 @@ declare const _default: {
                 drawerPanel: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 developerDialog: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 drawerToolbar: import("@omnia/fx-models").NestedCSSPropertiesExtends;
-                drawerToolbarWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
+                drawerToolbarWrapper: (dark: boolean) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 settingsWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 closeButton: import("@omnia/fx-models").NestedCSSPropertiesExtends;
                 rightResizer: (backgroundColor: string) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
@@ -204,7 +204,7 @@ declare const _default: {
             drawerPanel: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             developerDialog: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             drawerToolbar: import("@omnia/fx-models").NestedCSSPropertiesExtends;
-            drawerToolbarWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
+            drawerToolbarWrapper: (dark: boolean) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
             settingsWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             closeButton: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             rightResizer: (backgroundColor: string) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
@@ -221,7 +221,7 @@ declare const _default: {
             drawerPanel: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             developerDialog: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             drawerToolbar: import("@omnia/fx-models").NestedCSSPropertiesExtends;
-            drawerToolbarWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
+            drawerToolbarWrapper: (dark: boolean) => import("@omnia/fx-models").NestedCSSPropertiesExtends;
             settingsWrapper: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             closeButton: import("@omnia/fx-models").NestedCSSPropertiesExtends;
             rightResizer: (backgroundColor: string) => import("@omnia/fx-models").NestedCSSPropertiesExtends;

package/internal-do-not-import-from-here/ux/mediapicker/components/ImageEditor.css.d.ts

@@ -4,6 +4,7 @@ export declare const ImageEditorStyles: {
     imageRendition: string;
     renditionTypesWrapper: string;
     imageMenuWrapper: (dark: boolean) => string;
+    settingsWrapper: (dark: boolean) => string;
     renditionTypes: {
         common: (color: ColorDefinition, selected: boolean) => string;
         landscape: string;

package/internal-do-not-import-from-here/ux/oxide/list/List.css.d.ts

@@ -1,4 +1,4 @@
 import { ListTypes } from "@omnia/fx-models";
 export declare const listStyles: {
-    wrapper: (listType: ListTypes, dark: any) => string;
+    wrapper: (listType: ListTypes, dark: any, divider: boolean) => string;
 };

package/internal-do-not-import-from-here/ux/oxide/list/List.d.ts

@@ -55,6 +55,7 @@ declare const _default: {
             }>) => void)[];
             readonly variant?: "navigation" | "default" | "options";
             readonly lines?: false | "one" | "two" | "three";
+            readonly divider?: boolean;
             readonly toned?: boolean;
         };
         $attrs: {
@@ -74,6 +75,9 @@ declare const _default: {
             variant: {
                 type: import("vue").PropType<"navigation" | "default" | "options">;
             };
+            divider: {
+                type: import("vue").PropType<boolean>;
+            };
             toned: {
                 type: import("vue").PropType<boolean>;
             } & {
@@ -124,6 +128,9 @@ declare const _default: {
         variant: {
             type: import("vue").PropType<"navigation" | "default" | "options">;
         };
+        divider: {
+            type: import("vue").PropType<boolean>;
+        };
         toned: {
             type: import("vue").PropType<boolean>;
         } & {
@@ -152,6 +159,9 @@ declare const _default: {
     variant: {
         type: import("vue").PropType<"navigation" | "default" | "options">;
     };
+    divider: {
+        type: import("vue").PropType<boolean>;
+    };
     toned: {
         type: import("vue").PropType<boolean>;
     } & {
@@ -190,6 +200,7 @@ declare const _default: {
         class?: String | String[];
         variant?: "navigation" | "default" | "options";
         lines?: false | "one" | "two" | "three";
+        divider?: boolean;
         toned?: boolean;
     }>, never>;
 };

package/internal-do-not-import-from-here/ux/oxide/toolbar/Toolbar.css.d.ts

@@ -1,6 +1,9 @@
+import { ToolbarVariants } from "@omnia/fx-models";
 export declare const ToolbarStyles: {
-    templateTitle: string;
+    templateTitle: (variant: ToolbarVariants) => string;
     templateTitleCustom: string;
     content: string;
+    drawer: string;
     iconWrapper: (color: string) => string;
+    divider: (dark: boolean) => string;
 };

package/internal-do-not-import-from-here/ux/oxide/toolbar/Toolbar.d.ts

@@ -63,7 +63,8 @@ declare const _default: {
                 title?: Func<[VNodeChild]>;
                 customButtons?: Func<[VNodeChild]>;
             };
-            readonly variant?: "default" | "menu" | "blade";
+            readonly variant?: "default" | "menu" | "drawer" | "blade";
+            readonly divider?: boolean;
             readonly toned?: boolean;
             readonly subTitle?: string;
             "onClick:close"?: () => any;
@@ -99,6 +100,9 @@ declare const _default: {
             closeButton: {
                 type: import("vue").PropType<boolean>;
             };
+            divider: {
+                type: import("vue").PropType<boolean>;
+            };
             icon: {
                 type: import("vue").PropType<IIcon>;
             };
@@ -109,7 +113,7 @@ declare const _default: {
                 type: import("vue").PropType<string>;
             };
             variant: {
-                type: import("vue").PropType<"default" | "menu" | "blade">;
+                type: import("vue").PropType<"default" | "menu" | "drawer" | "blade">;
             };
             class: {
                 type: import("vue").PropType<String | String[]>;
@@ -168,6 +172,9 @@ declare const _default: {
         closeButton: {
             type: import("vue").PropType<boolean>;
         };
+        divider: {
+            type: import("vue").PropType<boolean>;
+        };
         icon: {
             type: import("vue").PropType<IIcon>;
         };
@@ -178,7 +185,7 @@ declare const _default: {
             type: import("vue").PropType<string>;
         };
         variant: {
-            type: import("vue").PropType<"default" | "menu" | "blade">;
+            type: import("vue").PropType<"default" | "menu" | "drawer" | "blade">;
         };
         class: {
             type: import("vue").PropType<String | String[]>;
@@ -212,6 +219,9 @@ declare const _default: {
     closeButton: {
         type: import("vue").PropType<boolean>;
     };
+    divider: {
+        type: import("vue").PropType<boolean>;
+    };
     icon: {
         type: import("vue").PropType<IIcon>;
     };
@@ -222,7 +232,7 @@ declare const _default: {
         type: import("vue").PropType<string>;
     };
     variant: {
-        type: import("vue").PropType<"default" | "menu" | "blade">;
+        type: import("vue").PropType<"default" | "menu" | "drawer" | "blade">;
     };
     class: {
         type: import("vue").PropType<String | String[]>;
@@ -263,7 +273,8 @@ declare const _default: {
             title?: Func<[VNodeChild]>;
             customButtons?: Func<[VNodeChild]>;
         };
-        variant?: "default" | "menu" | "blade";
+        variant?: "default" | "menu" | "drawer" | "blade";
+        divider?: boolean;
         toned?: boolean;
         subTitle?: string;
         backButton?: boolean;

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

@@ -9,10 +9,12 @@ export declare function useIcons(): {
     customIcon: (name: string) => CustomIcon;
     icon: {
         add: FontAwesomeIcon;
+        adjust: FontAwesomeIcon;
         back: FontAwesomeIcon;
         clone: FontAwesomeIcon;
         clipboard: FontAwesomeIcon;
         close: FontAwesomeIcon;
+        crop: FontAwesomeIcon;
         code: MaterialIcon;
         color: MaterialIcon;
         copy: MaterialIcon;
@@ -21,6 +23,8 @@ export declare function useIcons(): {
         drag: FontAwesomeIcon;
         edit: FontAwesomeIcon;
         expand: FontAwesomeIcon;
+        flip: MaterialIcon;
+        filter: FontAwesomeIcon;
         header: FontAwesomeIcon;
         info: FontAwesomeIcon;
         lock: FontAwesomeIcon;
@@ -33,6 +37,7 @@ export declare function useIcons(): {
         tag: FontAwesomeIcon;
         tags: FontAwesomeIcon;
         targeting: FontAwesomeIcon;
+        redo: FontAwesomeIcon;
         remove: FontAwesomeIcon;
         settings: FontAwesomeIcon;
         sort: MaterialIcon;
@@ -51,10 +56,12 @@ export declare function useIcons(): {
     };
     presets: {
         add: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
+        adjust: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         back: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         close: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         clipboard: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         clone: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
+        crop: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         color: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         copy: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         code: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
@@ -62,6 +69,8 @@ export declare function useIcons(): {
         device: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         drag: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         edit: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
+        filter: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
+        flip: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         expand: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         header: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         info: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
@@ -74,6 +83,7 @@ export declare function useIcons(): {
         navigate: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         tag: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         tags: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
+        redo: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         remove: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         settings: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;
         sort: (size?: OIconSizes, toned?: boolean, theming?: ThemeableComponentProps) => JSX.Element;

package/internal-do-not-import-from-here/vue/VueApp.d.ts

@@ -1,7 +1,7 @@
 import { App, DefineComponent } from "vue";
-import { WebComponentBundleManifest } from "@omnia/fx-models";
+import { ComponentBundleManifest } from "@omnia/fx-models";
 export declare function getVueApps(): Set<App<Element>>;
 export declare function destroyVueApp(app: App<Element>): void;
 export declare function createVueApp(rootComponent: any, rootProps?: any): App<Element>;
-export declare function registerAsyncVueComponent(app: App, component: WebComponentBundleManifest): void;
+export declare function registerAsyncVueComponent(app: App, component: ComponentBundleManifest): void;
 export declare function resolveAsyncVueComponent(elementName: string, definition: DefineComponent): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx",
   "license": "MIT",
-  "version": "8.0.102-vnext",
+  "version": "8.0.103-vnext",
   "description": "Provide Omnia Fx typings and tooling for clientside Omnia development.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -20,13 +20,13 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "8.0.102-vnext",
+    "@omnia/fx-models": "8.0.103-vnext",
     "@microsoft/signalr": "6.0.1",
     "broadcast-channel": "4.8.0",
     "dayjs": "1.10.7",
     "vue-virtual-scroller": "1.0.0-rc.2",
     "splitpanes": "2.4.1",
-    "vuetify": "3.3.14",
+    "vuetify": "3.3.16",
     "vue": "3.3.4",
     "tslib": "2.5.0",
     "typescript": "5.0.4",