@omnia/fx 8.0.8-vnext → 8.0.9-vnext

package/internal-do-not-import-from-here/shared/models/theming/TypographyDefinition.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypographyTypes = void 0;
-exports.TypographyTypes = {
-    h1: "h1",
-    h2: "h2",
-    h3: "h3",
-    text: "text",
-    caption: "caption",
-    link: "link",
-};
+var TypographyTypes;
+(function (TypographyTypes) {
+    TypographyTypes["h1"] = "h1";
+    TypographyTypes["h2"] = "h2";
+    TypographyTypes["h3"] = "h3";
+    TypographyTypes["text"] = "text";
+    TypographyTypes["caption"] = "caption";
+    TypographyTypes["link"] = "link";
+})(TypographyTypes = exports.TypographyTypes || (exports.TypographyTypes = {}));

package/internal-do-not-import-from-here/shared/models/theming/UseThemeMethods.d.ts

@@ -0,0 +1,11 @@
+import { ColorDefinition, ColorSchemaType, ColorSchemaTypes, ColorType, ColorTypes, ThemeDefinitionV2 } from "./ThemeDefinitionV2";
+import { TypographyType, TypographyTypeDefinition, TypographyTypes } from "./TypographyDefinition";
+export declare const useThemeMethods: (themedefinition: ThemeDefinitionV2) => {
+    colorSchema: (colorSchemaType: ColorSchemaTypes | ColorSchemaType) => import("./ThemeDefinitionV2").ColorSchema;
+    typography: (typographyType: TypographyTypes | TypographyType) => TypographyTypeDefinition;
+    color: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => string;
+    colorDefinition: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => ColorDefinition;
+    complementaryColorType: (colorType: ColorTypes | ColorType) => ColorTypes.base | ColorTypes.onBase | ColorTypes.container | ColorTypes.onContainer;
+    complementaryColor: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => string;
+    complementaryColorDefinition: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => ColorDefinition;
+};

package/internal-do-not-import-from-here/shared/models/theming/{ThemeMethods.js → UseThemeMethods.js}

@@ -137,7 +137,7 @@ const useThemeMethods = (themedefinition) => {
         colorDefinition,
         complementaryColorType,
         complementaryColor,
-        complementaryColorDefinition
+        complementaryColorDefinition,
     };
 };
 exports.useThemeMethods = useThemeMethods;

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

@@ -1,4 +1,4 @@
 export * from "./ThemeDefinitionV2";
 export * from "./TypographyDefinition";
 export * from "./OmniaThemes";
-export * from "./ThemeMethods";
+export * from "./UseThemeMethods";

package/internal-do-not-import-from-here/shared/models/theming/index.js

@@ -4,4 +4,4 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./ThemeDefinitionV2"), exports);
 tslib_1.__exportStar(require("./TypographyDefinition"), exports);
 tslib_1.__exportStar(require("./OmniaThemes"), exports);
-tslib_1.__exportStar(require("./ThemeMethods"), exports);
+tslib_1.__exportStar(require("./UseThemeMethods"), exports);

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

