@omnia/fx 8.0.30-vnext → 8.0.32-vnext

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

@@ -1,12 +1,6 @@
-import { WebComponentBundleManifest } from "../../models";
+import { GuidValue, WebComponentBundleManifest } from "../../models";
 export interface IWebComponentInstance {
 }
-export interface IManifestMap {
-    [manifestId: string]: IConnectedWebComponent;
-}
-export interface IProxyOmniaServiceManifestMap {
-    [omniaServiceId: string]: IManifestMap;
-}
 export interface IWebComponentRegistrationHandler {
     (webComponentManifest: WebComponentBundleManifest): void;
 }
@@ -19,7 +13,7 @@ export interface IWebComponentInstanceContext {
     getManifest: () => WebComponentBundleManifest;
 }
 export declare class InternalWebComponentBootstrapper {
-    static registerElement: (omniaServiceId: string, manifestId: string, registrationHandler: IWebComponentRegistrationHandler) => void;
-    static registerElementInstance(omniaServiceId: string, manifestId: string, instanceHandler: IWebComponentInstance, htmlElement: HTMLElement): IWebComponentInstanceContext;
+    static registerElement: (omniaServiceId: GuidValue, manifestId: GuidValue, registrationHandler: IWebComponentRegistrationHandler) => void;
+    static registerElementInstance(omniaServiceId: GuidValue, manifestId: GuidValue, instanceHandler: IWebComponentInstance, htmlElement: HTMLElement): IWebComponentInstanceContext;
     private static getProxyForCaller;
 }

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

@@ -12,7 +12,7 @@ export declare class ManifestPublisher {
     private static ManifestsByType;
     private static Subscribers;
     private static LoadManifestsPromise;
-    private static loadManifestFromJson;
+    private static init;
     static subscribe: (subscriber: IManifestSubscriber) => Promise<Boolean>;
     private static setOmniaServiceManifests;
 }

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

