@omnia/fx 8.0.216-dev → 8.0.219-dev

package/internal-do-not-import-from-here/ux/velcron/components/contenteditorNew/VelcronContentRenderer.d.ts

@@ -0,0 +1,80 @@
+import { DynamicState, ThemeDefinitionV2, VelcronSectionInstance } from "@omnia/fx-models";
+import { EditorRenderingHooks } from "./models";
+export interface ContentEditorVelcronState extends DynamicState {
+    content: {
+        [id: string]: unknown;
+    };
+}
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
+        sections: {
+            type: import("vue").PropType<VelcronSectionInstance[]>;
+        };
+        editMode: {
+            type: import("vue").PropType<boolean>;
+        };
+        themeDefinition: {
+            type: import("vue").PropType<ThemeDefinitionV2>;
+        };
+        hooks: {
+            type: import("vue").PropType<EditorRenderingHooks>;
+        };
+    }>>, () => JSX.Element[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
+        sections: {
+            type: import("vue").PropType<VelcronSectionInstance[]>;
+        };
+        editMode: {
+            type: import("vue").PropType<boolean>;
+        };
+        themeDefinition: {
+            type: import("vue").PropType<ThemeDefinitionV2>;
+        };
+        hooks: {
+            type: import("vue").PropType<EditorRenderingHooks>;
+        };
+    }>>, {}, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        sections: {
+            type: import("vue").PropType<VelcronSectionInstance[]>;
+        };
+        editMode: {
+            type: import("vue").PropType<boolean>;
+        };
+        themeDefinition: {
+            type: import("vue").PropType<ThemeDefinitionV2>;
+        };
+        hooks: {
+            type: import("vue").PropType<EditorRenderingHooks>;
+        };
+    }>>, () => JSX.Element[], {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    sections: {
+        type: import("vue").PropType<VelcronSectionInstance[]>;
+    };
+    editMode: {
+        type: import("vue").PropType<boolean>;
+    };
+    themeDefinition: {
+        type: import("vue").PropType<ThemeDefinitionV2>;
+    };
+    hooks: {
+        type: import("vue").PropType<EditorRenderingHooks>;
+    };
+}>>, () => JSX.Element[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        themeDefinition?: ThemeDefinitionV2;
+        editMode?: boolean;
+        hooks?: EditorRenderingHooks;
+        sections?: VelcronSectionInstance[];
+    }>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/components/contenteditorNew/components/BorderSelector copy.d.ts

@@ -0,0 +1,60 @@
+import { VelcronSectionInstance } from "@omnia/fx-models";
+declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
+    "v-model"?: VelcronSectionInstance;
+} & {
+    "onUpdate:modelValue"?: (value: VelcronSectionInstance) => void;
+} & {
+    modelValue?: VelcronSectionInstance;
+}>) => {
+    $: 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: import("@omnia/fx/ux").ExtractProps<{
+        "v-model"?: VelcronSectionInstance;
+    } & {
+        "onUpdate:modelValue"?: (value: VelcronSectionInstance) => void;
+    } & {
+        modelValue?: VelcronSectionInstance;
+    }> & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "v-model" | "onUpdate:modelValue" | "modelValue">;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/components/contenteditorNew/components/BorderSelector.css.d.ts

@@ -3,6 +3,7 @@ export declare const BorderSelectorStyles: {
     spacingPickerInner: string;
     spacingSeparator: string;
     spacingBackground: (selected: Boolean) => string;
+    actionButtonContainer: string;
     commonStyles: string;
     topSpacing: string;
     bottomSpacing: string;

package/internal-do-not-import-from-here/ux/velcron/components/contenteditorNew/components/DefinitionToolbar copy.d.ts

@@ -0,0 +1,65 @@
+import { VelcronSectionInstance } from "@omnia/fx-models";
+type ToolbarVariant = "default" | "reference";
+declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
+    "v-model"?: VelcronSectionInstance;
+} & {
+    "onUpdate:modelValue"?: (value: VelcronSectionInstance) => void;
+} & {
+    modelValue?: VelcronSectionInstance;
+} & {
+    variant?: ToolbarVariant;
+}>) => {
+    $: 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: import("@omnia/fx/ux").ExtractProps<{
+        "v-model"?: VelcronSectionInstance;
+    } & {
+        "onUpdate:modelValue"?: (value: VelcronSectionInstance) => void;
+    } & {
+        modelValue?: VelcronSectionInstance;
+    } & {
+        variant?: ToolbarVariant;
+    }> & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "v-model" | "onUpdate:modelValue" | "modelValue" | "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/components/contenteditorNew/components/DefinitionToolbar.css.d.ts

@@ -1,3 +1,4 @@
 export declare const DefinitionToolbarStyles: {
+    wrapper: string;
     overlay: string;
 };

package/internal-do-not-import-from-here/ux/velcron/components/contenteditorNew/models/EditorRenderingHooks.d.ts

@@ -14,4 +14,11 @@ export interface EditorRenderingHooks {
         renderExtensions?: (item: VelcronDefinition, renderContext: VelcronRenderContext) => VNodeChild;
         onItemSelected?: (item: VelcronDefinition, renderContext: VelcronRenderContext) => void;
     };
+    item?: {
+        onItemClicked?: (item: VelcronSectionInstance) => void;
+        onItemDblClicked?: (item: VelcronSectionInstance) => void;
+        onMouseenter?: (item: VelcronSectionInstance) => void;
+        onMouseleave?: (item: VelcronSectionInstance) => void;
+        isActive?: (item: VelcronSectionInstance) => boolean;
+    };
 }