@@ -0,0 +1,160 @@
+import "client/tooling/vue/bb000000-0000-bbbb-0000-0000000000bb.wctypings";
+import "../wctypings";
+import "./button/index";
+import "./colorpicker/index";
+import "./confirmdialog/index";
+import "./contextlanguagepicker/index";
+import "./datatable/index";
+import "./datetimepicker/index";
+import "./dialog/index";
+import "./documenticon/index";
+import "./enterpriseproperties/index";
+import "./enterprisepropertysets/index";
+import "./errormessage/index";
+import "./features/index";
+import "./fileuploader/index";
+import "./governancedashboard/index";
+import "./heading/index";
+import "./icon/index";
+import "./iconpicker/index";
+import "./iframe/index";
+import "./imagegrid/index";
+import "./imagetransformation/index";
+import "./imagetransformer/index";
+import "./journey/index";
+import "./languagepicker/index";
+import "./layoutcanvas/editor/ILayoutEditorCanvas";
+import "./layoutcanvas/renderer/ILayoutBlockRendererHelper";
+import "./layoutcanvas/renderer/ILayoutRendererCanvas";
+import "./letteravatar/index";
+import "./mediapicker/index";
+import "./mediapickerproviders/index";
+import "./messaging/index";
+import "./multilingualinput/index";
+import "./peoplepicker/index";
+import "./permissioninput/index";
+import "./richtexteditor/index";
+import "./richtexteditor/PublicRichTextEditorApi";
+import "./richtexteditorrenderer/index";
+import "./rollupfilter/index";
+import "./securitytrimer/index";
+import "./settings/index";
+import "./sitelogoicon/index";
+import "./social/index";
+import "./spacingpicker/index";
+import "./statusmessageoverlay/index";
+import "./templatepicker/index";
+import "./texttranslator/index";
+import "./theming/index";
+import "./timeperiodpicker/index";
+import "./timezonepicker/index";
+import "./urlinput/index";
+import "./validation/index";
+import "./welcome/index";
+import "./wizard/index";
+import "./enterpriseglossary/index";
+import "./app/builders/index";
+import "./app/appinstance/index";
+import "./selection/index";
+import "./profilecard/index";
+import "./organizationtree/IOrganizationTree";
+type VuetifyProps<T> = {
+    [K in keyof (T extends {
+        $props: any;
+    } ? T["$props"] : T)]: T extends {
+        $props: any;
+    } ? T["$props"][K] : never;
+};
+import { 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 } from "vuetify/components";
+declare global {
+    namespace JSX {
+        interface Element {
+        }
+        interface ElementClass {
+        }
+        interface IntrinsicElements {
+            "v-expansion-panels": VuetifyProps<Pick<VExpansionPanels, "$props">> & {
+                [name: string]: any;
+            };
+            "v-expansion-panel": VuetifyProps<Pick<VExpansionPanel, "$props">> & {
+                [name: string]: any;
+            };
+            "v-expansion-panel-text": VuetifyProps<Pick<VExpansionPanelText, "$props">> & {
+                [name: string]: any;
+            };
+            "v-expansion-panel-title": VuetifyProps<Pick<VExpansionPanelTitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card": VuetifyProps<Pick<VCard, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-actions": VuetifyProps<Pick<VCardActions, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-item": VuetifyProps<Pick<VCardItem, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-subtitle": VuetifyProps<Pick<VCardSubtitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-text": VuetifyProps<Pick<VCardText, "$props">> & {
+                [name: string]: any;
+            };
+            "v-card-title": VuetifyProps<Pick<VCardTitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-btn": VuetifyProps<Pick<VBtn, "$props">> & {
+                [name: string]: any;
+            };
+            "v-btn-group": VuetifyProps<Pick<VBtnGroup, "$props">> & {
+                [name: string]: any;
+            };
+            "v-btn-toggle": VuetifyProps<Pick<VBtnToggle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-navigation-drawer": VuetifyProps<Pick<VNavigationDrawer, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list": VuetifyProps<Pick<VList, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item": VuetifyProps<Pick<VListItem, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-group": VuetifyProps<Pick<VListGroup, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-img": VuetifyProps<Pick<VListImg, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-action": VuetifyProps<Pick<VListItemAction, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-title": VuetifyProps<Pick<VListItemTitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-subtitle": VuetifyProps<Pick<VListItemSubtitle, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-item-media": VuetifyProps<Pick<VListItemMedia, "$props">> & {
+                [name: string]: any;
+            };
+            "v-list-subheader": VuetifyProps<Pick<VListSubheader, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog": VuetifyProps<Pick<VDialog, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog-bottom-transition": VuetifyProps<Pick<VDialogBottomTransition, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog-top-transition": VuetifyProps<Pick<VDialogTopTransition, "$props">> & {
+                [name: string]: any;
+            };
+            "v-dialog-transition": VuetifyProps<Pick<VDialogTransition, "$props">> & {
+                [name: string]: any;
+            };
+        }
+    }
+}
+export {};

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

@@ -76,5 +76,6 @@ export * from "./SidePanelContext";
 export { OmniaTheming } from "./OmniaTheming";
 export type { FocusOption, ClickOutOption, ScrollOption, LinkHandlerOptions, } from "./directives";
 export { FocusDirective, ClickOutDirective, ScrollDirective, LinkHandlerDirective, } from "./directives";
-export { VueComponentBase, definePropFunctionType, definePropObjectType, getVuetifyAppClasses, VueComponentConnect, defineVueComponent, } from "./VueComponentBase";
+export { VueComponentBase, getVuetifyAppClasses, VueComponentConnect, } from "./VueComponentBase";
 export type { VueComponentBaseProps, VueComponentBaseEvents, } from "./VueComponentBase";
+export { defineVueWebComponent, defineVueComponent, defineSlotsAndProps, definePropFunctionType, definePropObjectType } from "./InternalDefineWebComponent";

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