@@ -38,7 +38,7 @@ export declare class ManifestResourceLoader {
     private static ReadyPromise;
     private Subscriber;
     private constructor();
-    static registerWebComponentFromGroupBundle: (omniaServiceId: string, groupableResourceManifestId: string, groupManifestId: string, initWebPackFunc: () => void) => void;
+    static registerWebComponentFromGroupBundle: (omniaServiceId: GuidValue, groupableResourceManifestId: GuidValue, groupManifestId: GuidValue, initWebPackFunc: () => void) => void;
     static ready: () => Future<void>;
     static getManifest: (omniaServiceId: GuidValue, manifestId: GuidValue) => LoadableBundleManifest;
     static getManifestById: (manifestId: GuidValue) => LoadableBundleManifest;
@@ -57,8 +57,8 @@ export declare class ManifestResourceLoader {
 export declare class WebpackModuleResoverInternal {
     private static resolveManifestResource;
     private static _omniaLoader;
-    static onLoadError(omniaServiceId: string, manifestId: string): void;
-    static resolve(omniaServiceId: string, manifestId: string): Future<void>;
+    static onLoadError(omniaServiceId: GuidValue, manifestId: GuidValue): void;
+    static resolve(omniaServiceId: GuidValue, manifestId: GuidValue): Future<void>;
     static isResolved(omniaServiceId: string, manifestId: string): boolean;
     private static ensureResolvablePromise;
     private static install;

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

@@ -16,12 +16,6 @@ export declare class ConnectedWebComponent implements IConnectedWebComponent {
     executeElementRegistration: () => void;
     addElementInstanceHandler: (instanceHandler: IWebComponentInstance, htmlElement: HTMLElement) => IWebComponentInstanceContext;
 }
-export interface IManifestMap {
-    [manifestId: string]: ConnectedWebComponent;
-}
-export interface IProxyOmniaServiceManifestMap {
-    [omniaServiceId: string]: IManifestMap;
-}
 export declare class PrivateBootstrapper {
     private static ProxyHolder;
     static newWebComponentProxy: (webComponentManifest: WebComponentBundleManifest) => ConnectedWebComponent;

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

@@ -8,8 +8,8 @@ export interface ExternallyLoadedGroupedManifest {
 }
 export declare class ServerSideLoader {
     private static serverLoaded;
-    static registerForLoading: (omniaServiceId: string, manifestId: string, groupedManifests: Array<ExternallyLoadedGroupedManifest>, type?: BundleTargetTypes) => void;
-    static groupLoadingRegistration: (omniaServiceId: string, groupableResourceManifestId: string, groupManifestId: string, registerFunc: () => void, webpackInitFunc: () => void) => void;
-    static isServerLoaded: (omniaServiceId: string, manifestId: string, type: BundleTargetTypes) => boolean;
-    static get: (omniaServiceId: string, manifestId: string, type: BundleTargetTypes) => IFromServerInstallable;
+    static registerForLoading: (omniaServiceId: GuidValue, manifestId: GuidValue, groupedManifests: Array<ExternallyLoadedGroupedManifest>, type?: BundleTargetTypes) => void;
+    static groupLoadingRegistration: (omniaServiceId: GuidValue, groupableResourceManifestId: GuidValue, groupManifestId: GuidValue, registerFunc: () => void, webpackInitFunc: () => void) => void;
+    static isServerLoaded: (omniaServiceId: GuidValue, manifestId: GuidValue, type: BundleTargetTypes) => boolean;
+    static get: (omniaServiceId: GuidValue, manifestId: GuidValue, type: BundleTargetTypes) => IFromServerInstallable;
 }

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

@@ -0,0 +1,3 @@
+export interface IEquals<T extends Object> {
+    equals: T;
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _equalsObject = {};
+Object.defineProperty(String.prototype, "equals", {
+    value: function () {
+        return _equalsObject;
+    },
+    writable: false,
+    configurable: false,
+    enumerable: false
+});

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

@@ -1,4 +1,7 @@
-export interface GuidValue {
+import { IEquals } from "./Equals";
+export interface GuidValue extends Partial<IEquals<{
+    guid(value: GuidValue): boolean;
+}>> {
     toString: () => string;
 }
 /**
@@ -6,10 +9,13 @@ export interface GuidValue {
  */
 export declare class Guid implements GuidValue {
     private static _empty;
+    private value;
+    equals: {
+        guid(value: GuidValue): boolean;
+    };
     static newGuid(): GuidValue;
     static get empty(): GuidValue;
     static isValid(guid: string | GuidValue): boolean;
-    private value;
     constructor(guid: string);
     toString(): string;
     toJSON: () => string;

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

@@ -4,6 +4,9 @@
 //}
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Guid = void 0;
+// export interface GuidValue {
+//     toString: () => string;
+// }
 /**
  * Class to create a guid
  */
@@ -26,7 +29,12 @@ class Guid {
         return validRegex.test(guid.toString());
     }
     constructor(guid) {
-        this.value = Guid._empty;
+        this.value = "";
+        this.equals = {
+            guid(value) {
+                return this.toString() === value.toString();
+            }
+        };
         //We serialize as string value
         this.toJSON = () => {
             return this.value.toLowerCase();
@@ -47,5 +55,18 @@ class Guid {
         return this.value.toLowerCase();
     }
 }
-Guid._empty = "00000000-0000-0000-0000-000000000000";
+Guid._empty = new Guid("00000000-0000-0000-0000-000000000000");
 exports.Guid = Guid;
+// only add extension methods when running in browser, not in node.js
+if (globalThis.omnia) {
+    Object.defineProperty(String.prototype["equals"], "guid", {
+        value: function () {
+            return function (value) {
+                return this.toString() === value.toString();
+            };
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+}

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

@@ -1,3 +1,4 @@
+export * from "./Equals";
 export * from "./Guid";
 export * from "./Broadcasting";
 export * from "./Topic";

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

@@ -2,6 +2,7 @@
 //! <omnia-transform-resource path="9a75501c-254b-46d1-9010-7b13681e06f4" />
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Equals"), exports);
 tslib_1.__exportStar(require("./Guid"), exports);
 tslib_1.__exportStar(require("./Broadcasting"), exports);
 tslib_1.__exportStar(require("./Topic"), exports);

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

@@ -1,5 +1,5 @@
-import { SpacingSettings } from "@omnia/fx-models";
 import { Guid } from "../Guid";
+import { SpacingSettings } from "./SpacingSetting";
 import { ColorSchemaType, ColorSchemaTypes } from "./ThemeDefinitionV2";
 import { TypographyDefinition } from "./TypographyDefinition";
 export interface BoxDimensions extends SpacingSettings {
@@ -13,11 +13,12 @@ export interface BluePrintDefinitions {
     variant2: BlueprintDefinition;
     variant3: BlueprintDefinition;
 }
-export type WebBlueprintDefintionType = "button" | "block" | "typography";
+export type WebBlueprintDefintionType = "button" | "block" | "typography" | "searchbox";
 export declare enum WebBlueprintDefintionTypes {
     button = "button",
     block = "block",
-    typography = "typography"
+    typography = "typography",
+    searchbox = "searchbox"
 }
 export type VelcronBlueprintDefintionType = "button" | "typography";
 export declare enum VelcronBlueprintDefintionTypes {
@@ -29,6 +30,7 @@ export interface BlueprintItemDefinition {
     type: any;
 }
 export interface BlockBlueprint extends BlueprintItemDefinition {
+    type: "block";
     header?: {
         definitionId: Guid;
     };
@@ -41,8 +43,14 @@ export interface BlockBlueprint extends BlueprintItemDefinition {
     };
 }
 export interface TypographyBlueprint extends BlueprintItemDefinition {
+    type: "typography";
     definition: TypographyDefinition;
 }
+export interface SearchBoxBlueprint extends BlueprintItemDefinition {
+    type: "searchbox";
+    borderRadius?: BoxDimensions;
+    variant?: "outlined" | "solo" | "regular" | "plain" | "underlined";
+}
 export interface BlueprintDefinition {
     id: Guid;
     definitions: Array<BlueprintItemDefinition>;

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

@@ -6,6 +6,7 @@ var WebBlueprintDefintionTypes;
     WebBlueprintDefintionTypes["button"] = "button";
     WebBlueprintDefintionTypes["block"] = "block";
     WebBlueprintDefintionTypes["typography"] = "typography";
+    WebBlueprintDefintionTypes["searchbox"] = "searchbox";
 })(WebBlueprintDefintionTypes = exports.WebBlueprintDefintionTypes || (exports.WebBlueprintDefintionTypes = {}));
 var VelcronBlueprintDefintionTypes;
 (function (VelcronBlueprintDefintionTypes) {

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

@@ -0,0 +1,6 @@
+export interface SpacingSettings {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -6,3 +6,4 @@ tslib_1.__exportStar(require("./TypographyDefinition"), exports);
 tslib_1.__exportStar(require("./OmniaThemes"), exports);
 tslib_1.__exportStar(require("./UseThemeMethods"), exports);
 tslib_1.__exportStar(require("./BlueprintDefinition"), exports);
+tslib_1.__exportStar(require("./SpacingSetting"), exports);

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

@@ -65,16 +65,14 @@ type VuetifyProps<T> = {
     } ? T["$props"][K] : never;
 };
 type VuetifySlots<T> = {
-    [K in keyof (T extends {
-        $slots?: any;
-    } ? T["$slots"] : T)]: T extends {
-        $slots?: any;
-    } ? T["$slots"][K] : never;
+    [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 } from "vuetify/components";
-import { VDataTable, VDataTableRow, VDataTableRows, VDataTableVirtual, VDataTableServer, VVirtualScroll } from "vuetify/labs/components";
-export type VDataTableServerSlots = VuetifySlots<Pick<VuetifyProps<Pick<VDataTableServer, "$props">>, "$slots">>;
-export type VDataTableSlots = VuetifySlots<Pick<VuetifyProps<Pick<VDataTable, "$props">>, "$slots">>;
+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";
+export interface VDataTableServerSlots extends VuetifySlots<VuetifyProps<Pick<VDataTableServer, "$props">>> {
+}
+export interface VDataTableSlots extends VuetifySlots<VuetifyProps<Pick<VDataTable, "$props">>> {
+}
 declare global {
     namespace JSX {
         interface Element {

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

@@ -62,7 +62,7 @@ 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>>(): {
+    slots<Slots extends Record<string, Slot | false>>(): {
         "v-slots": Prop<{
             default?: Func<[VNodeChild]>;
         } & Slots>;

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

@@ -1,5 +1,5 @@
-import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentPropsOptions, DefineComponent, ComponentObjectPropsOptions, Prop, VNodeChild, PropType, ObjectEmitsOptions, CreateComponentPublicInstance, ExtractPropTypes, ExtractDefaultPropTypes, ComponentOptionsBase, RenderFunction, VNode } from "vue";
-import { LooseRequired, UnionToIntersection } from "@vue/shared";
+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";
@@ -71,14 +71,6 @@ type ComponentOptionsWithArrayProps<PropNames extends string = string, RawBindin
 }> & EmitsToProps<E>> = ComponentOptionsBaseExtends<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, {}, I, II> & {
     props: PropNames[];
 } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, {}, false, I>>;
-type ExtractOptionProp<T> = T extends ComponentOptionsBase<infer P, // Props
-any, // RawBindings
-any, // D
-any, // C
-any, // M
-any, // Mixin
-any, // Extends
-any> ? unknown extends P ? {} : P : {};
 type Data = Record<string, unknown>;
 type InternalSlots = {
     [name: string]: (...args: any[]) => VNode[] | undefined;
@@ -87,6 +79,22 @@ 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]>;
+type OptionTypesKeys = "P" | "B" | "D" | "C" | "M" | "Defaults";
+type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Defaults = {}> = {
+    P: P;
+    B: B;
+    D: D;
+    C: C;
+    M: M;
+    Defaults: Defaults;
+};
+type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
+type ExtractMixin<T> = {
+    Mixin: MixinToOptionTypes<T>;
+}[T extends ComponentOptionsMixin ? "Mixin" : never];
+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 ? {
     attrs: Data;
     slots: Slots;
@@ -97,11 +105,11 @@ type SetupContext<Props, E = EmitsOptions> = E extends any ? {
     expose: (exposed?: Record<string, any>) => void;
 } : 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: Readonly<LooseRequired<ExcludeJsxPropKeys<Props> & UnionToIntersection<ExtractOptionProp<Mixin>> & UnionToIntersection<ExtractOptionProp<Extends>>>>, ctx: SetupContext<Props, E>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
+    setup?: (this: void, props: LooseRequired<ExcludeJsxPropKeys<Props> & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin> & IntersectionMixin<Extends>, "P">>>, ctx: SetupContext<Props, E>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
 }
 export declare function createPropType<T>(): PropType<T>;
 export declare function defineVue(): {
-    slots<Slots_1 extends Record<string, Slot<any[]>>>(): {
+    slots<Slots_1 extends Record<string, false | Slot<any[]>>>(): {
         "v-slots": Prop<{
             default?: import("@omnia/fx-models").Func<[VNodeChild]>;
         } & Slots_1>;
@@ -212,12 +220,32 @@ 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<{
@@ -226,7 +254,7 @@ export declare function defineVueWebComponent<PropNames extends string, RawBindi
     [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, register?: (manifest: WebComponentBundleManifest, component: any) => void): any;
+export declare function internalDefineVueWebComponent(omniaServiceId: any, manifestId: any, options: any, extraOptions?: any, register?: (manifest: WebComponentBundleManifest, component: any) => void): any;
 declare global {
     namespace JSX {
         interface IntrinsicAttributes {

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

@@ -169,9 +169,53 @@ export declare const VueComponentConnect: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
         $data: {};
-        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{
-            content: import("vue").Prop<() => JSX.Element, () => JSX.Element>;
-        }>> & VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            readonly content?: () => JSX.Element;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
         $attrs: {
             [x: string]: unknown;
         };
@@ -179,15 +223,15 @@ export declare const VueComponentConnect: {
             [x: string]: unknown;
         };
         $slots: Readonly<{
-            [name: string]: import("vue").Slot;
+            [name: string]: import("vue").Slot<any>;
         }>;
-        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
-        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $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<{
             content: import("vue").Prop<() => JSX.Element, () => JSX.Element>;
-        }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+        }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
             beforeMount?: (() => void) | (() => void)[];
@@ -202,7 +246,7 @@ export declare const VueComponentConnect: {
             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)[];
+            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;
@@ -215,7 +259,7 @@ export declare const VueComponentConnect: {
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     content: import("vue").Prop<() => JSX.Element, () => JSX.Element>;
-}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
         content?: () => JSX.Element;
     }>, never>;

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

@@ -1 +1,4 @@
-export {};
+import { ColorDefinition } from "../../velcron/core";
+export declare const AdminChromeStyles: {
+    wrapper: (color: ColorDefinition) => string;
+};

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

@@ -1,9 +1,53 @@
-import "./AdminChrome.css";
 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>;
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
         $attrs: {
             [x: string]: unknown;
         };
@@ -11,13 +55,13 @@ declare const _default: {
             [x: string]: unknown;
         };
         $slots: Readonly<{
-            [name: string]: import("vue").Slot;
+            [name: string]: import("vue").Slot<any>;
         }>;
-        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
-        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $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> & {
+        $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)[];
@@ -32,7 +76,7 @@ declare const _default: {
             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)[];
+            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;
@@ -41,7 +85,7 @@ declare const _default: {
     __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 & {
+} & 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: Omit<Readonly<{} & {}>, never>;
 };
 export default _default;