@omnia/fx 8.0.148-dev → 8.0.150-dev

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

@@ -1,7 +1,7 @@
 import { ITokenBasedRouteContext, TokenBasedRouteStateData, IMessageBusTopicSubscription, TokenBasedRoute, InstanceLifetimes } from "../models";
 import { SetupFactoryContext } from "@omnia/fx";
 interface SetupRouterContext extends SetupFactoryContext {
-    defineRoute: <T1 extends TokenBasedRoute, T2 extends TokenBasedRouteStateData>(buildContextPath: (routeContext: T1) => string, resolveRouteFromPath: (path: string) => T1) => InternalTokenRouter<T1, T2>;
+    defineRoute<T1 extends TokenBasedRoute, T2 extends TokenBasedRouteStateData>(buildContextPath: (routeContext: T1) => string, resolveRouteFromPath: (path: string) => T1): InternalTokenRouter<T1, T2>;
 }
 export declare function defineRouter<InferReturnSetup>(token: string, setup: (ctx: SetupRouterContext) => InferReturnSetup, lifeTime?: InstanceLifetimes): () => InferReturnSetup;
 export declare abstract class TokenBasedRouter<T1 extends TokenBasedRoute, T2 extends TokenBasedRouteStateData> {
@@ -14,7 +14,7 @@ export declare abstract class TokenBasedRouter<T1 extends TokenBasedRoute, T2 ex
     private readonly token;
     private _tokenExistsOnUrl;
     private _routeContext;
-    constructor(token: string);
+    constructor(token: string, autoResolveContext?: boolean);
     /**
      * Build the path base on the current context
      *
@@ -27,16 +27,18 @@ export declare abstract class TokenBasedRouter<T1 extends TokenBasedRoute, T2 ex
     protected protectedNavigate(title: string, route: T1, stateData?: T2, replaceState?: boolean): void;
     protected protectedClearRoute(): void;
     protected combinePathParts(...parts: string[]): string;
-    private resolveContext;
+    protected resolveContext(stateDataFromBrowserPopState?: T2): void;
     static getRouterUrl(): string;
     private static buildPath;
     private static resolveTokenBasedContext;
     private static ensureNoSlashAtTheBeginningAndTheEnd;
     private static init;
 }
-declare class InternalTokenRouter<T1 extends TokenBasedRoute, T2 extends TokenBasedRouteStateData> extends TokenBasedRouter<T1, TokenBasedRouteStateData> {
+declare class InternalTokenRouter<T1 extends TokenBasedRoute, T2 extends TokenBasedRouteStateData> extends TokenBasedRouter<T1, T2> {
     buildContextPath: (routeContext: T1) => string;
     resolveRouteFromPath: (path: string) => T1;
     constructor(token: string, buildContextPath: (routeContext: T1) => string, resolveRouteFromPath: (path: string) => T1);
+    clearRoute(): void;
+    navigate(title: string, context: T1, stateData?: T2): void;
 }
 export {};

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

@@ -713,6 +713,11 @@ export interface OmniaUxLocalization {
             Title: string;
             ConsentInformation: string;
         };
+        AnonymousAccessSetup: {
+            Category: string;
+            Description: string;
+            Title: string;
+        };
     };
     AuditLog: {
         Title: string;

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

@@ -20,7 +20,6 @@ declare class InternalAdminRouter extends TokenBasedRouter<AdminRoute, TokenBase
     * Override protected function logic
     */
     protected protectedClearRoute(): void;
-    updateRouteContext(context: AdminRoute): void;
     navigateRoot(title: string, manifestId: GuidValue, urlSegment?: string): void;
     navigatePath(title: string, path: string): void;
     clearRoute(): void;

package/internal-do-not-import-from-here/ux/journey/stores/JourneyRouterStore.d.ts

@@ -66,6 +66,6 @@ export declare const useJourneyRouterStore: () => {
         removeBlade(blade: JourneyBladeRouter): void;
     };
     events: {
-        onMutatedBlades: import("../../..").MessageBusExposeOnlySubscription<InternalJourneyBladeRouter[]>;
+        onMutatedBlades: import("@omnia/fx").MessageBusExposeOnlySubscription<InternalJourneyBladeRouter[]>;
     } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
 };