@@ -1,8 +1,55 @@
-import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentOptionsWithArrayProps, ComponentPropsOptions, ComponentOptionsWithObjectProps, DefineComponent, ComponentObjectPropsOptions, ComponentOptionsWithoutProps, ExtractPropTypes } from "vue";
+import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentOptionsWithArrayProps, ComponentPropsOptions, ComponentOptionsWithObjectProps, DefineComponent, ComponentObjectPropsOptions, ComponentOptionsWithoutProps, Prop, VNodeChild, PropType } from "vue";
 import { WebComponentBundleManifest } from "@omnia/fx-models";
+export declare function definePropFunctionType<T>(): PropType<T>;
+export declare function definePropObjectType<T>(): PropType<T>;
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [
+    {
+        type: null | true;
+    }
+] ? any : [T] extends [
+    ObjectConstructor | {
+        type: ObjectConstructor;
+    }
+] ? Record<string, any> : [T] extends [
+    BooleanConstructor | {
+        type: BooleanConstructor;
+    }
+] ? boolean : [T] extends [
+    DateConstructor | {
+        type: DateConstructor;
+    }
+] ? Date : [T] extends [
+    (infer U)[] | {
+        type: (infer U)[];
+    }
+] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+type RequiredKeys<T> = {
+    [K in keyof T]: T[K] extends {
+        required: true;
+    } ? K : never;
+}[keyof T];
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+type OmniaExtractPropTypes<O> = {
+    [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]>;
+} & {
+    [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>;
+};
 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> = DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE> & {
-    propsDefinition: Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions>;
+    propsDefinition: Readonly<PropsOrPropOptions extends ComponentPropsOptions ? OmniaExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions>;
+};
+type Slot<T extends any[] = any[]> = (...args: T) => VNodeChild;
+export declare function defineSlotsAndProps<Slots extends Record<string, Slot>>(): <Props>(props: ComponentObjectPropsOptions<Props>) => ComponentObjectPropsOptions<Props> & {
+    "v-slots"?: {
+        type: PropType<Slots>;
+    };
 };
+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: ComponentOptionsWithObjectProps<ComponentObjectPropsOptions<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<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: ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<PropsOptions, RawBindings, D, C, M, Mixin, Extends, 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: ComponentOptionsWithObjectProps<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<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<{

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

@@ -1,4 +1,4 @@
-import { VNode, PropType, VNodeProps, VNodeArrayChildren, ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, DefineComponent, ComponentOptionsWithArrayProps, ComponentPropsOptions, ComponentOptionsWithObjectProps, ComponentObjectPropsOptions, ComponentOptionsWithoutProps, ExtractPropTypes, ObjectEmitsOptions, HTMLAttributes } from "vue";
+import { VNode, VNodeProps, HTMLAttributes, VNodeArrayChildren } from "vue";
 import { Vue } from "./decorators";
 import type { IComponentValidationEnabled, IValidator } from "./validation/IComponentValidationEnabled";
 import { ConfirmDialogResponse, ConfirmDialogOptions } from "./confirmdialog/IVueConfirmDialog";
@@ -90,11 +90,6 @@ type ScopedSlotReturnType = ReturnType<ScopedSlot>;
 type ScopedSlots<T> = {
     [K in keyof T]: (props: Exclude<T[K], undefined>) => ScopedSlotReturnType;
 };
-type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
-    [K in string & `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
-} : T extends ObjectEmitsOptions ? {
-    [K in string & `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}` ? T[Uncapitalize<C>] extends null ? (...args: any[]) => any : (...args: T[Uncapitalize<C>] extends (...args: infer P) => any ? P : never) => any : never;
-} : {};
 interface ComponentAdditionalAttrs {
 }
 type EventHandlers<E> = {
@@ -136,8 +131,6 @@ export interface VueComponentBaseProps extends Omit<HTMLAttributes, "placeholder
 }
 export interface VueComponentBaseEvents {
 }
-export declare function definePropFunctionType<T>(): PropType<T>;
-export declare function definePropObjectType<T>(): PropType<T>;
 export declare class VueComponentBase<Props = VueComponentBaseProps | {}, EventsWithOn = VueComponentBaseEvents, ScopedSlotArgs = {}> extends VueTsx<Props, EventsWithOn, ScopedSlotArgs> implements IVueComponentBase<Props, EventsWithOn, ScopedSlotArgs>, IComponentValidationEnabled {
     inheritanceTheme?: InheritanceTheme;
     themeTargetId?: string;
@@ -171,13 +164,53 @@ export declare function getVuetifyAppClasses(): string;
 export interface VueComponentConnectProps {
     content: () => JSX.Element;
 }
-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>): DefineComponent<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: ComponentOptionsWithObjectProps<ComponentObjectPropsOptions<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II, Readonly<ExtractPropTypes<ComponentObjectPropsOptions<Props>>> & EmitsToProps<E>>): DefineComponent<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>): DefineComponent<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: ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): DefineComponent<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE>;
-export declare const VueComponentConnect: DefineComponent<ComponentObjectPropsOptions<VueComponentConnectProps>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<ComponentObjectPropsOptions<VueComponentConnectProps>>>, {}>;
+export declare const VueComponentConnect: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<VueComponentConnectProps>>> & VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<VueComponentConnectProps>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<VueComponentConnectProps>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<VueComponentConnectProps>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<{} & {
+        content?: () => JSX.Element;
+    }>;
+};
 declare global {
     namespace JSX {
         interface IntrinsicAttributes {

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

@@ -24,16 +24,14 @@ export declare const VIconTag = "v-icon";
 export declare const VImgTag = "v-img";
 export declare const VLayoutTag = "v-layout";
 export declare const VListTag = "v-list";
+export declare const VListGroupTag = "v-list-group";
 export declare const VListItemTag = "v-list-item";
-export declare const VListItemAvatarTag = "v-list-item-avatar";
-export declare const VListItemContentTag = "v-list-item-content";
+export declare const VListItemActionTag = "v-list-item-action";
+export declare const VListItemMediaTag = "v-list-item-media";
 export declare const VListItemSubTitleTag = "v-list-item-subtitle";
 export declare const VListItemTitleTag = "v-list-item-title";
-export declare const VListGroupTag = "v-list-group";
-export declare const VListItemGroupTag = "v-list-item-group";
-export declare const VListItemActionTag = "v-list-item-action";
-export declare const VListItemActionTextTag = "v-list-item-action-text";
-export declare const VListItemIconTag = "v-list-item-icon";
+export declare const VListItemGroupTag = "v-list-subheader";
+export declare const VListImgTag = "v-list-img";
 export declare const VMenuTag = "v-menu";
 export declare const VNavigationDrawerTag = "v-navigation-drawer";
 export declare const VProgressCircularTag = "v-progress-circular";
@@ -85,8 +83,8 @@ export declare const VTimePickerClockTag = "v-time-picker-clock";
 export declare const VTimePickerTitleTag = "v-time-picker-title";
 export declare const VExpansionPanelsTag = "v-expansion-panels";
 export declare const VExpansionPanelTag = "v-expansion-panel";
-export declare const VExpansionPanelContentTag = "v-expansion-panel-content";
-export declare const VExpansionPanelHeaderTag = "v-expansion-panel-header";
+export declare const VExpansionPanelTextTag = "v-expansion-panel-text";
+export declare const VExpansionPanelTitleTag = "v-expansion-panel-title";
 export declare const VChipTag = "v-chip";
 export declare const VSwitchTag = "v-switch";
 export declare const VBottomNavTag = "v-bottom-navigation";

package/internal-do-not-import-from-here/ux/admin/chrome/AdminChrome.d.ts

@@ -1,61 +1,47 @@
-import { IWebComponentInstance } from "../../../";
-import { AdminNavigationBuiltInCategory, NavigationNode } from "../../../models";
-import { DirectionRuleStore } from "../../../stores";
-import { VueComponentBase } from "../../index";
-import { InputLanguageStore } from "../../inputlanguagepicker/stores";
 import "./AdminChrome.css";
-type AdminNavCategory = AdminNavigationBuiltInCategory | string;
-export declare class AdminChromeComponent extends VueComponentBase implements IWebComponentInstance {
-    private omniaContext;
-    private localizationService;
-    private permissionService;
-    private omniaTheming;
-    private subscriptionHandler;
-    directionStore: DirectionRuleStore;
-    private sidePanelContext;
-    private multilingualStore;
-    private adminChromeInstance;
-    inputLanguageStore: InputLanguageStore;
-    private omniaUxLocalization;
-    private htmlToRender;
-    private authorizedNodes;
-    private tenantAdministrator;
-    private bpAdministrator;
-    private appInstanceAdministrator;
-    private adminChromeClasses;
-    private selectedElement;
-    private classToFixVExpansionPanelZIndexIssue;
-    private adminContentId;
-    private tenantInfoSettings;
-    private displayLeftNav;
-    private checkGlobalPermissionResolvablePromise;
-    private checkedNodePermissionState;
-    private nodeReactiveStates;
-    beforeCreate(): void;
-    created(): void;
-    mounted(): void;
-    destroyed(): void;
-    private checkGlobalPermissions;
-    private checkNodeTrack;
-    private handleNavigationNode;
-    private checkNodePermission;
-    private setTheme;
-    private renderSelectedElement;
-    private getIdentityNode;
-    private isNodeEquals;
-    private toggleLefNav;
-    onNodeClick(node: NavigationNode): void;
-    closeOmniaAdmin(): void;
-    private setIconColor;
-    groupBy(list: any, keyGetter: any): Map<any, any>;
-    initTenantInfoSettings(): void;
-    private getSelectedNode;
-    private handleScroll;
-    private renderAppBar;
-    private getValidNodes;
-    render(): JSX.Element;
-    renderListItem(selectedNode: NavigationNode, node: NavigationNode): JSX.Element;
-    renderCategory(validNodes: NavigationNode[], category: AdminNavCategory, selectedNode: NavigationNode): JSX.Element;
-    renderAccessDeny(): JSX.Element;
-}
-export {};
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Readonly<{} & {}>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/admin/chrome/AdminChromeOld.d.ts

@@ -0,0 +1,61 @@
+import { IWebComponentInstance } from "../../../";
+import { AdminNavigationBuiltInCategory, NavigationNode } from "../../../models";
+import { DirectionRuleStore } from "../../../stores";
+import { VueComponentBase } from "../../index";
+import { InputLanguageStore } from "../../inputlanguagepicker/stores";
+import "./AdminChrome.css";
+type AdminNavCategory = AdminNavigationBuiltInCategory | string;
+export declare class AdminChromeComponent extends VueComponentBase implements IWebComponentInstance {
+    private omniaContext;
+    private localizationService;
+    private permissionService;
+    private omniaTheming;
+    private subscriptionHandler;
+    directionStore: DirectionRuleStore;
+    private sidePanelContext;
+    private multilingualStore;
+    private adminChromeInstance;
+    inputLanguageStore: InputLanguageStore;
+    private omniaUxLocalization;
+    private htmlToRender;
+    private authorizedNodes;
+    private tenantAdministrator;
+    private bpAdministrator;
+    private appInstanceAdministrator;
+    private adminChromeClasses;
+    private selectedElement;
+    private classToFixVExpansionPanelZIndexIssue;
+    private adminContentId;
+    private tenantInfoSettings;
+    private displayLeftNav;
+    private checkGlobalPermissionResolvablePromise;
+    private checkedNodePermissionState;
+    private nodeReactiveStates;
+    beforeCreate(): void;
+    created(): void;
+    mounted(): void;
+    destroyed(): void;
+    private checkGlobalPermissions;
+    private checkNodeTrack;
+    private handleNavigationNode;
+    private checkNodePermission;
+    private setTheme;
+    private renderSelectedElement;
+    private getIdentityNode;
+    private isNodeEquals;
+    private toggleLefNav;
+    onNodeClick(node: NavigationNode): void;
+    closeOmniaAdmin(): void;
+    private setIconColor;
+    groupBy(list: any, keyGetter: any): Map<any, any>;
+    initTenantInfoSettings(): void;
+    private getSelectedNode;
+    private handleScroll;
+    private renderAppBar;
+    private getValidNodes;
+    render(): JSX.Element;
+    renderListItem(selectedNode: NavigationNode, node: NavigationNode): JSX.Element;
+    renderCategory(validNodes: NavigationNode[], category: AdminNavCategory, selectedNode: NavigationNode): JSX.Element;
+    renderAccessDeny(): JSX.Element;
+}
+export {};

package/internal-do-not-import-from-here/ux/app/appinstance/renderer/AppInstanceRollup.d.ts

@@ -67,12 +67,12 @@ declare const _default: {
     blockInstance: IBlockInstance<AppInstanceRollupBlockSettings>;
     onFollowAppInstanceClicked: (appInstanceInfoUser: AppInstanceInfoUser) => void;
 }>>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Readonly<import("vue").ExtractPropTypes<import("vue").ComponentObjectPropsOptions<{
-        hideBlock: (hidden: boolean) => void;
-        appDefinitionId: string;
-        settings: AppInstanceRollupBlockSettings;
-        blockInstance: IBlockInstance<AppInstanceRollupBlockSettings>;
-        onFollowAppInstanceClicked: (appInstanceInfoUser: AppInstanceInfoUser) => void;
-    }>>>;
+    propsDefinition: Readonly<{} & {
+        settings?: AppInstanceRollupBlockSettings;
+        blockInstance?: IBlockInstance<AppInstanceRollupBlockSettings>;
+        appDefinitionId?: string;
+        onFollowAppInstanceClicked?: (appInstanceInfoUser: AppInstanceInfoUser) => void;
+        hideBlock?: (hidden: boolean) => void;
+    }>;
 };
 export default _default;