@omnia/fx 8.0.33-vnext → 8.0.34-dev

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

@@ -19,10 +19,10 @@ export interface StateMutationLog {
 export interface StateActionLog {
     func: any;
 }
-type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
-type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
-type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
-type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
+export type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
+export type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
+export type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
+export type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
 export declare class StoreLogger {
     private _logState;
     enabled: boolean;
@@ -148,4 +148,3 @@ export declare class StoreMutation<T extends Function, CommitFunc extends Functi
     onCommiting(fn: T): IMessageBusSubscriptionHandler;
     onCommited(fn: T): IMessageBusSubscriptionHandler;
 }
-export {};

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

@@ -1,22 +1,19 @@
 import { TimeZoneUnit } from "../models";
 import { Store } from "./Store";
+import dayjs from "dayjs";
 export declare class TimeZoneStore extends Store {
     private timeZoneService;
-    private omniaContext;
     private localTimeZoneId;
     private timeZoneUnits;
     private loadTimeZoneCollectionPromise;
-    private loadCurrenTimeZoneSettingsPromise;
-    private currentUser;
-    private currentTimeZone;
     getters: {
         localTimeZoneId: () => string;
         timeZones: () => TimeZoneUnit[];
-        convertToCurrentUserTimeZone: (utcDatetime: string) => any;
+        convertToCurrentUserTimeZone: (utcDatetime: string) => dayjs.Dayjs;
+        convertToTimeZone: (utcDatetime: string, timezone: string) => dayjs.Dayjs;
     };
     actions: {
         ensureTimeZones: import("./Store").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
-        ensureLoadedCurrentTimeZoneSettings: import("./Store").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
     };
     protected onActivated(): void;
 }

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

@@ -1,4 +1,4 @@
-import { EnterprisePropertyDefinition, GroupIdentity, GuidValue, Identity, IdentityProperty, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity } from "@omnia/fx-models";
+import { GroupIdentity, GuidValue, Identity, IdentityProperty, UserIdentityPropertyDefinition, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity } from "@omnia/fx-models";
 import { MediaPickerService, UserPresenceStatus } from "../services";
 import { Store } from "./Store";
 export declare class UserIdentityStore extends Store {
@@ -22,8 +22,11 @@ export declare class UserIdentityStore extends Store {
     };
     actions: {
         addUserProperty: import("./Store").StoreAction<unknown, (property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (result: void, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (failureReason: any, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (property: PropertyBinding<PropertyDefinition<any, any, any>>) => Promise<void>>;
-        createUserProperty: import("./Store").StoreAction<unknown, (property: EnterprisePropertyDefinition) => void, (result: void, property: EnterprisePropertyDefinition) => void, (failureReason: any, property: EnterprisePropertyDefinition) => void, (property: EnterprisePropertyDefinition) => Promise<void>>;
+        createUserProperty: import("./Store").StoreAction<unknown, (property: UserIdentityPropertyDefinition) => void, (result: void, property: UserIdentityPropertyDefinition) => void, (failureReason: any, property: UserIdentityPropertyDefinition) => void, (property: UserIdentityPropertyDefinition) => Promise<void>>;
         removeUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        updateUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        terminateUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        restoreUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
         ensureLoadUserProperties: import("./Store").StoreAction<unknown, () => void, (result: IdentityProperty[]) => void, (failureReason: any) => void, () => Promise<IdentityProperty[]>>;
         resolveUsersIdentity: import("./Store").StoreAction<unknown, (users: UserIdentity[]) => void, (result: {
             [uid: string]: ResolvedUserIdentity;

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

@@ -13,6 +13,7 @@ export declare class VersionedLayoutStore extends Store {
         getLatestRef: (dataIdentifier: IVersionedDataIdentifier) => LatestReferenceResponse;
         getAppScopedLayoutWithDefinition: <Definition extends VersionedLayoutDefinition>(appInstanceId: GuidValue, definition: new () => Definition) => VersionedLayout[];
         getTenantScopedLayoutWithDefinition: <Definition_1 extends VersionedLayoutDefinition>(definition: new () => Definition_1) => VersionedLayout[];
+        getBusinessProfileScopedLayoutWithDefinition: <Definition_2 extends VersionedLayoutDefinition>(businessProfileId: GuidValue, definition: new () => Definition_2) => VersionedLayout[];
     };
     mutations: {
         addOrUpdateLayouts: import("./Store").StoreMutation<(...versionedLayouts: VersionedLayout[]) => void, (...args: VersionedLayout[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
@@ -27,6 +28,7 @@ export declare class VersionedLayoutStore extends Store {
         ensureLoadDefinition: import("./Store").StoreAction<unknown, (version: IVersionReference) => void, (result: void, version: IVersionReference) => void, (failureReason: any, version: IVersionReference) => void, (version: IVersionReference) => Promise<void>>;
         ensureLoadDefinitionWithParentLayout: import("./Store").StoreAction<unknown, (version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (result: Layout, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (failureReason: any, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => Promise<Layout>>;
         ensureLoadDisplayBreakpointMapping: import("./Store").StoreAction<unknown, (versionedLayout: VersionedLayout, useCache?: unknown) => void, (result: DisplayBreakpointVersionedAlternateLayoutMapping, versionedLayout: VersionedLayout, useCache?: unknown) => void, (failureReason: any, versionedLayout: VersionedLayout, useCache?: unknown) => void, (versionedLayout: VersionedLayout, useCache?: unknown) => Promise<DisplayBreakpointVersionedAlternateLayoutMapping>>;
+        ensureLoadByProfileAndTypeId: import("./Store").StoreAction<unknown, (businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (result: void, businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (failureReason: any, businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (businessProfileId: GuidValue, layoutTypeId: GuidValue) => Promise<void>>;
         setDisplayBreakpointMapping: import("./Store").StoreAction<unknown, (versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (result: void, versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (failureReason: any, versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => Promise<void>>;
         createAppScoped: import("./Store").StoreAction<unknown, (appInstanceId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
             versionedLayout: VersionedLayout;
@@ -35,6 +37,13 @@ export declare class VersionedLayoutStore extends Store {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
         }>>;
+        createBusinessProfileScoped: import("./Store").StoreAction<unknown, (businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
+            versionedLayout: VersionedLayout;
+            checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
+        }, businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (failureReason: any, businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<{
+            versionedLayout: VersionedLayout;
+            checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
+        }>>;
         createTenantScoped: import("./Store").StoreAction<unknown, (definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;

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

@@ -40,3 +40,6 @@ export * from "./PromotedTagStore";
 export * from "./DynamicGroupStore";
 export * from "./ConnectedTenantStore";
 export * from "./DefineStore";
+export * from "./oxide";
+export * from "./AiSettingsStore";
+export * from "./LinkReferencesStore";

package/internal-do-not-import-from-here/stores/oxide/ComponentHostStore.d.ts

@@ -0,0 +1,71 @@
+declare const HostTypeDefinitions: readonly ["admin", "editor", "docs"];
+export type HostTypes = typeof HostTypeDefinitions[number];
+declare const ComponentHostTypeDefinitions: readonly ["dialog", "drawer", "expansion-panel", "blade", "app", "table", "appbar", "toolbar", "tab", "tab-vertical", "panel", "omfx", "menu"];
+export type ComponentHostTypes = typeof ComponentHostTypeDefinitions[number];
+declare const ComponentVariantDefinitions: readonly ["footer", "content", "navigation", "header", "settings", "info-section", "default", "section", "options", "toolbar"];
+export type ComponentVariants = typeof ComponentVariantDefinitions[number];
+export interface NewHostSettings {
+    host?: HostTypes;
+    componentHost?: ComponentHostTypes;
+    variant?: ComponentVariants;
+    force?: boolean;
+    appliedComponent?: string;
+}
+export declare const useCompontentHostStore: () => {
+    state: {
+        host: "editor" | "admin" | "docs";
+        componentHost: "dialog" | "menu" | "table" | "tab" | "toolbar" | "app" | "tab-vertical" | "drawer" | "expansion-panel" | "blade" | "appbar" | "panel" | "omfx";
+        componentVariant: "section" | "navigation" | "default" | "footer" | "header" | "options" | "content" | "toolbar" | "settings" | "info-section";
+        appliedComponents: string[];
+        force: boolean;
+    };
+    events: {
+        onMutatedHost: import("internal/fx/core").MessageBusExposeOnlySubscription<"editor" | "admin" | "docs">;
+        onMutatedComponentHost: import("internal/fx/core").MessageBusExposeOnlySubscription<"dialog" | "menu" | "table" | "tab" | "toolbar" | "app" | "tab-vertical" | "drawer" | "expansion-panel" | "blade" | "appbar" | "panel" | "omfx">;
+        onMutatedComponentVariant: import("internal/fx/core").MessageBusExposeOnlySubscription<"section" | "navigation" | "default" | "footer" | "header" | "options" | "content" | "toolbar" | "settings" | "info-section">;
+        onMutatedAppliedComponents: import("internal/fx/core").MessageBusExposeOnlySubscription<string[]>;
+        onMutatedForce: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching<T extends (...args: any) => any>(action: (actions: {
+            addAppliedComponent(host: string): void;
+            setHost(type: HostTypes): void;
+            setComponentHost(type: ComponentHostTypes): void;
+            setComponentVariant(variant: ComponentVariants): void;
+            setForce(value: boolean): void;
+            provideNewHost(settings: NewHostSettings): void;
+        }) => T, fn: T extends (...args: infer U) => any ? (...args: U) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onDispatched<T_1 extends (...args: any) => any>(action: (actions: {
+            addAppliedComponent(host: string): void;
+            setHost(type: HostTypes): void;
+            setComponentHost(type: ComponentHostTypes): void;
+            setComponentVariant(variant: ComponentVariants): void;
+            setForce(value: boolean): void;
+            provideNewHost(settings: NewHostSettings): void;
+        }) => T_1, fn: T_1 extends (...args: infer U_1) => infer Y | Promise<infer Y> ? (result: Y, ...args: U_1) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onFailure<T_2 extends (...args: any) => any>(action: (actions: {
+            addAppliedComponent(host: string): void;
+            setHost(type: HostTypes): void;
+            setComponentHost(type: ComponentHostTypes): void;
+            setComponentVariant(variant: ComponentVariants): void;
+            setForce(value: boolean): void;
+            provideNewHost(settings: NewHostSettings): void;
+        }) => T_2, fn: T_2 extends (...args: infer U_2) => any ? (failureReason: any, ...args: U_2) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    } & {
+        addAppliedComponent(host: string): void;
+        setHost(type: HostTypes): void;
+        setComponentHost(type: ComponentHostTypes): void;
+        setComponentVariant(variant: ComponentVariants): void;
+        setForce(value: boolean): void;
+        provideNewHost(settings: NewHostSettings): void;
+    };
+    get: {
+        canApplyOn: (hostType: ComponentHostTypes | HostTypes, variant?: any) => boolean;
+        readonly host: "editor" | "admin" | "docs";
+        readonly componentHost: "dialog" | "menu" | "table" | "tab" | "toolbar" | "app" | "tab-vertical" | "drawer" | "expansion-panel" | "blade" | "appbar" | "panel" | "omfx";
+        readonly componentVariant: "section" | "navigation" | "default" | "footer" | "header" | "options" | "content" | "toolbar" | "settings" | "info-section";
+        readonly force: boolean;
+        appliedComponents(host: string): boolean;
+    };
+};
+export {};

package/internal-do-not-import-from-here/stores/oxide/ComponentSharedSettingsStore.d.ts

@@ -0,0 +1,24 @@
+export declare const useCompontentSharedSettingsStore: () => {
+    state: {
+        settings: any;
+    };
+    events: {
+        onMutatedSettings: import("internal/fx/core").MessageBusExposeOnlySubscription<any>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching<T extends (...args: any) => any>(action: (actions: {
+            updateSettings(settings: any): void;
+        }) => T, fn: T extends (...args: infer U) => any ? (...args: U) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onDispatched<T_1 extends (...args: any) => any>(action: (actions: {
+            updateSettings(settings: any): void;
+        }) => T_1, fn: T_1 extends (...args: infer U_1) => infer Y | Promise<infer Y> ? (result: Y, ...args: U_1) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onFailure<T_2 extends (...args: any) => any>(action: (actions: {
+            updateSettings(settings: any): void;
+        }) => T_2, fn: T_2 extends (...args: infer U_2) => any ? (failureReason: any, ...args: U_2) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    } & {
+        updateSettings(settings: any): void;
+    };
+    get: {
+        settings<TSettings>(): TSettings;
+    };
+};

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

@@ -0,0 +1,2 @@
+export * from "./ComponentHostStore";
+export * from "./ComponentSharedSettingsStore";

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

@@ -1,4 +1,4 @@
-import "client/tooling/vue/bb000000-0000-bbbb-0000-0000000000bb.wctypings";
+import "client/tooling/vue/config/wctypings";
 import "../wctypings";
 import "./button/index";
 import "./colorpicker/index";
@@ -36,7 +36,6 @@ import "./richtexteditor/index";
 import "./richtexteditor/PublicRichTextEditorApi";
 import "./richtexteditorrenderer/index";
 import "./rollupfilter/index";
-import "./securitytrimer/index";
 import "./settings/index";
 import "./sitelogoicon/index";
 import "./social/index";
@@ -67,19 +66,56 @@ type VuetifyProps<T> = {
 type VuetifySlots<T> = {
     [K in keyof T as K extends `v-slot:${infer N}` ? N : never]: T[K];
 };
-import { VTextField, VBtn, VBtnToggle, VBtnGroup, VNavigationDrawer, VList, VListItem, VListGroup, VListImg, VListItemAction, VListItemTitle, VListItemSubtitle, VListItemMedia, VListSubheader, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VCard, VCardActions, VCardItem, VCardSubtitle, VCardText, VCardTitle, VExpansionPanels, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VAutocomplete, VMenu, VTable, VCheckbox, VCheckboxBtn, VVirtualScroll } from "vuetify/components";
-import { VDataTable, VDataTableRow, VDataTableRows, VDataTableVirtual, VDataTableServer } from "vuetify/labs/components";
+type VuetifyValue<T> = T extends {
+    value?: any;
+} ? T["value"] : T;
+import { VTooltip, VTextarea, VSwitch, VRadioGroup, VForm, VTextField, VBtn, VBtnToggle, VBtnGroup, VNavigationDrawer, VList, VListItem, VListGroup, VListImg, VListItemAction, VListItemTitle, VListItemSubtitle, VListItemMedia, VListSubheader, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VCard, VCardActions, VCardItem, VCardSubtitle, VCardText, VCardTitle, VExpansionPanels, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VAutocomplete, VMenu, VTable, VCheckbox, VCheckboxBtn, VVirtualScroll, VChip, VSelect, VBadge } from "vuetify/components";
+import { Intersect } from "vuetify/directives";
+import { VDataTable, VDataTableRow, VDataTableRows, VDataTableVirtual, VDataTableServer, VInfiniteScroll } from "vuetify/labs/components";
 export interface VDataTableServerSlots extends VuetifySlots<VuetifyProps<Pick<VDataTableServer, "$props">>> {
 }
 export interface VDataTableSlots extends VuetifySlots<VuetifyProps<Pick<VDataTable, "$props">>> {
 }
+export interface VListItemSlots extends VuetifySlots<VuetifyProps<Pick<VListItem, "$props">>> {
+}
+export interface VTextFieldSlots extends VuetifySlots<VuetifyProps<Pick<VTextField, "$props">>> {
+}
+export interface VTextAreaSlots extends VuetifySlots<VuetifyProps<Pick<VTextarea, "$props">>> {
+}
 declare global {
     namespace JSX {
         interface Element {
         }
         interface ElementClass {
         }
+        interface IntrinsicAttributes {
+            "v-intersect"?: VuetifyValue<Pick<Parameters<typeof Intersect.mounted>[1], "value">>;
+        }
         interface IntrinsicElements {
+            "v-tooltip": VuetifyProps<Pick<VTooltip, "$props">> & {
+                [name: string]: any;
+            };
+            "v-textarea": VuetifyProps<Pick<VTextarea, "$props">> & {
+                [name: string]: any;
+            };
+            "v-radio-group": VuetifyProps<Pick<VRadioGroup, "$props">> & {
+                [name: string]: any;
+            };
+            "v-switch": VuetifyProps<Pick<VSwitch, "$props">> & {
+                [name: string]: any;
+            };
+            "v-form": VuetifyProps<Pick<VForm, "$props">> & {
+                [name: string]: any;
+            };
+            "v-badge": VuetifyProps<Pick<VBadge, "$props">> & {
+                [name: string]: any;
+            };
+            "v-select": VuetifyProps<Pick<VSelect, "$props">> & {
+                [name: string]: any;
+            };
+            "v-chip": VuetifyProps<Pick<VChip, "$props">> & {
+                [name: string]: any;
+            };
             "v-data-table-server": VuetifyProps<Pick<VDataTableServer, "$props">> & {
                 [name: string]: any;
             };
@@ -113,6 +149,9 @@ declare global {
             "v-virtual-scroll": VuetifyProps<Pick<VVirtualScroll, "$props">> & {
                 [name: string]: any;
             };
+            "v-infinite-scroll": VuetifyProps<Pick<VInfiniteScroll, "$props">> & {
+                [name: string]: any;
+            };
             "v-autocomplete": VuetifyProps<Pick<VAutocomplete, "$props">> & {
                 [name: string]: any;
             };

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

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

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

@@ -9,13 +9,11 @@ export * from "./heading";
 export * from "./journey";
 export * from "./app";
 export * from "./datetimepicker";
-export * from "./mediapicker";
-export * from "./mediapickerimage";
+export * from "./depricated-mediapicker";
 export * from "./mediapickervideo";
 export * from "./mediapickerproviders";
 export * from "./fileuploader";
 export * from "./actionhandler";
-export * from "./imagetransformation";
 export * from "./iframe";
 export * from "./validation";
 export * from "./letteravatar";
@@ -26,14 +24,11 @@ export * from "./social";
 export * from "./sitelogoicon";
 export * from "./languagepicker";
 export * from "./permissioninput";
-export * from "./securitytrimer";
 export * from "./models";
 export * from "./wizard";
 export * from "./multilingualinput";
 export * from "./texttranslator";
 export * from "./errormessage";
-export * from "./imagegrid";
-export * from "./timeperiodpicker";
 export * from "./theming";
 export * from "./theming-v2";
 export * from "./messaging";
@@ -56,6 +51,7 @@ export * from "./use";
 export * from "./tag";
 export * from "./decorators";
 export * from "./docs";
+export * from "./statuscoderenderer";
 export * from "./VueWebComponentSlot";
 export * from "./TokenBasedRouter";
 export * from "./StyleFlow";
@@ -79,4 +75,4 @@ export type { FocusOption, ClickOutOption, ScrollOption, LinkHandlerOptions, } f
 export { FocusDirective, ClickOutDirective, ScrollDirective, LinkHandlerDirective, } from "./directives";
 export { VueComponentBase, getVuetifyAppClasses, VueComponentConnect, } from "./VueComponentBase";
 export type { VueComponentBaseProps, VueComponentBaseEvents, } from "./VueComponentBase";
-export { defineVueWebComponent, defineVueComponent, defineSlotsAndProps, definePropFunctionType, definePropObjectType, defineVue } from "./InternalDefineWebComponent";
+export { defineVueComponent, definePropFunctionType, definePropObjectType, defineVue, createVueNode, getElementName, isElement } from "./InternalDefineComponent";

package/internal-do-not-import-from-here/ux/{InternalDefineWebComponent.d.ts → InternalDefineComponent.d.ts}

@@ -1,10 +1,21 @@
-import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentPropsOptions, DefineComponent, ComponentObjectPropsOptions, Prop, VNodeChild, PropType, ObjectEmitsOptions, CreateComponentPublicInstance, ExtractPropTypes, ExtractDefaultPropTypes, ComponentOptionsBase, RenderFunction, VNode, SlotsType, ComponentOptions } from "vue";
-import { LooseRequired, UnionToIntersection, Prettify } from "@vue/shared";
-import { ThemeableComponentProps, WebComponentBundleManifest } from "@omnia/fx-models";
-import { useColorSchemaSetup, useBlueprintSetup } from "./use";
-import { Slot } from "./DefineVueTypings";
+import { SubscriptionHandler } from "@omnia/fx";
+import { ComponentInjectOptions, ComponentObjectPropsOptions, ComponentOptions, ComponentOptionsBase, ComponentOptionsMixin, ComponentPropsOptions, ComputedOptions, CreateComponentPublicInstance, DefineComponent, EmitsOptions, ExtractDefaultPropTypes, ExtractPropTypes, MethodOptions, ObjectEmitsOptions, Prop, PropType, RenderFunction, Slot, SlotsType, VNode, VNodeArrayChildren, VNodeProps, VNodeTypes, computed, watch, watchEffect } from "vue";
+import { LooseRequired, Prettify, UnionToIntersection } from "@vue/shared";
+import { ComponentBundleManifest, GuidValue, ThemeableComponentProps } from "@omnia/fx-models";
+import { IValidatorBase } from "./models/Validation";
+import { useBlueprintSetup } from "./use/UseBlueprintSetup";
+import { useColorSchemaSetup } from "./use/UseColorSchemaSetup";
 export declare function definePropFunctionType<T>(): PropType<T>;
 export declare function definePropObjectType<T>(): PropType<T>;
+type RawSlots = {
+    [name: string]: unknown;
+    $stable?: boolean;
+};
+type RawProps = VNodeProps & {
+    __v_isVNode?: never;
+    [Symbol.iterator]?: never;
+} & Record<string, any>;
+type RawChildren = string | number | boolean | VNode | VNodeArrayChildren | (() => any);
 type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
 type InferPropType<T> = [T] extends [null] ? any : [T] extends [
     {
@@ -36,6 +47,13 @@ type ExcludeJsxPropKeys<T> = T extends string[] ? T : {
 type ExtractPropModels<T> = {
     -readonly [K in keyof T as K extends `v-model:${infer N}` ? N : K extends "v-model" ? "modelValue" : never]: T[K];
 };
+type ExtractPropSlots<T> = T extends {
+    "v-slots"?: any;
+} ? T["v-slots"] & {
+    default?: Slot;
+} : {
+    default?: Slot;
+};
 type RequiredKeys<T> = {
     [K in keyof T]: T[K] extends {
         required: true;
@@ -55,11 +73,6 @@ type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
 type TsxComponentV3<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PropsDefinition = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? CustomExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions>> = DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE> & {
     propsDefinition: PropsDefinition extends {} ? Omit<PropsDefinition, keyof ({} extends E ? {} : EmitsToProps<E>)> & ({} extends E ? {} : EmitsToProps<E>) : never;
 };
-export declare function defineSlotsAndProps<Slots extends Record<string, Slot>>(): <Props>(props: ComponentObjectPropsOptions<Props>) => ComponentObjectPropsOptions<Props> & {
-    "v-slots"?: Prop<{
-        default?: () => VNodeChild;
-    } & Slots>;
-};
 type ComponentOptionsWithObjectPropsCustom<PropsOptions = ComponentObjectPropsOptions, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<ExtractPropTypes<PropsOptions>> & EmitsToProps<E>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBaseExtends<RemoveDefinePropApi<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> & {
     props: PropsOptions & ThisType<void>;
 } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I>>;
@@ -72,10 +85,6 @@ type ComponentOptionsWithArrayProps<PropNames extends string = string, RawBindin
     props: PropNames[];
 } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, {}, false, I>>;
 type Data = Record<string, unknown>;
-type InternalSlots = {
-    [name: string]: (...args: any[]) => VNode[] | undefined;
-};
-type Slots = Readonly<InternalSlots>;
 type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{
     [key in Event]: Options[key] extends (...args: infer Args) => any ? (event: key, ...args: Args) => void : (event: key, ...args: any[]) => void;
 }[Event]>;
@@ -95,27 +104,57 @@ type ExtractMixin<T> = {
 type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
 type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType<{}, {}, {}, {}, {}> : UnionToIntersection<ExtractMixin<T>>;
 type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
-type SetupContext<Props, E = EmitsOptions> = E extends any ? {
+type UseState = <T = any>(state?: T) => {
+    state: T;
+    setState(state: T): void;
+};
+type SetupContext<ExtractedPropsType, Props, E = EmitsOptions> = E extends any ? {
+    props: ExtractedPropsType;
     attrs: Data;
-    slots: Slots;
+    slots: ExtractPropSlots<Props>;
     models?: Required<ExtractPropModels<Props>>;
     colors: ReturnType<typeof useColorSchemaSetup>;
     blueprints: ReturnType<typeof useBlueprintSetup>;
+    validator: IValidatorBase;
     emit: EmitFn<E>;
     expose: (exposed?: Record<string, any>) => void;
+    useState: UseState;
+    computed: typeof computed;
+    watch: typeof watch;
+    watchEffect: typeof watchEffect;
+    subscriptions: SubscriptionHandler;
 } : never;
 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;
+    setup?: (this: void, ctx: SetupContext<LooseRequired<ExcludeJsxPropKeys<Props> & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, "P">>>, 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: (ctx: SetupContext<Props, 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: (ctx: SetupContext<Props, 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 extends Record<string, false | Slot<any[]>>>(): {
+    slots<Slots_1>(): {
         "v-slots": Prop<{
-            default?: import("@omnia/fx-models").Func<[VNodeChild]>;
+            default?: import("./DefineVueTypings").Slot<any[]>;
         } & Slots_1>;
         doc$(doc?: { [K in keyof Slots_1]: string; }): {
             "v-slots": Prop<{
-                default?: import("@omnia/fx-models").Func<[VNodeChild]>;
+                default?: import("./DefineVueTypings").Slot<any[]>;
             } & Slots_1>;
         };
     };
@@ -220,41 +259,9 @@ 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;
+export declare function getElementName(componentManifestId: GuidValue): string;
+export declare function createVueNode(element: VNodeTypes | GuidValue, props?: RawProps, children?: RawChildren | RawSlots): VNode;
+export declare function isElement<TElement = typeof omfx>(element: string, cb: (elements: TElement) => any): boolean;
 declare global {
     namespace JSX {
         interface IntrinsicAttributes {

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

@@ -1,6 +1,6 @@
 import { MessageBusExposeOnlySubscription, SubscriptionHandler } from "..";
 import { IMessageBusTopicSubscription, Color } from "../models";
-interface ITheme {
+export interface ITheme {
     onThemingChanged: () => IMessageBusTopicSubscription<ITheme>;
     system: {
         grey: Color;
@@ -90,4 +90,3 @@ export declare class OmniaTheming implements ITheme {
     private get bodyBackground();
     private get chromeBackground();
 }
-export {};

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

@@ -23,6 +23,7 @@ export declare abstract class TokenBasedRouter<T1 extends TokenBasedRoute, T2 ex
     protected protectedClearRoute(): void;
     protected combinePathParts(...parts: string[]): string;
     private resolveContext;
+    static getRouterUrl(): string;
     private static buildPath;
     private static resolveTokenBasedContext;
     private static ensureNoSlashAtTheBeginningAndTheEnd;

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

@@ -1,3 +1 @@
-import "vue-virtual-scroller/dist/vue-virtual-scroller.css";
-export declare function getProvided(vueComponent: any, el: HTMLElement, name: string): void;
-export declare function setProvided(vueComponent: any, vuetifyRef: any, name: string): void;
+export {};