package/internal-do-not-import-from-here/ux/velcron/components/contenteditorNew/stores/ContentEditorStore.d.ts

@@ -1,5 +1,13 @@
-import { VelcronAppDefinition, VelcronDefinition, VelcronDefinitionRegistration, ContainerBlueprint, ContainerVariant, VelcronSectionInstance, guid } from "@omnia/fx-models";
-type insertMode = "add" | "change";
+import { VelcronAppDefinition, VelcronDefinition, VelcronDefinitionRegistration, ContainerBlueprint, ContainerVariant, VelcronSectionInstance, guid, BorderSelectorActionRegistration } from "@omnia/fx-models";
+type InsertMode = "add" | "change";
+export interface InsertOptions {
+    preInsert?: boolean;
+    inserRelativeToActive?: boolean;
+    insertMode: InsertMode;
+}
+export interface DefinitionSelecttionOptions {
+    categoryFilters?: Array<guid>;
+}
 export declare const useVelcronContentEditorStore: () => {
     get: {
         contentAsVelcron: () => VelcronAppDefinition<object>[];
@@ -18,15 +26,15 @@ export declare const useVelcronContentEditorStore: () => {
         toggleContainerBlueprintPreview: ContainerVariant | ContainerBlueprint;
         toggleDefinitionPreview: VelcronDefinition;
         showOverlay: boolean;
+        borderSelectorActions: BorderSelectorActionRegistration[];
         allowPreviewToggle: boolean;
         onGoingDragging: boolean;
         socialMode: boolean;
         showLoading: boolean;
-        showDefinitionSelector: boolean;
-        insertOptions: {
-            preInsert: boolean;
-            inserRelativeToActive: boolean;
-            insertMode: insertMode;
+        definitionSelector: {
+            show: boolean;
+            options: DefinitionSelecttionOptions;
+            insertOptions: InsertOptions;
         };
     };
     events: {
@@ -42,235 +50,159 @@ export declare const useVelcronContentEditorStore: () => {
         onMutatedToggleContainerBlueprintPreview: import("@omnia/fx").MessageBusExposeOnlySubscription<ContainerVariant | ContainerBlueprint>;
         onMutatedToggleDefinitionPreview: import("@omnia/fx").MessageBusExposeOnlySubscription<VelcronDefinition>;
         onMutatedShowOverlay: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+        onMutatedBorderSelectorActions: import("@omnia/fx").MessageBusExposeOnlySubscription<BorderSelectorActionRegistration[]>;
         onMutatedAllowPreviewToggle: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedOnGoingDragging: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedSocialMode: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
         onMutatedShowLoading: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
-        onMutatedShowDefinitionSelector: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
-        onMutatedInsertOptions: import("@omnia/fx").MessageBusExposeOnlySubscription<{
-            preInsert: boolean;
-            inserRelativeToActive: boolean;
-            insertMode: insertMode;
+        onMutatedDefinitionSelector: import("@omnia/fx").MessageBusExposeOnlySubscription<{
+            show: boolean;
+            options: DefinitionSelecttionOptions;
+            insertOptions: InsertOptions;
         }>;
     } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
     actions: {
         onDispatching: {
-            setCategoryFilters: {
-                subscribe(fn: (filters: guid[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setRendererTypeFilters: {
-                subscribe(fn: (filters: guid[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setFixedContentWidth: {
-                subscribe(fn: (width: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            showDefinitionSelector: {
-                subscribe(fn: (preInsert: boolean, insertRelativeToActive?: boolean, changeDefinition?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            updateSection: {
-                subscribe(fn: (section: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            toggleEditorToolbar: {
-                subscribe(fn: (forceHide?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            addByRegistration: {
-                subscribe(fn: (definition: VelcronDefinitionRegistration<object>, setAsActive?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            addBySection: {
-                subscribe(fn: (definitions: VelcronSectionInstance[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setActiveDefinition: {
-                subscribe(fn: (definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            deleteDefinition: {
-                subscribe(fn: (definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            deleteReferenceDefinition: {
-                subscribe(fn: (definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            removeActiveDefinition: {
+            selectorActions: {
                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            setSelectedDefinition: {
-                subscribe(fn: (definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            removeSelectedDefinition: {
+            filters: {
                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            setDragDropState: {
-                subscribe(fn: (onGoingDragging: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            updateColorSchema: {
-                subscribe(fn: (definitionRegistration: VelcronSectionInstance, colorSchemaType: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            previewContainerBlueprint: {
-                subscribe(fn: (definitionRegistration: VelcronSectionInstance, containerVariant: ContainerVariant | ContainerBlueprint, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            settings: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            previewColorSchema: {
-                subscribe(fn: (definitionRegistration: VelcronSectionInstance, colorSchemaType: string, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            editor: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            previewDefinition: {
-                subscribe(fn: (definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            section: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            changeDefinition: {
-                subscribe(fn: (definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, toggle?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            definition: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            updateDefinition: {
-                subscribe(fn: (definition: VelcronSectionInstance, velcronDefinition: VelcronAppDefinition<object>) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            preview: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
         };
         onDispatched: {
-            setCategoryFilters: {
-                subscribe(fn: (result: void, filters: guid[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setRendererTypeFilters: {
-                subscribe(fn: (result: void, filters: guid[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setFixedContentWidth: {
-                subscribe(fn: (result: void, width: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            showDefinitionSelector: {
-                subscribe(fn: (result: void, preInsert: boolean, insertRelativeToActive?: boolean, changeDefinition?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            updateSection: {
-                subscribe(fn: (result: void, section: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            toggleEditorToolbar: {
-                subscribe(fn: (result: void, forceHide?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            addByRegistration: {
-                subscribe(fn: (result: void, definition: VelcronDefinitionRegistration<object>, setAsActive?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            addBySection: {
-                subscribe(fn: (result: void, definitions: VelcronSectionInstance[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setActiveDefinition: {
-                subscribe(fn: (result: void, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            deleteDefinition: {
-                subscribe(fn: (result: void, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            deleteReferenceDefinition: {
-                subscribe(fn: (result: any, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            removeActiveDefinition: {
-                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setSelectedDefinition: {
-                subscribe(fn: (result: void, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            removeSelectedDefinition: {
-                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setDragDropState: {
-                subscribe(fn: (result: void, onGoingDragging: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            updateColorSchema: {
-                subscribe(fn: (result: void, definitionRegistration: VelcronSectionInstance, colorSchemaType: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            previewContainerBlueprint: {
-                subscribe(fn: (result: void, definitionRegistration: VelcronSectionInstance, containerVariant: ContainerVariant | ContainerBlueprint, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            previewColorSchema: {
-                subscribe(fn: (result: void, definitionRegistration: VelcronSectionInstance, colorSchemaType: string, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            previewDefinition: {
-                subscribe(fn: (result: void, definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            changeDefinition: {
-                subscribe(fn: (result: void, definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, toggle?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            updateDefinition: {
-                subscribe(fn: (result: void, definition: VelcronSectionInstance, velcronDefinition: VelcronAppDefinition<object>) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            selectorActions: {
+                subscribe(fn: (result: {
+                    hideDefaultSelector: () => void;
+                    remove: (id: guid) => void;
+                    add: (action: BorderSelectorActionRegistration | Array<BorderSelectorActionRegistration>) => void;
+                    run: (action: BorderSelectorActionRegistration, options: InsertOptions) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            filters: {
+                subscribe(fn: (result: {
+                    setRendererTypeFilters: (filters: Array<guid>) => void;
+                    setCategoryFilters: (filters: Array<guid>) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            settings: {
+                subscribe(fn: (result: {
+                    setFixedContentWidth: (width: string) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            editor: {
+                subscribe(fn: (result: {
+                    showDefinitionSelector: (insertOptions: InsertOptions, selectionOptions?: DefinitionSelecttionOptions) => void;
+                    toggleEditorToolbar: (forceHide?: boolean) => void;
+                    setActiveDefinition: (definition: VelcronSectionInstance) => void;
+                    removeActiveDefinition: () => void;
+                    setSelectedDefinition: (definition: VelcronSectionInstance) => void;
+                    removeSelectedDefinition: () => void;
+                    setDragDropState: (onGoingDragging: boolean) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            section: {
+                subscribe(fn: (result: {
+                    update: (section: VelcronSectionInstance) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            definition: {
+                subscribe(fn: (result: {
+                    updateColorSchema: (definitionRegistration: VelcronSectionInstance, colorSchemaType: string) => void;
+                    addByRegistration: (definition: VelcronDefinitionRegistration, insertOptions: InsertOptions, setAsActive?: boolean) => VelcronSectionInstance;
+                    addBySection: (definitions: Array<VelcronSectionInstance>) => void;
+                    delete: (definition: VelcronSectionInstance) => void;
+                    deleteReference: (definition: VelcronSectionInstance) => any;
+                    change: (definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, toggle?: boolean) => VelcronSectionInstance;
+                    update: (definition: VelcronSectionInstance, velcronDefinition: VelcronAppDefinition) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            preview: {
+                subscribe(fn: (result: {
+                    containerBlueprint: (definitionRegistration: VelcronSectionInstance, containerVariant: ContainerBlueprint | ContainerVariant, cancelPreview: boolean) => void;
+                    colorSchema: (definitionRegistration: VelcronSectionInstance, colorSchemaType: string, cancelPreview: boolean) => void;
+                    definition: (definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, cancelPreview: boolean) => void;
+                }) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
         };
         onFailure: {
-            setCategoryFilters: {
-                subscribe(fn: (failureReason: any, filters: guid[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setRendererTypeFilters: {
-                subscribe(fn: (failureReason: any, filters: guid[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setFixedContentWidth: {
-                subscribe(fn: (failureReason: any, width: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            showDefinitionSelector: {
-                subscribe(fn: (failureReason: any, preInsert: boolean, insertRelativeToActive?: boolean, changeDefinition?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            updateSection: {
-                subscribe(fn: (failureReason: any, section: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            toggleEditorToolbar: {
-                subscribe(fn: (failureReason: any, forceHide?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            addByRegistration: {
-                subscribe(fn: (failureReason: any, definition: VelcronDefinitionRegistration<object>, setAsActive?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            addBySection: {
-                subscribe(fn: (failureReason: any, definitions: VelcronSectionInstance[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            setActiveDefinition: {
-                subscribe(fn: (failureReason: any, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            deleteDefinition: {
-                subscribe(fn: (failureReason: any, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            deleteReferenceDefinition: {
-                subscribe(fn: (failureReason: any, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            removeActiveDefinition: {
+            selectorActions: {
                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            setSelectedDefinition: {
-                subscribe(fn: (failureReason: any, definition: VelcronSectionInstance) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            removeSelectedDefinition: {
+            filters: {
                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            setDragDropState: {
-                subscribe(fn: (failureReason: any, onGoingDragging: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            updateColorSchema: {
-                subscribe(fn: (failureReason: any, definitionRegistration: VelcronSectionInstance, colorSchemaType: string) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
-            };
-            previewContainerBlueprint: {
-                subscribe(fn: (failureReason: any, definitionRegistration: VelcronSectionInstance, containerVariant: ContainerVariant | ContainerBlueprint, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            settings: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            previewColorSchema: {
-                subscribe(fn: (failureReason: any, definitionRegistration: VelcronSectionInstance, colorSchemaType: string, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            editor: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            previewDefinition: {
-                subscribe(fn: (failureReason: any, definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, cancelPreview: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            section: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            changeDefinition: {
-                subscribe(fn: (failureReason: any, definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, toggle?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            definition: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
-            updateDefinition: {
-                subscribe(fn: (failureReason: any, definition: VelcronSectionInstance, velcronDefinition: VelcronAppDefinition<object>) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            preview: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
         };
     } & {
-        setCategoryFilters(filters: Array<guid>): void;
-        setRendererTypeFilters(filters: Array<guid>): void;
-        setFixedContentWidth(width: string): void;
-        showDefinitionSelector(preInsert: boolean, insertRelativeToActive?: boolean, changeDefinition?: boolean): void;
-        updateSection(section: VelcronSectionInstance): void;
-        toggleEditorToolbar(forceHide?: boolean): void;
-        addByRegistration(definition: VelcronDefinitionRegistration, setAsActive?: boolean): void;
-        addBySection(definitions: Array<VelcronSectionInstance>): void;
-        setActiveDefinition(definition: VelcronSectionInstance): void;
-        deleteDefinition(definition: VelcronSectionInstance): void;
-        deleteReferenceDefinition(definition: VelcronSectionInstance): any;
-        removeActiveDefinition(): void;
-        setSelectedDefinition(definition: VelcronSectionInstance): void;
-        removeSelectedDefinition(): void;
-        setDragDropState(onGoingDragging: boolean): void;
-        updateColorSchema(definitionRegistration: VelcronSectionInstance, colorSchemaType: string): void;
-        previewContainerBlueprint: (definitionRegistration: VelcronSectionInstance, containerVariant: ContainerBlueprint | ContainerVariant, cancelPreview: boolean) => void;
-        previewColorSchema: (definitionRegistration: VelcronSectionInstance, colorSchemaType: string, cancelPreview: boolean) => void;
-        previewDefinition: (definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, cancelPreview: boolean) => void;
-        changeDefinition(definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, toggle?: boolean): void;
-        updateDefinition(definition: VelcronSectionInstance, velcronDefinition: VelcronAppDefinition): void;
+        selectorActions: () => {
+            hideDefaultSelector: () => void;
+            remove: (id: guid) => void;
+            add: (action: BorderSelectorActionRegistration | Array<BorderSelectorActionRegistration>) => void;
+            run: (action: BorderSelectorActionRegistration, options: InsertOptions) => void;
+        };
+        filters: () => {
+            setRendererTypeFilters: (filters: Array<guid>) => void;
+            setCategoryFilters: (filters: Array<guid>) => void;
+        };
+        settings: () => {
+            setFixedContentWidth: (width: string) => void;
+        };
+        editor: () => {
+            showDefinitionSelector: (insertOptions: InsertOptions, selectionOptions?: DefinitionSelecttionOptions) => void;
+            toggleEditorToolbar: (forceHide?: boolean) => void;
+            setActiveDefinition: (definition: VelcronSectionInstance) => void;
+            removeActiveDefinition: () => void;
+            setSelectedDefinition: (definition: VelcronSectionInstance) => void;
+            removeSelectedDefinition: () => void;
+            setDragDropState: (onGoingDragging: boolean) => void;
+        };
+        section: () => {
+            update: (section: VelcronSectionInstance) => void;
+        };
+        definition: () => {
+            updateColorSchema: (definitionRegistration: VelcronSectionInstance, colorSchemaType: string) => void;
+            addByRegistration: (definition: VelcronDefinitionRegistration, insertOptions: InsertOptions, setAsActive?: boolean) => VelcronSectionInstance;
+            addBySection: (definitions: Array<VelcronSectionInstance>) => void;
+            delete: (definition: VelcronSectionInstance) => void;
+            deleteReference: (definition: VelcronSectionInstance) => any;
+            change: (definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, toggle?: boolean) => VelcronSectionInstance;
+            update: (definition: VelcronSectionInstance, velcronDefinition: VelcronAppDefinition) => void;
+        };
+        preview: () => {
+            containerBlueprint: (definitionRegistration: VelcronSectionInstance, containerVariant: ContainerBlueprint | ContainerVariant, cancelPreview: boolean) => void;
+            colorSchema: (definitionRegistration: VelcronSectionInstance, colorSchemaType: string, cancelPreview: boolean) => void;
+            definition: (definitionRegistration: VelcronSectionInstance, newDefinitionId: guid, cancelPreview: boolean) => void;
+        };
     };
 };
 export {};