package/internal-do-not-import-from-here/ux/velcron/components/definitionpicker/VelcronDefinitionPicker.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue, IIcon, VelcronDefitinionRegistrationsTypes, VelcronState } from "@omnia/fx-models";
+import { GuidValue, IIcon, VelcronState } from "@omnia/fx-models";
 import { VNodeChild } from "vue";
 type Variant = "dialog" | "panel" | "editor" | "default";
 declare const _default: {
@@ -116,13 +116,13 @@ declare const _default: {
         colors?: any;
     }>> & {
         "onUpdate:modelValue"?: (value: boolean) => any;
-        onAdd?: (category: VelcronDefitinionRegistrationsTypes) => any;
+        onAdd?: () => any;
         onSelected?: (id: GuidValue) => any;
         "onDefinition:enter"?: (id: GuidValue) => any;
         "onDefinition:leave"?: (id: GuidValue) => any;
     }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
         selected: (id: GuidValue) => any;
-        add: (category: VelcronDefitinionRegistrationsTypes) => any;
+        add: () => any;
         "update:modelValue": (value: boolean) => any;
         "definition:enter": (id: GuidValue) => any;
         "definition:leave": (id: GuidValue) => any;
@@ -240,7 +240,7 @@ declare const _default: {
         colors?: any;
     }>> & {
         "onUpdate:modelValue"?: (value: boolean) => any;
-        onAdd?: (category: VelcronDefitinionRegistrationsTypes) => any;
+        onAdd?: () => any;
         onSelected?: (id: GuidValue) => any;
         "onDefinition:enter"?: (id: GuidValue) => any;
         "onDefinition:leave"?: (id: GuidValue) => any;
@@ -369,7 +369,7 @@ declare const _default: {
         colors?: any;
     }>> & {
         "onUpdate:modelValue"?: (value: boolean) => any;
-        onAdd?: (category: VelcronDefitinionRegistrationsTypes) => any;
+        onAdd?: () => any;
         onSelected?: (id: GuidValue) => any;
         "onDefinition:enter"?: (id: GuidValue) => any;
         "onDefinition:leave"?: (id: GuidValue) => any;
@@ -495,13 +495,13 @@ declare const _default: {
     colors?: any;
 }>> & {
     "onUpdate:modelValue"?: (value: boolean) => any;
-    onAdd?: (category: VelcronDefitinionRegistrationsTypes) => any;
+    onAdd?: () => any;
     onSelected?: (id: GuidValue) => any;
     "onDefinition:enter"?: (id: GuidValue) => any;
     "onDefinition:leave"?: (id: GuidValue) => any;
 }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     selected: (id: GuidValue) => any;
-    add: (category: VelcronDefitinionRegistrationsTypes) => any;
+    add: () => any;
     "update:modelValue": (value: boolean) => any;
     "definition:enter": (id: GuidValue) => any;
     "definition:leave": (id: GuidValue) => any;
@@ -595,7 +595,7 @@ declare const _default: {
         exclusions?: GuidValue[];
     }>, "onUpdate:modelValue" | "onAdd" | "onSelected" | "onDefinition:enter" | "onDefinition:leave"> & {
         "onUpdate:modelValue"?: (value: boolean) => any;
-        onAdd?: (category: VelcronDefitinionRegistrationsTypes) => any;
+        onAdd?: () => any;
         onSelected?: (id: GuidValue) => any;
         "onDefinition:enter"?: (id: GuidValue) => any;
         "onDefinition:leave"?: (id: GuidValue) => any;

package/internal-do-not-import-from-here/ux/velcron/core/models/VelcronDefinitions.d.ts

@@ -64,6 +64,7 @@ export interface VelcronRenderContext {
     eventHandlers?: VelcronRenderContextEventHandlersInstance;
     editMode?: boolean;
     disposers: Array<() => void>;
+    subApp?: boolean;
 }
 export interface VelcronRenderContextEventHandlers {
     receiving?: {
@@ -82,7 +83,8 @@ export interface VelcronRenderContextEventHandlersInstance extends VelcronRender
 export interface VelcronRenderContextHooks {
     dialogVisibilityChanged?: ((visible: boolean) => void);
     onItemSelected?: ((item: VelcronDefinition) => void);
-    wrapperStyleExtensions?: ((item: VelcronDefinition) => string);
+    wrapperStyleExtensions?: ((item: VelcronDefinition, renderContext: VelcronRenderContext) => string);
+    renderExtensions?: <TNodeType>(item: VelcronDefinition) => TNodeType;
     appStyleExtension?: (() => string);
     onItemCreatedProps?: ((item: VelcronDefinition) => object);
 }
@@ -179,7 +181,7 @@ export interface VelcronCardDefinition extends VelcronDefinition, VelcronColorSt
 }
 export interface VelcronTextDefinition extends VelcronDefinitionWithEditMode, VelcronColorStyling, VelcronTextStyling {
     type: "text";
-    value: VelcronBindableProp<string>;
+    value?: VelcronBindableProp<string>;
     placeholder?: VelcronBindableProp<string>;
     editLabel?: VelcronBindableProp;
     lineClamp?: number;

package/internal-do-not-import-from-here/ux/velcron/core/models/VelcronPropertyEditorDefinitions.d.ts

@@ -14,6 +14,7 @@ export interface BuiltInPropertyEditors {
     typography: unknown;
     spacing: unknown;
     "color-schema-type": unknown;
+    reference: unknown;
 }
 export declare enum BuiltInPropertyEditorTypes {
     text = "text",
@@ -82,6 +83,9 @@ export interface VelcronImagePropertyEditor extends VelcronPropertyEditor<any> {
 export interface VelcronSpacingPropertyEditor extends VelcronPropertyEditor<VelcronSpacingEditorSettings> {
     type: "spacing";
 }
+export interface VelcronReferencePropertyEditor extends VelcronPropertyEditor<any> {
+    type: "reference";
+}
 export interface VelcronState {
     images?: VelcronImagesState;
     styling?: VelcronStylingState;

package/internal-do-not-import-from-here/ux/velcron/editor/components/AddApp.d.ts

@@ -0,0 +1,51 @@
+declare const _default: (props: {} & Omit<{}, never> & {
+    "v-slots"?: {
+        default?: import("vue").Slot;
+    } & {};
+} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, never>) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, 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;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: {} & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, never>;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/components/AddComponent.d.ts

@@ -1,16 +1,51 @@
-declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>>, {}, true, {}, {}, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, {}>;
-    __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: Omit<Readonly<{} & {}>, never>;
-};
+declare const _default: (props: {} & Omit<{}, never> & {
+    "v-slots"?: {
+        default?: import("vue").Slot;
+    } & {};
+} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, never>) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, 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;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: {} & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, never>;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
 export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/components/AppExplorer.d.ts

@@ -1,16 +1,62 @@
-declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>>, {}, true, {}, {}, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, {}>;
-    __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: Omit<Readonly<{} & {}>, never>;
-};
+import { TreeViewItem } from "@omnia/fx-models";
+export declare const AppExplorerVariantDefinitions: readonly ["default", "statebind"];
+export type OAppExplorerVariants = typeof AppExplorerVariantDefinitions[number];
+declare const _default: (props: {
+    variant?: "default" | "statebind";
+} & Omit<{
+    "onItems:selected"?: (items: TreeViewItem<any>[]) => any;
+}, "variant"> & {
+    "v-slots"?: {
+        default?: import("vue").Slot;
+    } & {};
+} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "variant" | "emit:items:selected">) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, 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;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: {
+        variant?: "default" | "statebind";
+    } & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {
+        "onItems:selected"?: (items: TreeViewItem<any>[]) => any;
+    } & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "variant">;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
 export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/components/EditorCanvas.d.ts

@@ -0,0 +1,51 @@
+declare const _default: (props: {} & Omit<{}, never> & {
+    "v-slots"?: {
+        default?: import("vue").Slot;
+    } & {};
+} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, never>) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, 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;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: {} & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, never>;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/components/StateTree.d.ts

@@ -0,0 +1,63 @@
+import { VelcronDataTypes } from "@omnia/fx-models";
+import { VelcronComponentPropertyDescriptor } from "../models";
+declare const _default: (props: {
+    descriptor: VelcronComponentPropertyDescriptor;
+    allowedDataTypes?: VelcronDataTypes[];
+} & Omit<{
+    "onState:selected"?: (value: string) => any;
+}, "descriptor" | "allowedDataTypes"> & {
+    "v-slots"?: {
+        default?: import("vue").Slot;
+    } & {};
+} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "descriptor" | "allowedDataTypes" | "emit:state:selected">) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, 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;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: {
+        descriptor: VelcronComponentPropertyDescriptor;
+        allowedDataTypes?: VelcronDataTypes[];
+    } & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {
+        "onState:selected"?: (value: string) => any;
+    } & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "descriptor" | "allowedDataTypes">;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/components/panels/edit-component/PropertiesPanel.d.ts

@@ -1,16 +1,16 @@
 declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, () => (JSX.Element | JSX.Element[])[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>>, {}, true, {}, {}, {
+    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>>, {}, true, {}, {}, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{}>>, () => (JSX.Element | JSX.Element[])[], {}, {}, {}, {}>;
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, {}>;
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => (JSX.Element | 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;

package/internal-do-not-import-from-here/ux/velcron/editor/models/BuiltInDescriptors.d.ts

@@ -35,3 +35,4 @@ export declare const VelcronDialogComponentDescriptor: VelcronComponentDescripto
 export declare const VelcronIconComponentDescriptor: VelcronComponentDescriptor;
 export declare const VelcronChipComponentDescriptor: VelcronComponentDescriptor;
 export declare const VelcronMarkdownComponentDescriptor: VelcronComponentDescriptor;
+export declare const VelcronReferenceComponentDescriptor: VelcronComponentDescriptor;

package/internal-do-not-import-from-here/ux/velcron/editor/models/Enums.d.ts

@@ -4,3 +4,8 @@ export declare enum VelcronDescriptorTypes {
     appData = 2,
     dataMember = 3
 }
+export type AddVelcronComponentInsertionStrategy = "default" | "before" | "after" | "createnew";
+export type AddVelcronComponentMode = {
+    show: boolean;
+    strategy?: AddVelcronComponentInsertionStrategy;
+};

package/internal-do-not-import-from-here/ux/velcron/editor/models/VelcronDescriptors.d.ts

@@ -1,6 +1,6 @@
 import { IIcon, VelcronPropertyEditor } from "@omnia/fx-models";
 import { VelcronDataTypes } from "../../core/models/Enums";
-import { VelcroncomponentArrayType, VelcronPrimitiveType } from "../../core/models/VelcronTypes";
+import { VelcroncomponentArrayType, VelcronObjectType, VelcronPrimitiveType } from "../../core/models/VelcronTypes";
 import { VelcronDescriptorTypes } from "./Enums";
 export interface VelcronDescriptor {
     descriptorType: VelcronDescriptorTypes;
@@ -24,7 +24,7 @@ export interface VelcronComponentPropertyDescriptor {
     group?: string;
     editor?: VelcronPropertyEditor<any>;
     required?: boolean;
-    defaultValue?: VelcronPrimitiveType | VelcroncomponentArrayType;
+    defaultValue?: VelcronPrimitiveType | VelcroncomponentArrayType | VelcronObjectType<{}>;
     disableRemovePropertyOnEmptyOrFalse?: boolean;
     label?: string;
 }

package/internal-do-not-import-from-here/ux/velcron/editor/stores/VelcronEditorStore.d.ts

@@ -1,8 +1,16 @@
 import { TreeViewItem, VelcronAppDefinition, VelcronDefinition } from "@omnia/fx-models";
 import { AppTreeItem, AppValidationState, editorModes } from "../models/Shared";
-import { CodeEditorState, VelcronComponentDescriptor, codeEditorTabs } from "../models";
+import { CodeEditorState, VelcronComponentDescriptor, codeEditorTabs, AddVelcronComponentMode } from "../models";
+import { ThemeDefinitionV2, VelcronRenderContext } from "../../core";
+type canvasMode = "split-spacing" | "design";
 export declare const useVelcronEditorStore: () => {
+    get: {
+        getBodyTreeviewItem(): TreeViewItem<any>;
+    };
     state: {
+        previewTheme: ThemeDefinitionV2;
+        previewRenderContext: VelcronRenderContext;
+        canvasMode: canvasMode;
         appData: {};
         appAsJson: string;
         appDefinition: VelcronAppDefinition<object>;
@@ -12,8 +20,10 @@ export declare const useVelcronEditorStore: () => {
         selectedAppTreeItem: TreeViewItem<AppTreeItem>;
         editorMode: editorModes;
         activeAppTreeItem: TreeViewItem<any>;
+        itemToCopy: TreeViewItem<AppTreeItem>;
         history: string[];
-        showAddComponent: boolean;
+        showAddComponent: AddVelcronComponentMode;
+        showAddApp: boolean;
         showAddDataObject: boolean;
         showShare: boolean;
         codeEditor: CodeEditorState;
@@ -52,7 +62,7 @@ export declare const useVelcronEditorStore: () => {
                 subscribe(fn: (key: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             showAddComponent: {
-                subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (mode: AddVelcronComponentMode) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             showShare: {
                 subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -61,7 +71,10 @@ export declare const useVelcronEditorStore: () => {
                 subscribe(fn: (show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             addComponent: {
-                subscribe(fn: (descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition, insertOptions?: {
+                    beforeKey?: string;
+                    afterKey?: string;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             deleteComponent: {
                 subscribe(fn: (target: TreeViewItem<AppTreeItem>) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -81,8 +94,11 @@ export declare const useVelcronEditorStore: () => {
             setActiveAppTreeItem: {
                 subscribe(fn: (key: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
+            copyComponent: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
             pasteComponent: {
-                subscribe(fn: (target: AppTreeItem) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             reloadApp: {
                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -120,7 +136,7 @@ export declare const useVelcronEditorStore: () => {
                 subscribe(fn: (result: void, key: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             showAddComponent: {
-                subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (result: void, mode: AddVelcronComponentMode) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             showShare: {
                 subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -129,7 +145,10 @@ export declare const useVelcronEditorStore: () => {
                 subscribe(fn: (result: void, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             addComponent: {
-                subscribe(fn: (result: void, descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (result: void, descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition, insertOptions?: {
+                    beforeKey?: string;
+                    afterKey?: string;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             deleteComponent: {
                 subscribe(fn: (result: void, target: TreeViewItem<AppTreeItem>) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -149,8 +168,11 @@ export declare const useVelcronEditorStore: () => {
             setActiveAppTreeItem: {
                 subscribe(fn: (result: void, key: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
+            copyComponent: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
             pasteComponent: {
-                subscribe(fn: (result: void, target: AppTreeItem) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             reloadApp: {
                 subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -188,7 +210,7 @@ export declare const useVelcronEditorStore: () => {
                 subscribe(fn: (failureReason: any, key: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             showAddComponent: {
-                subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (failureReason: any, mode: AddVelcronComponentMode) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             showShare: {
                 subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -197,7 +219,10 @@ export declare const useVelcronEditorStore: () => {
                 subscribe(fn: (failureReason: any, show: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             addComponent: {
-                subscribe(fn: (failureReason: any, descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (failureReason: any, descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition, insertOptions?: {
+                    beforeKey?: string;
+                    afterKey?: string;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             deleteComponent: {
                 subscribe(fn: (failureReason: any, target: TreeViewItem<AppTreeItem>) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -217,8 +242,11 @@ export declare const useVelcronEditorStore: () => {
             setActiveAppTreeItem: {
                 subscribe(fn: (failureReason: any, key: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
+            copyComponent: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
             pasteComponent: {
-                subscribe(fn: (failureReason: any, target: AppTreeItem) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             reloadApp: {
                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -237,21 +265,28 @@ export declare const useVelcronEditorStore: () => {
         setEditorMode(newState: editorModes): void;
         syncState(): void;
         setSelectedAppTreeItem(key: string): void;
-        showAddComponent(show: boolean): void;
+        showAddComponent(mode: AddVelcronComponentMode): void;
         showShare(show: boolean): void;
         showAddDataObject(show: boolean): void;
-        addComponent(descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition): void;
+        addComponent(descriptor: VelcronComponentDescriptor, parent?: TreeViewItem<AppTreeItem>, definition?: VelcronDefinition, insertOptions?: {
+            beforeKey?: string;
+            afterKey?: string;
+        }): void;
         deleteComponent(target: TreeViewItem<AppTreeItem>): void;
         addDataMember(target: TreeViewItem<AppTreeItem>, propertyName: string, value: any): void;
         deleteDataMember(target: TreeViewItem<AppTreeItem>): void;
         renameDataMember(target: TreeViewItem<AppTreeItem>, newName: string): void;
         updateDataMemberValue(target: TreeViewItem<AppTreeItem>, newValue: any): void;
         setActiveAppTreeItem(key: string): void;
-        pasteComponent(target: AppTreeItem): void;
+        copyComponent(): void;
+        pasteComponent(): void;
         reloadApp(): void;
         updateHistory(): void;
     };
     events: {
+        onMutatedPreviewTheme: import("@omnia/fx").MessageBusExposeOnlySubscription<ThemeDefinitionV2>;
+        onMutatedPreviewRenderContext: import("@omnia/fx").MessageBusExposeOnlySubscription<VelcronRenderContext>;
+        onMutatedCanvasMode: import("@omnia/fx").MessageBusExposeOnlySubscription<canvasMode>;
         onMutatedAppData: import("@omnia/fx").MessageBusExposeOnlySubscription<{}>;
         onMutatedAppAsJson: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
         onMutatedAppDefinition: import("@omnia/fx").MessageBusExposeOnlySubscription<VelcronAppDefinition<object>>;
@@ -261,8 +296,10 @@ export declare const useVelcronEditorStore: () => {
         onMutatedSelectedAppTreeItem: import("@omnia/fx").MessageBusExposeOnlySubscription<TreeViewItem<AppTreeItem>>;
         onMutatedEditorMode: import("@omnia/fx").MessageBusExposeOnlySubscription<editorModes>;
         onMutatedActiveAppTreeItem: import("@omnia/fx").MessageBusExposeOnlySubscription<TreeViewItem<any>>;
+        onMutatedItemToCopy: import("@omnia/fx").MessageBusExposeOnlySubscription<TreeViewItem<AppTreeItem>>;
         onMutatedHistory: import("@omnia/fx").MessageBusExposeOnlySubscription<string[]>;
-        onMutatedShowAddComponent: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedShowAddComponent: import("@omnia/fx").MessageBusExposeOnlySubscription<AddVelcronComponentMode>;
+        onMutatedShowAddApp: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedShowAddDataObject: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedShowShare: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedCodeEditor: import("@omnia/fx").MessageBusExposeOnlySubscription<CodeEditorState>;
@@ -272,3 +309,4 @@ export declare const useVelcronEditorStore: () => {
         }>;
     } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
 };
+export {};

package/internal-do-not-import-from-here/ux/velcron/renderer/propertyeditors/ReferenceEditor.d.ts

@@ -0,0 +1,62 @@
+import { VelcronRendererResolverReference } from "@omnia/fx-models";
+declare const _default: (props: {
+    label?: string;
+    "v-model"?: VelcronRendererResolverReference;
+    "onUpdate:modelValue"?: (value: VelcronRendererResolverReference) => void;
+    modelValue?: VelcronRendererResolverReference;
+} & Omit<{}, "label" | "v-model" | "onUpdate:modelValue" | "modelValue"> & {
+    "v-slots"?: {
+        default?: import("vue").Slot;
+    } & {};
+} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "label" | "v-model" | "onUpdate:modelValue" | "modelValue">) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, 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;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: {
+        label?: string;
+        "v-model"?: VelcronRendererResolverReference;
+        "onUpdate:modelValue"?: (value: VelcronRendererResolverReference) => void;
+        modelValue?: VelcronRendererResolverReference;
+    } & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "label" | "v-model" | "onUpdate:modelValue" | "modelValue">;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export default _default;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx",
   "license": "MIT",
-  "version": "8.0.148-dev",
+  "version": "8.0.150-dev",
   "description": "Provide Omnia Fx typings and tooling for clientside Omnia development.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -20,7 +20,7 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "8.0.148-dev",
+    "@omnia/fx-models": "8.0.150-dev",
     "@microsoft/signalr": "6.0.1",
     "broadcast-channel": "4.8.0",
     "dayjs": "1.11.7",