@omnia/fx 8.0.7-vnext → 8.0.9-vnext

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

@@ -1,30 +1,30 @@
 import { Guid } from "../Guid";
 export interface TypographyDefinition {
     id: Guid;
-    h1: TypographyType;
-    h2: TypographyType;
-    h3: TypographyType;
-    text: TypographyType;
-    caption: TypographyType;
-    link: TypographyType;
+    h1: TypographyTypeDefinition;
+    h2: TypographyTypeDefinition;
+    h3: TypographyTypeDefinition;
+    text: TypographyTypeDefinition;
+    caption: TypographyTypeDefinition;
+    link: TypographyTypeDefinition;
 }
-export interface TypographyType {
+export interface TypographyTypeDefinition {
     decoration?: string;
     large: TypographyTypeBreakPoint;
     medium?: TypographyTypeBreakPoint;
     small?: TypographyTypeBreakPoint;
-    style: object | string;
 }
 export interface TypographyTypeBreakPoint {
     weight: number;
     size: number;
     lineHeight: number;
 }
-export declare const TypographyTypes: {
-    h1: string;
-    h2: string;
-    h3: string;
-    text: string;
-    caption: string;
-    link: string;
-};
+export type TypographyType = TypographyTypes.h1 | TypographyTypes.h2 | TypographyTypes.h3 | TypographyTypes.text | TypographyTypes.caption | TypographyTypes.link;
+export declare enum TypographyTypes {
+    h1 = "h1",
+    h2 = "h2",
+    h3 = "h3",
+    text = "text",
+    caption = "caption",
+    link = "link"
+}

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/UseThemeMethods.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useThemeMethods = void 0;
+const ThemeDefinitionV2_1 = require("./ThemeDefinitionV2");
+const TypographyDefinition_1 = require("./TypographyDefinition");
+const useThemeMethods = (themedefinition) => {
+    const colorSchema = (colorSchemaType) => {
+        if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.primary) {
+            return themedefinition.primary;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.secondary) {
+            return themedefinition.secondary;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent1) {
+            return themedefinition.accent1;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent2) {
+            return themedefinition.accent2;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.accent3) {
+            return themedefinition.accent3;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.background) {
+            return themedefinition.background;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.neutral) {
+            return themedefinition.neutral;
+        }
+        else if (colorSchemaType === ThemeDefinitionV2_1.ColorSchemaTypes.error) {
+            return themedefinition.error;
+        }
+        return themedefinition.background;
+    };
+    const typography = (typographyType) => {
+        if (typographyType === TypographyDefinition_1.TypographyTypes.h1) {
+            return themedefinition.typography.h1;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.h2) {
+            return themedefinition.typography.h2;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.h3) {
+            return themedefinition.typography.h3;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.caption) {
+            return themedefinition.typography.caption;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.link) {
+            return themedefinition.typography.link;
+        }
+        else if (typographyType === TypographyDefinition_1.TypographyTypes.text) {
+            return themedefinition.typography.text;
+        }
+        return themedefinition.typography.text;
+    };
+    const color = (colorSchemaType, colorType) => {
+        const mappedColorSchema = colorSchema(colorSchemaType);
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base) {
+            return mappedColorSchema.base.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.baseTone) {
+            return mappedColorSchema.base.colorToned;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase) {
+            return mappedColorSchema.onBase.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBaseTone) {
+            return mappedColorSchema.onBase.colorToned;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container) {
+            return mappedColorSchema.container.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.containerTone) {
+            return mappedColorSchema.container.colorToned;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer) {
+            return mappedColorSchema.onContainer.color;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainerTone) {
+            return mappedColorSchema.onContainer.colorToned;
+        }
+        return colorType;
+    };
+    const colorDefinition = (colorSchemaType, colorType) => {
+        const mappedColorSchema = colorSchema(colorSchemaType);
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base
+            || colorType === ThemeDefinitionV2_1.ColorTypes.baseTone) {
+            return mappedColorSchema.base;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase
+            ||
+                colorType === ThemeDefinitionV2_1.ColorTypes.onBaseTone) {
+            return mappedColorSchema.onBase;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container
+            ||
+                colorType === ThemeDefinitionV2_1.ColorTypes.containerTone) {
+            return mappedColorSchema.container;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer
+            ||
+                colorType === ThemeDefinitionV2_1.ColorTypes.onContainerTone) {
+            return mappedColorSchema.onContainer;
+        }
+        return mappedColorSchema.base;
+    };
+    const complementaryColorType = (colorType) => {
+        if (colorType === ThemeDefinitionV2_1.ColorTypes.base
+            || colorType === ThemeDefinitionV2_1.ColorTypes.baseTone) {
+            return ThemeDefinitionV2_1.ColorTypes.onBase;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onBase
+            || colorType === ThemeDefinitionV2_1.ColorTypes.onBaseTone) {
+            return ThemeDefinitionV2_1.ColorTypes.base;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.container
+            || colorType === ThemeDefinitionV2_1.ColorTypes.containerTone) {
+            return ThemeDefinitionV2_1.ColorTypes.onContainer;
+        }
+        else if (colorType === ThemeDefinitionV2_1.ColorTypes.onContainer
+            || colorType === ThemeDefinitionV2_1.ColorTypes.onContainerTone) {
+            return ThemeDefinitionV2_1.ColorTypes.container;
+        }
+        return colorType;
+    };
+    const complementaryColor = (colorSchemaType, colorType) => {
+        const matchingColorType = complementaryColorType(colorType);
+        return color(colorSchemaType, matchingColorType);
+    };
+    const complementaryColorDefinition = (colorSchemaType, colorType) => {
+        const matchingColorType = complementaryColorType(colorType);
+        return colorDefinition(colorSchemaType, matchingColorType);
+    };
+    return {
+        colorSchema,
+        typography,
+        color,
+        colorDefinition,
+        complementaryColorType,
+        complementaryColor,
+        complementaryColorDefinition,
+    };
+};
+exports.useThemeMethods = useThemeMethods;

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

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

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

@@ -4,3 +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("./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";